[Leetcode Weekly Contest]311

链接：LeetCode

[Leetcode]2413. 最小偶倍数

给你一个正整数 n ，返回 2 和 n 的最小公倍数（正整数）。

根据题意，当 n 为奇数时，答案为 2n，当 n 为偶数时，答案为 n。

class Solution {
    public int smallestEvenMultiple(int n) {
        if((n & 1) == 0) return n;
        else return n<<1;
    }
}

[Leetcode]2414. 最长的字母序连续子字符串的长度

字母序连续字符串 是由字母表中连续字母组成的字符串。换句话说，字符串 "abcdefghijklmnopqrstuvwxyz" 的任意子字符串都是 字母序连续字符串 。
例如，"abc" 是一个字母序连续字符串，而 "acb" 和 "za" 不是。
给你一个仅由小写英文字母组成的字符串 s ，返回其 最长 的 字母序连续子字符串 的长度。

遍历即可。

class Solution {
    public int longestContinuousSubstring(String s) {
        int res = 1;
        int cur = 1;
        for(int i=1;i<s.length();++i) {
            if(s.charAt(i) == (char)(s.charAt(i-1)+1)) {
                cur ++;
                res = Math.max(res, cur);
            }
            else cur = 1;
        }
        return res;
    }
}

[Leetcode]2415. 反转二叉树的奇数层

给你一棵 完美 二叉树的根节点 root ，请你反转这棵树中每个 奇数 层的节点值。
例如，假设第 3 层的节点值是 [2,1,3,4,7,11,29,18] ，那么反转后它应该变成 [18,29,11,7,4,3,1,2] 。
反转后，返回树的根节点。
完美 二叉树需满足：二叉树的所有父节点都有两个子节点，且所有叶子节点都在同一层。
节点的 层数 等于该节点到根节点之间的边数。

BFS或者DFS。
BFS 这棵树，对于奇数层，直接交换层里面的所有元素值（交换的是元素值，不是节点）。DFS依然是交换值的思路，通过同时递归左右子树实现。

/**
 * 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 TreeNode reverseOddLevels(TreeNode root) {
        dfs(root.left, root.right, true);
        return root;
        // return bfs(root);
    }

    // DFS
    public void dfs(TreeNode node1, TreeNode node2, boolean isOdd) {
        if(node1 == null) return;
        if(isOdd) {
            node1.val = node1.val ^ node2.val;
            node2.val = node1.val ^ node2.val;
            node1.val = node1.val ^ node2.val;
        }
        dfs(node1.left, node2.right, !isOdd);
        dfs(node1.right, node2.left, !isOdd);
    }

    // BFS
    public TreeNode bfs(TreeNode root) {
        Deque<TreeNode> q = new ArrayDeque<>();
        q.offer(root);
        boolean isOdd = false;
        while(!q.isEmpty()) {
            ArrayList<TreeNode> list = new ArrayList<>();
            int n = q.size();
            // Note that q.size() will increase when offered
            for(int i=0;i<n;++i) {
                TreeNode node = q.poll();
                if(node.left != null) {
                    q.offer(node.left);
                    q.offer(node.right);
                    list.add(node.left);
                    list.add(node.right);
                }
            }
            if(!isOdd) swap(list);
            isOdd = !isOdd;
        }
        return root;
    }

    public void swap(List<TreeNode> list) {
        int n = list.size();
        for(int i=0;i<n/2;++i) {
            int tmp = list.get(i).val;
            list.get(i).val = list.get(n-1-i).val;
            list.get(n-1-i).val = tmp;
        }
    }
}

[Leetcode] 2416. 字符串的前缀分数和

给你一个长度为 n 的数组 words ，该数组由 非空 字符串组成。
定义字符串 word 的 分数 等于以 word 作为 前缀 的 words[i] 的数目。
例如，如果 words = ["a", "ab", "abc", "cab"] ，那么 "ab" 的分数是 2 ，因为 "ab" 是 "ab" 和 "abc" 的一个前缀。
返回一个长度为 n 的数组 answer ，其中 answer[i] 是 words[i] 的每个非空前缀的分数 总和 。
注意：字符串视作它自身的一个前缀。

用字典树存储所有字符串，由于每个节点都是其子树节点的前缀，题干中的分数就是在字符串插入字典树的过程中，经过该节点的字符串个数，即以该节点为前缀的字符串的个数。

class Node {
    HashMap<Character, Node> children = new HashMap<>();;
    int score = 0;
}

class TrieTree {
    Node root = new Node();

    public void insert(String word) {
        Node cur = root;
        for(var ch:word.toCharArray()) {
            if(!cur.children.containsKey(ch)) cur.children.put(ch, new Node());
            cur = cur.children.get(ch);
            cur.score ++;
        }
    }

    public int searchScore(String word) {
        int res = 0;
        Node cur = root;
        for(var ch:word.toCharArray()) {
            if(!cur.children.containsKey(ch)) break;
            cur = cur.children.get(ch);
            res += cur.score;
        }
        return res;
    }
}

class Solution {
    public int[] sumPrefixScores(String[] words) {
        TrieTree tree = new TrieTree();
        for(var word:words) {
            tree.insert(word);
        }
        int n = words.length;
        int[] res = new int[n];
        for(int i=0;i<n;++i) {
            res[i] = tree.searchScore(words[i]);
        }
        return res;
    }
}

参考：
LeetCode