LeetCode第 311 场周赛前三题https://leetcode.cn/contest/weekly-contest-311/

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

示例 1：

输入：n = 5
输出：10
解释：5 和 2 的最小公倍数是 10 。
示例 2：

输入：n = 6
输出：6
解释：6 和 2 的最小公倍数是 6 。注意数字会是它自身的倍数。
 

提示：

1 <= n <= 150

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/smallest-even-multiple
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
```java
class Solution {
    public int smallestEvenMultiple(int n) {
        if(n%2 != 0){
            return n*2;
        }else{
            return n;
        }
    }
}

#6181. 最长的字母序连续子字符串的长度
字母序连续字符串 是由字母表中连续字母组成的字符串。换句话说，字符串 “abcdefghijklmnopqrstuvwxyz” 的任意子字符串都是 字母序连续字符串 。

例如，“abc” 是一个字母序连续字符串，而 “acb” 和 “za” 不是。
给你一个仅由小写英文字母组成的字符串 s ，返回其 最长 的 字母序连续子字符串 的长度。

示例 1：

输入：s = “abacaba”
输出：2
解释：共有 4 个不同的字母序连续子字符串 “a”、“b”、“c” 和 “ab” 。
“ab” 是最长的字母序连续子字符串。
示例 2：

输入：s = “abcde”
输出：5
解释：“abcde” 是最长的字母序连续子字符串。

提示：

1 <= s.length <= 105
s 由小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/length-of-the-longest-alphabetical-continuous-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
O(n^2)解法：

class Solution {
    public int longestContinuousSubstring(String s) {
        if(s.length() == 1) return 1;
        int len = 1;
        int n = s.length();
        // O(n^2)判是否连续
        for(int i = 0;i<n;i++){
            int temp = i;
            for(int j = i+1;j<n;j++){
                if((s.charAt(j)-'a')-(s.charAt(i)-'a') == 1){
                    len = Math.max(len,j-temp+1);
                    i = j;
                }else{
                    break;
                }
            }
            i = temp;
        }
        return len;
    }
}```
O(n）解法：
```java
class Solution {
    public int longestContinuousSubstring(String s) {
        char[] ss = s.toCharArray();
        int max = 1,dp = 1;
        for(int i=1;i<ss.length;i++){
            if(ss[i] == ss[i-1] + 1){
                dp++;//滚动数组
                max = Math.max(max,dp);
            }else{
                dp = 1;
            }
        }
        return max;
    }
}

#6182. 反转二叉树的奇数层
给你一棵 完美 二叉树的根节点 root ，请你反转这棵树中每个 奇数 层的节点值。

例如，假设第 3 层的节点值是 [2,1,3,4,7,11,29,18] ，那么反转后它应该变成 [18,29,11,7,4,3,1,2] 。
反转后，返回树的根节点。

完美 二叉树需满足：二叉树的所有父节点都有两个子节点，且所有叶子节点都在同一层。

节点的 层数 等于该节点到根节点之间的边数。

示例 1：

输入：root = [2,3,5,8,13,21,34]
输出：[2,5,3,8,13,21,34]
解释：
这棵树只有一个奇数层。
在第 1 层的节点分别是 3、5 ，反转后为 5、3 。
示例 2：

输入：root = [7,13,11]
输出：[7,11,13]
解释：
在第 1 层的节点分别是 13、11 ，反转后为 11、13 。
示例 3：

输入：root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
输出：[0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
解释：奇数层由非零值组成。
在第 1 层的节点分别是 1、2 ，反转后为 2、1 。
在第 3 层的节点分别是 1、1、1、1、2、2、2、2 ，反转后为 2、2、2、2、1、1、1、1 。

提示：

树中的节点数目在范围 [1, 214] 内
0 <= Node.val <= 105
root 是一棵 完美 二叉树

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

class Solution {
    public TreeNode reverseOddLevels(TreeNode root) {
        if (root == null) {
            return root;
        }
        int count = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        // 用栈是一样的
        Stack<Integer> levelVal = new Stack<>();
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode poll = queue.poll();
                if (count % 2 == 1) {
                    poll.val = levelVal.pop();
                }
                if (poll.left != null) {
                    queue.add(poll.left);
                    if(count % 2 == 0){
                        levelVal.push(poll.left.val);
                    }
                }
                if (poll.right != null) {
                    queue.add(poll.right);
                    if(count % 2 == 0){
                        levelVal.push(poll.right.val);
                    }
                }
            }
            count++;
            // 优美
        }
        return root;
    }
}