leetcode 第100场周赛

https://leetcode.com/contest/weekly-contest-100

1、Monotonic Array

判断是否是单调数列

class Solution {
    boolean check1(int[] A) {
        for (int i = 1; i < A.length; i++) {
            if (A[i - 1] > A[i]) {
                return false;
            }
        }
        return true;
    }

    boolean check2(int[] A) {
        for (int i = 1; i < A.length; i++) {
            if (A[i - 1] < A[i]) {
                return false;
            }
        }
        return true;
    }

    public boolean isMonotonic(int[] A) {
        return (check1(A) || check2(A));
    }
}

2、Increasing Order Search Tree

把一个二叉树按照中序遍历变为一棵树（具体看题目），只有右子树，没有左子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    List r = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root) {
        if (root == null) return null;
        dfs(root);
        for (int i = 0; i < r.size() - 1; i++ ) {
            TreeNode treeNode = r.get(i);
            treeNode.left = null;
            treeNode.right = r.get(i + 1);
        }
        r.get(r.size() - 1).left = null;
        r.get(r.size() - 1).right = null;
        return r.get(0);
    }

    private void dfs(TreeNode root) {
        if (root == null) return;
        dfs(root.left);
        r.add(root);
        dfs(root.right);
    }
}

3、Bitwise ORs of Subarrays

给一个数组，求任何一个子数组的异或值有多少种

做法：考虑以每个数为结尾的子数组

数组为{1, 2, 3, 4, 5}

1

12 2

123 23 3

1234 234 34 4

12345 2345 345 45 5

这样来计算的时候，每次维护上次以a[i]为结尾的子数组得到的异或值，那么异或上a[i+1]就是下一行的结果。

复杂度不会分析，看别人博客说是O(32N)

class Solution {
    public int subarrayBitwiseORs(int[] A) {
        //结果
        Set res = new HashSet<>();
        //每次以上个数为最后一个数的子数组所得到的或值的集合
        Set set = new HashSet<>();
        for (int x : A) {
            Set tmp = new HashSet<>();
            tmp.add(x);
            set.stream().forEach(e -> tmp.add(e | x));
            res.addAll(tmp);
            set.clear();
            set.addAll(tmp);
        }
        return res.size();
    }
}

4、Orderly Queue

题意：

给了一个字符串，和一个K值。每次可以选择前k个字符中的一个放在末尾，求出可以得到的最小字符串。

做法：如果k=1，可以暴力来做（实际有更好的做法），可以在O(N)里算出来结果，这个不做展开。

如果k=2，稍微思考下可以知道，可以得到原字符串的任意排列。

class Solution {
    public String orderlyQueue(String S, int K) {
        if (K > 1) {
            char[] cs = S.toCharArray();
            Arrays.sort(cs);
            return new String(cs);
        } else {
            int len = S.length();
            S = S + S;
            String res =S;
            for (int i = 0; i < len; i++ ) {
                String sub = S.substring(i, i + len);
                if (sub.compareTo(res) < 0) res = sub;
                        
            }
            return res;
        }
    }
}