计数二进制字串（简单题） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。

重复出现的子串要计算它们出现的次数。

示例 1 :

输入: "00110011"
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。

请注意，一些重复出现的子串要计算它们出现的次数。

另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。
示例 2 :

输入: "10101"
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。
注意：

s.length 在1到50,000之间。
s 只包含“0”或“1”字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-binary-substrings
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

菜鸡一个，自己写的超时了，看别人写的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class SameSubString {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        System.out.println(countBinarySubstrings(s));

    }

    public static int countBinarySubstrings(String s) {
        // pre 前一个数字连续出现的次数，cur 当前数字连续出现的次数，result 结果子串个数
        int pre = 0, cur = 1, result = 0;
        for (int i = 0, len = s.length() - 1; i < len; i++) {
            // 判断当前数字是否与后一个数字相同
            if (s.charAt(i) == s.charAt(i+1)) { // 相同，则当前数字出现的次数cur加1
                cur++;
            } else { // 不同，则当前数字事实上变成了前一个数字，当前数字的次数重置为1
                pre = cur;
                cur = 1;
            }
            if (pre >= cur) { // 前一个数字出现的次数 >= 后一个数字出现的次数，则一定包含满足条件的子串
                result++;
            }
        }
        return result;
    }
}

展开全文 >>

树遍历问题（简单题）

相同的树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true
示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false
示例 3:

输入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/same-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。


简单题没有什么弯弯绕绕，也没有时间限制，如果不用递归的话，内存消耗或许能减少一些。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        return preIteration(p,q);
    }
    public static boolean preIteration(TreeNode p, TreeNode q){
        boolean flag=true;
        if(null!=p &&null!=q){
            if(p.val!=q.val){
                return false;
            }
            flag=preIteration(p.left,q.left);
            if(flag==false){
                return false;
            }
            flag=preIteration(p.right,q.right);
            if(flag==false){
                return false;
            }

        }else if(null !=p||null!=q){
            return false;
        }
        return true;


    }
}

展开全文 >>

二叉搜索树（困难题）

二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的
二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为
二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

对二叉搜索树进行中序遍历的时候访问到的元素是从小到大顺序排列的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
二叉搜索树中的两个节点被错误地交换。

请在不改变其结构的情况下，恢复这棵树。

示例 1:

输入: [1,3,null,null,2]

   1
  /
 3
  \
   2

输出: [3,1,null,null,2]

   3
  /
 1
  \
   2
示例 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3
进阶:

使用 O(n) 空间复杂度的解法很容易实现。
你能想出一个只使用常数空间的解决方案吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/recover-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

别人的写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

    // 中序遍历过程中，记录错误两个错误排序节点，最后进行交换
    /*
    中序遍历过程中，记录错误两个错误排序节点，最后进行交换
    只需要中序遍历一遍就可以了

    首先我们来看中序遍历过程模板
    public void inorder(TreeNode root){
            if (root == null) return ;    //终止条件
            inorder(root.left);           //访问左子树
            对当前节点进行一些操作          //访问根节点-----在遍历过程中希望实现的操作
            inorder(root.right);          //访问右子树
        }

    另一方面我们知道 对二叉搜索树进行 中序遍历的时候 访问到的元素是从小到大顺序排列的
    如我们对实例 2 恢复好的树 进行中序遍历 得到的应该是  1 2 3 4

    那这道题我们就有了大致思路
    我们对错误的二叉树进行 中序遍历 那我们按顺序访问到的数应该是按顺序排列的
    那如果对两个节点交换了顺序  那一定有两个地方是  不满足  前一个元素 < 当前元素 < 后一个元素
     如示例2      3，  1，  4， null， null， 2：
                 中序遍历结果是：1，3，2，4
                  3  这个节点不满足      2 这个节点不满足
                 所以我们使用两个全局变量在遍历过程中记录这两个节点 最后对他们进行交换
     */
class Solution {
    TreeNode t1, t2, pre;
    public void recoverTree(TreeNode root) {
        inorder(root);
        int temp = t1.val;
        t1.val = t2.val;
        t2.val = temp;
    }
    public void inorder(TreeNode root){
        if (root == null) return ;
        inorder(root.left);
        if (pre != null && pre.val > root.val) {
            if (t1 == null) t1 = pre;
            t2 = root;
        }
        pre = root;
        inorder(root.right);
    }
}

展开全文 >>

回文问题（困难题）

回文对

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

给定一组 互不相同 的单词， 找出所有不同 的索引对(i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。

示例 1：

输入：["abcd","dcba","lls","s","sssll"]
输出：[[0,1],[1,0],[3,2],[2,4]] 
解释：可拼接成的回文串为 ["dcbaabcd","abcddcba","slls","llssssll"]
示例 2：

输入：["bat","tab","cat"]
输出：[[0,1],[1,0]] 
解释：可拼接成的回文串为 ["battab","tabbat"]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

java暴力解法，通过了所有测试点，但是超时了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.*;
//“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。
public class Reword {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<String> slist = new ArrayList<>();
        while (sc.hasNext()) {

            String s = sc.next();
            if (s.equals("1")) {
                break;
            }
            System.out.println(s);

            slist.add(s);

        }

        String[] words = new String[slist.size()];
        for (int i = 0; i < slist.size(); i++) {
            words[i] = slist.get(i);
        }

        List<List<Integer>> result = palindromePairs(words);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i).get(0) + "\t" + result.get(i).get(1));
        }
    }

    public static List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> outerList = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            for (int j = i + 1; j < words.length; j++) {
                if (isReword(words[i] + words[j])) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    list.add(j);
                    outerList.add(list);
                }
                if (isReword(words[j] + words[i])) {
                    List<Integer> list = new ArrayList<>();
                    list.add(j);
                    list.add(i);
                    outerList.add(list);
                }

            }
        }
        return outerList;
    }


    public static boolean isReword(String word) {
//        加上注释多通过10多个测试点
//        if (word.length() == 0) {
//            return false;
//        }
//        这样写效率更低
//        if(word.equals(new StringBuffer(word).reverse().toString())){
//            return true;
//        }else{
//            return false;
//        }
//        通过了所有测试点但是还是超时
        int length = word.length() - 1;
        for (int i = 0; i < word.length() / 2; i++) {
            if (word.charAt(i) != word.charAt(length - i)) {
                return false;
            }
        }
        return true;
    }
}

别人的解法：使用字典树和哈希表两种方法

参考文献
LeetCode（336）：回文对 Palindrome Pairs（Java）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
//        字典树解法
//
//        从后往前反方向遍历所有单词，构建一棵后缀树（存储翻转的单词）。后缀树的有两个额外成员：
//        reverseWordIdx用于存放翻转单词的单词序号，容器palindPrefixWords存放该结点处除去后缀其余部分能形成回文前缀[0,i]的单词序号。
//        从前往后遍历单词curWord的进行校验。
//
//        如果字典中恰存在一个与curWord[0,j-1]互为翻转的单词reverseWord，且剩余部分curWord[j,end]恰为回文子串，则一定能组合成
//        curWord[0,j-1]+curWord[j,end]+reverseWord[0,end]的回文串。
//
//
//        若遍历结束结点仍不空，说明curWord[0,end]恰与字典中其他单词的部分后缀[j,end]互为翻转。除去翻转后缀后其余部分[0,j-1]能够形成回文的单词palindPrefixWord一定能与curWord构成
//        curWord[0,end]+palindPrefixWord[0,j-1]+palindPrefixWord[j,end]的回文串（j-1=0时为空回文子串，字典中恰有两个单词互为翻转）。


class PalindromePairs {

    //字典树
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> result = new ArrayList<>();
        TrieNode root = new TrieNode();
        for(int i = 0; i < words.length; i++){
            addWord(root, words[i], i);
        }
        for(int i = 0; i < words.length; i++){
            search(words, i, root, result);
        }
        return result;
    }

    private class TrieNode{
        TrieNode[] children;
        int reverseWordIdx;
        List<Integer> palindPrefixWords;
        TrieNode(){
            children = new TrieNode[26];
            reverseWordIdx = -1;
            palindPrefixWords = new ArrayList<>();
        }
    }

    //构建后缀树
    private void addWord(TrieNode root, String word, int curWordIdx){
        //从前往后遍历每一个字符i进行建树
        for(int i = word.length() - 1; i >= 0; i--){
            int loc = word.charAt(i) - 'a';
            if(root.children[loc] == null){
                root.children[loc] = new TrieNode();
            }
            //palindPrefixWords存放在i处除去后缀其余部分能形成回文前缀[0,i]的单词序号
            if(isPalindrome(word, 0, i)){
                root.palindPrefixWords.add(curWordIdx);
            }
            root = root.children[loc];
        }
        //考虑前缀为空串时[0,0]也是回文串，尾结点处palindPrefixWords添加curWordIdx
        root.palindPrefixWords.add(curWordIdx);
        //尾结点的reverseWordIdx存放翻转单词的单词序号
        root.reverseWordIdx = curWordIdx;
    }

    private void search(String[] words, int curWordIdx, TrieNode node, List<List<Integer>> result){
        //从前往后遍历单词curWord的进行校验
        for(int j = 0; j < words[curWordIdx].length(); j++){
            //如果字典中恰存在一个与curWord[0,j-1]互为翻转的单词reverseWord，且剩余部分curWord[j,end]恰为回文子串
            //则一定能组合成curWord[0,j-1]+curWord[j,end]+reverseWord[0,end]的回文串
            if(node.reverseWordIdx >= 0 && isPalindrome(words[curWordIdx], j, words[curWordIdx].length() - 1)){
                result.add(Arrays.asList(curWordIdx, node.reverseWordIdx));
            }
            node = node.children[words[curWordIdx].charAt(j) - 'a'];
            //若后缀路径遇到空值则停止校验并返回
            if(node == null){
                return;
            }
        }
        //若遍历结束结点仍不空，说明curWord[0,end]恰与字典中其他单词的部分后缀[j,end]互为翻转
        //除去翻转后缀后其余部分[0,j-1]能够形成回文的单词palindPrefixWord一定能与curWord构成
        //curWord[0,end]+palindPrefixWord[0,j-1]+palindPrefixWord[j,end]的回文串（j-1=0时为空回文子串，字典中恰有两个单词互为翻转）
        for(int palindPrefixWordIdx : node.palindPrefixWords){
            //排除自身构成回文的重复情况
            if(curWordIdx != palindPrefixWordIdx){
                result.add(Arrays.asList(curWordIdx, palindPrefixWordIdx));
            }
        }
    }

    private boolean isPalindrome(String word, int begin, int end){
        while(begin < end){
            if(word.charAt(begin++) != word.charAt(end--)){
                return false;
            }
        }
        return true;
    }
}

展开全文 >>

动态规划问题（有条件选择树的最优节点） 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \ 
     3   1

输出: 7 
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

     3
    / \
   4   5
  / \   \ 
 1   3   1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

使用贪心算法没有求得最优解，局部最优不是全局最优.
以下是别人写的一种比较好理解的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public static void main(String[] args) {

    Scanner sc=new Scanner(System.in);
    String s=sc.nextLine();
    String[] arr = s.split(",");
    TreeNode root = new TreeNode(Integer.parseInt(arr[1]));
    create(arr, 1, root);
    rob(root)
}


public static void create(String[] arr, int index, TreeNode node) {
    if (2 * index < arr.length && (!arr[2 * index].equals("null"))) {
        //生成左子树
        node.left = new TreeNode(Integer.parseInt(arr[2 * index]));
        // System.out.println(node.left.val);
        // System.out.println("index is\t"+(2*index));
        create(arr, 2 * index, node.left);
    }

    if (2 * index + 1 < arr.length && (!arr[2 * index + 1].equals("null"))) {
        //生成右子树
        node.right = new TreeNode(Integer.parseInt(arr[2 * index + 1]));
        // System.out.println(node.right.val);
        // System.out.println("index is\t"+(2*index+1));
        create(arr, 2 * index + 1, node.right);
    }

}

public static int rob(TreeNode root) {

    //动态规划
    //思路：
    //定义一个数组res,长度为2,res[0]表示不抢该节点可获得最大值,res[1]表示抢劫该节点可获得最大值
    //方法helper(r)意为：在以r为根节点的树中,返回抢劫根节点与不抢劫根节点可获得的最大值
    int[] res = helper(root);
    return Math.max(res[0],res[1]);
}
public static int[] helper(TreeNode node){
    if(node == null) return new int[2];//边界条件，r为null时，跳出
    int[] left = helper(node.left);//对于以node.left为根的树，计算抢劫根节点(node.left)与不抢劫根节点可获得最大金额.
    // left[0]则为不抢node.left可获得的最大金额,left[1]则为抢劫node.left可获得的最大金额  以下right[] 分析同理
    int[] right = helper(node.right);
    int[] res = new int[2];
    res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);//计算不抢劫当前根节点可获得的最大金额(那么其左右子树可以随便抢)
    res[1] = node.val + left[0] + right[0];//计算若抢劫根节点可获得的最大金额(此时,其左右子树的根节点不能被抢)
    return res;
}



展开全文 >>

字符串大数加法

415. 字符串相加

难度：简单

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

提示：

  1. num1 和num2 的长度都小于 5100
  2. num1 和num2 都只包含数字 0-9
  3. num1 和num2 都不包含任何前导零
  4. 你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式

别人的解法，学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        int carry = 0, i = num1.length()-1, j = num2.length()-1;

        while(i >= 0 || j >= 0 || carry != 0){
            if(i>=0) carry += num1.charAt(i--)-'0';//如果数组1没有结束，加上进位
            if(j>=0) carry += num2.charAt(j--)-'0';//如果数组2没有结束，加上进位
            sb.append(carry%10);//当前位的值是carry%10，倒序输入的
            carry /= 10;//下一位的进位值是carry /= 10
        }
        return sb.reverse().toString();//正序输出
    }
}

展开全文 >>

拓扑排序 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]

给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？

 示例 1:

输入: 2, [[1,0]] 
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
 

提示：

输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5

开始时没考虑入度问题，导致时间复杂度太高，无法ac，看了别人的解法发现
使用入度计算可以大大减少复杂度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {

        int[] res = new int[numCourses];
        int[] indegree = new int[numCourses];

        // get the indegree for each course
        for(int[] pre : prerequisites) {
            indegree[pre[0]] ++;
        }

        // put courses with indegree == 0 to queue
        Queue<Integer> queue = new ArrayDeque<>();
        for(int i = 0; i < numCourses; i++) {
            if(indegree[i] == 0) {
                queue.offer(i);//没有前驱的先加入到队列中
            }
        }

        int i = 0;
        while(!queue.isEmpty()) {
            Integer curr = queue.poll();//返回第一个元素，并在队列中删除
            res[i++] = curr;

            for(int[] pre : prerequisites) {
                if(pre[1] == curr) {//如果有以该没有前驱的课程为依赖的课程那么他的前驱减少1
                    indegree[pre[0]] --;
                    if(indegree[pre[0]] == 0) {//如果减少之后没有前驱了，那么加入队列
                        queue.offer(pre[0]);
                    }
                }
            }
        }
        if(i==numCourses) {
            return true;
        }else {
            return false;
        }

    }

}

参考文献
一文搞懂「拓扑排序」

来源：力扣（LeetCode）

展开全文 >>

pip 安装其余包时出错

安装其他包时出现了这个错误，强制重新安装pip解决了我的问题

1
2
3
4
5
6
Traceback (most recent call last):
  File "/home/vector/.local/bin/pip", line 7, in <module>
    from pip._internal.cli.main import main
ImportError: No module named _internal.cli.main


我的解决方案：

1
sudo -H python get-pip.py --force-reinstall

展开全文 >>

python多进程类内部回调函数

python多进程中，如果回调函数需要写类的属性，那么该类的属性应该设置为多进程共享变量，否则在回调函数中将无法写入该类变量，其余函数访问到的数据仍然是该回调函数写入之前的数据。

不同的进程默认有自己独立的内存空间，互相之间不能直接访问。所以，通常的全局变量或者传递参数，在创建新进程时，都是拷贝一份到新进程里使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import multiprocessing
#截取的部分代码   截取的部分代码    截取的部分代码
class Moudle(object):
    control_flag=multiprocessing.Value("i",-1)#多进程共享变量
    #control_flag=-1#这种写法是有问题的，在多进程情况下无法修改该变量的值
    def on_message(self,client, userdata, msg):#回调函数返回消息时调用该方法
        self.control_flag.value = msg.data['index']
        #self.control_flag=msg.data['index']#这种写法是有问题的，在多进程情况下无法修改该变量的值
        print("control_flag",self.control_flag)

#截取的部分代码   截取的部分代码    截取的部分代码
class Env(gym.Env):
    def __init__(self, name):
        self.mqtt_util=Moudle()
    
    def step():
        """
        程序逻辑
        """
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import multiprocessing
from environment import Env
os.environ["OMP_NUM_THREADS"] = "1"

class Worker(mp.Process):
    def __init__(self):  #
        super(Worker, self).__init__()
        self.env = Env(0)

    def run(self):
        for i in range(100):
            done = self.env.step()
            while not done:
                 done =self.env,step()

if __name__ == "__main__":
    workers = [Worker()for i in range(1)]
    [w.start() for w in workers]

参考文献
multiprocessing中的共享变量

展开全文 >>

科研小装备

一些好用的软件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
文献管理软件：mendeley
图片公式转latex公式软件：Mathpix Snpping tool（每月免费50次）
记事本软件：OneNote
读书软件：calibre（epub,azw3等格式都支持）
win10商店阅读epub：freda
win10商店阅读PDF：PDF Reader by Xodo
win10pdf阅读编辑软件：Abdobe Acrobat DC（需要激活）
翻译软件：QTranslate、沙拉查词（chrome和firefox插件，可以边看pdf边翻译）
ppt插件：iSlide（统一字体，排版等操作）
远程协助软件：teamviewer
win10下文档搜索软件：everything
win10下压缩软件：bandizip
win10下视频软件：potPlayer
win10网络监控软件：TrafficMonitor
Win10CPU频率控制软件：throttlestop

***
查看源码
sourcetrail工具
推荐一个网站 https://elixir.bootlin.com/linux/latest/source

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我是一只<br>又水又笨又菜的<br>菜狗子<br>希望有一天被领走