896. Monotonic Array

https://leetcode.com/contest/weekly-contest-100/problems/monotonic-array/
這道題就是判斷是不是單調非減或單調非增。要注意的是邊界條件。

public boolean isMonotonic(int[] A) {
        int l = A.length;
        if(l == 1) return true;
        Boolean up = null;
        for(int i = 0; i < l-1; i++){
            if(A[i] == A[i+1]) continue;
            if(up == null){
                up = A[i] < A[i+1];
            }else if((A[i] < A[i+1]) != up) return false;
        }
        return true;
    }

897. Increasing Order Search Tree

https://leetcode.com/contest/weekly-contest-100/problems/increasing-order-search-tree/
這道題要按順序構成BST，那么其實就是把BST通過中序遍歷，轉換為鏈表，同時不用左孩子。

List<TreeNode> l = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root) {
        if(root == null) return null;
        inOrder(root);
        for(int i = 0; i < l.size()-1; i++){
            TreeNode cur = l.get(i);
            cur.left = null;
            cur.right = l.get(i+1);
        }
        return l.get(0);
    }
    private void inOrder(TreeNode root){
        if(root == null) return ;
        inOrder(root.left);
        l.add(root);
        inOrder(root.right);
    }

優化下解法,把LIST 的空間給節約了

TreeNode pre = null;
    TreeNode r = null;
    public TreeNode increasingBST(TreeNode root) {
        if(root == null) return null;
        inOrder(root);
        pre.left = null;
        pre.right = null;
        return r;
    }
    private void inOrder(TreeNode root){
        if(root == null) return ;
        inOrder(root.left);
        if(r == null) r = root;
        if(pre != null){
            pre.left = null;
            pre.right = root;
        }
        pre = root;
        inOrder(root.right);
    }

898. Bitwise ORs of Subarrays

https://leetcode.com/contest/weekly-contest-100/problems/bitwise-ors-of-subarrays/
這道題消耗了我大量時間，感覺比HARD的那道還要難些。HARD的難道，就一個TRICK其實挺簡單。
我們來分析下這道。
常規的暴力解法就是N^2,在50000的數據量下一定不過。
想到位運算，就想到能否用到常數32，隨后接著想或運算，是只加不減。就是你沒法通過或運算來讓一個大的數變小。
根據這個性質我們知道，對一個數來說，他最大能變到的就是每個位都置為1了。那么這個時間復雜度就能變成O 32N
時間復雜度夠了。我們該怎么求解呢。
用常規O N^2的解法，最后一次遍歷，也就是最后一個單獨元素加進SET里。
那么我可以反過來處理這個情況。先從最后一個單獨元素開始，再從每一次產生的解，去和左邊的那個元素或。又產生一批新的后。再放進去總結果集，依次循環。

public int subarrayBitwiseORs(int[] A) {
        int l = A.length;
        Set<Integer> s = new HashSet<>();
        Set<Integer> pre = new HashSet<>();
        for(int i = l-1; i >= 0; i--){
            int cur = A[i];
            Set<Integer> now = new HashSet<>();
            now.add(cur);
            for(int j : pre){
                now.add((j|cur));
            }
            for(int j : now) s.add(j);
            pre = now;
        }
        return s.size();
    }

思考 如果是AND 應該怎么改這個算法呢？

public int subarrayBitwiseORs(int[] A) {
        int l = A.length;
        Set<Integer> s = new HashSet<>();
        Set<Integer> pre = new HashSet<>();
        for(int i = l-1; i >= 0; i--){
            int cur = A[i];
            Set<Integer> now = new HashSet<>();
            now.add(cur);
            for(int j : pre){
                now.add((j&cur));
            }
            for(int j : now) s.add(j);
            pre = now;
        }
        return s.size();
    }

899. Orderly Queue

https://leetcode.com/problems/orderly-queue/description/
這道題就是給你個K，說只有前K個，你可以挑一個移動到最后，然后可以移動任意次。求最小的字母序。
當K>=2，證明等價于可以交換任意2個字母。
我們假設要交換的2個字母0<=i < j <l。 分別是第I個 和 第J個。
就會有如下結構
數組結構： [L] I [M] J [R]
一直把第一個放到最后 -》I [M] J [R][L]
一直把第二個放到最后-》I J [R][L][M]
把I 放最后 -》J [R][L][M] I
永遠把第二個放到最后 -》 J [M] I [R] [L]
一直把第一個放最后 -》 [L] J[M] I [R]
完成。

public String orderlyQueue(String S, int K) {
        String min = S;
        if(K == 1){
            for(int i = 1; i < S.length(); i++){
                String cur = S.substring(1)+S.charAt(0);
                if(cur.compareTo(min)<0) min = cur;
                S = cur;
            }
            return min;
        }
        char[] cs = S.toCharArray();
        Arrays.sort(cs);
        String tar = new String(cs);
        return tar;
    }