【leetcode】Weekly Contest 91

　　leetcode周赛，早上起来发现没网，用热点意识模糊的a了三个水题。

1.Lemonade Change

　　简单模拟题，收到十元用五元钱找回，收到20元时优先用一张10一张5，如果10不够用3张5，如果没有就返回flase（贪心）。

    public boolean lemonadeChange(int[] bills) {
        int five = 0;
        int ten = 0;
        int twenty = 0;
        for (int i = 0; i < bills.length; i++) {
            if (bills[i] == 5) {
                five++;
            } else if (bills[i] == 10) {
                if (five > 0) {
                    five--;
                    ten++;
                } else {
                    return false;
                }
            } else if (bills[i] == 20) {
                if (ten > 0 && five > 0) {
                    five--;
                    ten--;
                    twenty++;
                } else if (five >= 3) {
                    five -= 3;
                    twenty++;
                } else {
                    return false;
                }
            }
        }
        return true;
    }

2.All Nodes Distance K in Binary Tree

　　找到target的位置，根据左（0）右（1）记录路径，再遍历（我用的是先根）一遍整颗树，每个点与target的距离是其“两点的深度和”减去“公共前缀的两倍”，判断是否与K相等即可。

    public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
        String t = findTarget(root,target,new String());
        return helper(root, K,t, new LinkedList<>(), new String());
    }
    public List<Integer> helper(TreeNode root,int k,String target,List<Integer> res,String s){//先根遍历
        if(root!=null){
            if(disK(target, s.toString(), k)){
                res.add(root.val);
            }
            helper(root.left, k, target, res, s+"0");
            helper(root.right, k, target, res, s+"1");
        }
        return res;
    }
    public boolean disK(String s1,String s2,int k){//计算距离，距离=点1的深度+点2的深度-2倍的公共前缀深度
        if(s1.length()>s2.length()){
            String s = s1;
            s1 = s2;
            s2 = s;
        }
        int i;
        for(i = 0;i<s1.length();i++){
            if(s1.charAt(i) != s2.charAt(i)){
                break;
            }
        }
        int dis = s1.length() + s2.length() - i*2;
        return dis == k;
    }
    public String findTarget(TreeNode root, TreeNode target,String res){//查找target节点，返回路径
        if(root == null){
            return "w";
        }
        if(root == target){
            return res;
        }
        String s = findTarget(root.left, target, res+"0");
        if(s.equals("w")){
            return findTarget(root.right, target, res+"1");
        }else {
            return s;
        }
    }

3.Score After Flipping Matrix

　　在一行中，每一列中的值比后面所有的列和都要大，因此把第一列的值置为1是第一目标，所以首先转换行用于把第一列的值全置为1，第二列到最后一列只需要根据每一列的1的个数是否大于行数的一半，如果大于就翻转列，反之则该列已经最大。

    public int matrixScore(int[][] A) {
        int score = 0;
        for (int i = 0; i < A.length; i++) {//把第一列的所有值都用行转换变为1
            if (A[i][0] == 0) {
                swap(A, true, i);
            }
            score += Math.pow(2, A[i].length - 1);
        }
        for (int j = 1; j < A[0].length; j++) {
            int count = 0;//每一列1的个数
            for (int i = 0; i < A.length; i++) {
                if (A[i][j] == 1) {
                    count++;
                }
            }
            count = Math.max(count, A.length - count);//如果小于一半，就反转
            score += Math.pow(2, A[0].length - 1 - j) * count;
        }
        return score;
    }

    public void swap(int[][] A, boolean row, int num) {//用于转换行、列（后来发现转换列其实不需要，只需要计算每列的个数，如果反转就把个数反转即可，因为该列是否反转与后序无关联）
        if (row) {
            for (int i = 0; i < A[0].length; i++) {
                A[num][i] ^= 1;
            }
        }
    }

4.Shortest Subarray with Sum at Least K

　　感觉A.length<=50000是最大的难点，当时没做出来，补题学到了一种很厉害的思路。首先用P[i]数组记录数组中第0个元素到第i个元素的和，因此P[y]-p[x]就是从位置x到y的和。

　　然后，用一个双端队列，扫描一遍p数组，使队列保持递增（因为对于i<j，p[i]>p[j]，则最小的距离肯定不是后面某个位置的值到i的和，而是到j的和，因此需要保持队列递增）。

　　扫描每个点（比如i）的时候，用i与队列中首位的值配对，如果到队列首位位置的和比K大，则可以把队列首位的值remove掉，因为对于j>i来说，后面的所有符合条件的位置离队列首位记录的位置更远。

　　可能听描述有点抽象，看代码就好啦！

    public int shortestSubarray(int[] A, int K) {
        int[] P = new int[A.length + 1];
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < A.length; i++) {
            P[i + 1] = P[i] + A[i];
        }
        Deque<Integer> deque = new LinkedList<>();// 下面保证单调递增队列
        for (int i = 0; i < A.length + 1; i++) {
            while (!deque.isEmpty() && P[i] <= P[deque.getLast()]) {// 如果x1<y2
                                                                    // 且p[y2]<p[x1]则把x1抛弃
                deque.removeLast();
            }
            while (!deque.isEmpty() && P[i] >= P[deque.getFirst()] + K) {// 从前找满足的位置
                res = Math.min(res, i - deque.removeFirst());// 如果满足就把队列中的那个点去掉，因为i之后的点-队列中的点位置肯定比当前点大
            }
            deque.addLast(i);
        }
        return res == Integer.MAX_VALUE ? -1 : res;
    }

　　oN的时间复杂度和空间复杂度，正好利用了区间和大于k这个条件（我才不会说我一开始看错题在思考怎么判断等于k）。很妙！