2022-09-18 第 311 场周赛

6180. 最小偶倍数

class Solution {
    public int smallestEvenMultiple(int n) {
        if (n % 2 == 0) {
            return n;
        }
        if (n == 1) {
            return 2;
        } else {
            return 2*n;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

6181. 最长的字母序连续子字符串的长度

动态规划

class Solution {
    public int longestContinuousSubstring(String s) {
        int n = s.length();
        int[] dp = new int[n];
        dp[0] = 1;
        int ans = 1;
        for (int i = 1; i < n; i++) {
            dp[i] = 1;
            if (s.charAt(i) == s.charAt(i-1) + 1) {
                dp[i] = dp[i-1] + 1;
            }
            ans = Math.max(ans,dp[i]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6182. 反转二叉树的奇数层

层序遍历，拿到奇数层反转之后的数值列表，然后生成二叉树

class Solution {
    public TreeNode reverseOddLevels(TreeNode root) {
        boolean even = true;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        List<Integer> ans = new ArrayList<>();
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            add(ans,list,even);
            if (even) {
                even = false;
            } else {
                even = true;
            }
        }
        TreeNode newRoot = buildTree(ans,1);
        return newRoot;
    }
    
    public void add(List<Integer> ans, List<Integer> list, boolean even) {
        if (even) {
            for (Integer num : list) {
                ans.add(num);
            }
        } else {
            for (int i = list.size() - 1; i >= 0; i--) {
                ans.add(list.get(i));
            }
        }
    }
    
    public TreeNode buildTree(List<Integer> ans,int index) {
        if (index > ans.size()) {
            return null;
        }
        TreeNode root = new TreeNode(ans.get(index-1));
        root.left = buildTree(ans,index * 2);
        root.right = buildTree(ans,index * 2 + 1);
        return root;
    }
}
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

6183. 字符串的前缀分数和

前缀树的应用

class Solution {
    class preTree {
        preTree[] arr;
        int times;
        preTree () {
            arr = new preTree[26];
            times = 0;
        }
    }
    public int[] sumPrefixScores(String[] words) {
        preTree root = new preTree();
        preTree cur = root;
        for (String s : words) {
            cur = root;
            for (char c : s.toCharArray()) {
                if (cur.arr[c-'a'] == null) {
                    cur.arr[c-'a'] = new preTree();
                }
                cur = cur.arr[c-'a'];
                cur.times += 1;
            }
        }
        int[] ans = new int[words.length];
        
        for (int i = 0; i < ans.length; i++) {
            int count = 0;
            cur = root;
            for (char c : words[i].toCharArray()) {
                cur = cur.arr[c-'a'];
                count += cur.times;
            }
            ans[i] = count;
        }
        return ans;
    }
}
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