LeetCode刷题记194-Sliding Window(滑动窗口)

995. K 连续位的最小翻转次数

class Solution {
    public int minKBitFlips(int[] A, int K) {
        int ans = 0;
        // 前面反转影响的范围
        Queue<Integer> range = new LinkedList<Integer>();
        for (int i = 0; i < A.length; i ++) {
            while (!range.isEmpty()) {
                int top = range.peek();
                if (top < i) {
                    range.poll();
                } else {
                    if ((range.size() & 1) == 1) {
                        A[i] ^= 1;
                    }
                    break;
                }

            }
            if (A[i] == 0) {
                range.add(i + K - 1);
                ans ++;
            }
            
        }
        while (range.size() > 1) {
            range.poll();
        }
        if (!range.isEmpty() && range.peek() >= A.length) return -1; 
        return ans;
    }
}

1074. 元素和为目标值的子矩阵数量

class Solution {
    int[][] sum;
    public int getSum(int x1, int y1, int x2, int y2) {
        if (x1 == 0 && y1 == 0) return sum[x2][y2];
        if (x1 == 0) return sum[x2][y2] - sum[x2][y1 - 1];
        if (y1 == 0) return sum[x2][y2] - sum[x1 - 1][y2];
        return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
    }
    public int numSubmatrixSumTarget(int[][] matrix, int target) {
        sum = new int[matrix.length][matrix[0].length];
        sum[0][0] = matrix[0][0];
        for (int i = 1; i < matrix.length; i ++) {
            sum[i][0] = sum[i - 1][0] + matrix[i][0];
        }
        for (int j = 1; j < matrix[0].length; j ++) {
            sum[0][j] = sum[0][j - 1] + matrix[0][j];
        }
        for (int i = 1; i < matrix.length; i ++) {
            for (int j = 1; j < matrix[i].length; j ++) {
                sum[i][j] = sum[i][j - 1]  + sum[i - 1][j] + matrix[i][j] - sum[i - 1][j - 1];
            }
        }
        Map<Integer, Integer> map = new HashMap<Integer,Integer>();
        int ans = 0;
        for (int i1 = 0; i1 < matrix.length; i1 ++) {
            for (int i2 = i1; i2 < matrix.length; i2 ++) {
                map.clear();
                map.put(0, 1);
                for (int j = 0; j < matrix[0].length; j ++) {
                    int curSum = getSum(i1, 0, i2, j);
                    int tmp =  - target + curSum;  // curSum - tmp = target
                    if (map.containsKey(tmp)) {
                        ans += map.get(tmp);
                    }
                    if (map.containsKey(curSum)) map.put(curSum, map.get(curSum) + 1);
                    } else {
                        map.put(curSum, 1);
                    }
                }
            }
        }
        return ans;
    }
}

1040. 移动石子直到连续 II

class Solution {
    public int minNum(int[] stones) {
        int n = stones.length;
        int ans = n;
        int len = 0;
        int cur = 1;
        for (int i = 1; i < stones.length; i ++) {
            if (stones[i] == stones[i - 1] + 1) {
                cur ++;
            } else {
                len = Math.max(len, cur);
                cur = 1;
            }
        }
        len = Math.max(len, cur);
        if (len == n - 1) {  //  5,6,7,8,10; 5,6,7,8,11
            if (stones[n - 1] == stones[n - 2] + 2 || stones[1] == stones[0] + 2) return 1;
            return 2;
        }
        Queue<Integer> q = new LinkedList<Integer>();
        for (int i = 0; i < n; i ++) {
            while (!q.isEmpty()) {
                int top = q.peek();
                if (stones[i] - stones[top] + 1 > n) {
                    ans = Math.min(ans, n - q.size());
                    q.poll();
                } else break;
            }
            q.add(i);
        }
        ans = Math.min(ans, n - q.size());
        return ans;
    }
    public int maxNum(int[] stones) {  // 4,8,33,34,55,68   68+1-8-5=56  55-4-5+1=47 [4,56]
        int ans = 0;
        int n = stones.length;
        ans = Math.max(stones[n - 2] - stones[0], stones[n - 1] - stones[1]) + 1 - (n - 1);
        return ans;
    }
    
    public int[] numMovesStonesII(int[] stones) {
        Arrays.sort(stones);
        int[] ans = new int[2];
        ans[0] = minNum(stones);
        ans[1] = maxNum(stones);
        return ans;
    }
}

改进后

class Solution {
    public int minNum(int[] stones) {
        int n = stones.length;
        int len = 0;
        int i = 0;
        int j = 0;
        while (j < n) {
            int dif = stones[j] - stones[i] + 1;
            if (dif > n) {
                len = Math.max(len, j - i);
                i ++;
            } else {
                j ++;
            }
        }
        len = Math.max(len, j - i);
        if (len == n - 1) {  // 处理特殊情况   1,2,3,7 之类的
            if (stones[n - 2] - stones[0] + 1 == n - 1) {  // 0...n-2连续
                if (stones[n - 1] - stones[n - 2] > 2) return 2;
            } 
            if (stones[n - 1] - stones[1] + 1 == n - 1) {
                if (stones[1] - stones[0] > 2) return 2;
            }
        }
        return n - len;
    }
    public int maxNum(int[] stones) {  // 4,8,33,34,55,68   68+1-8-5=56  55-4-5+1=47 [4,56]
        int ans = 0;
        int n = stones.length;
        ans = Math.max(stones[n - 2] - stones[0], stones[n - 1] - stones[1]) + 1 - (n - 1);
        return ans;
    }
    public int[] numMovesStonesII(int[] stones) {
        Arrays.sort(stones);
        int[] ans = new int[2];
        ans[0] = minNum(stones);
        ans[1] = maxNum(stones);
        return ans;
    }
}

1521. 找到最接近目标值的函数值

class Solution {
    public int closestToTarget(int[] arr, int target) {
        int ans = Integer.MAX_VALUE;
        int[] bitZeroNum = new int[21];
        int[] pow = new int[21];
        pow[0] = 1;
        for (int i = 1; i < 21; i ++) pow[i] = pow[i - 1] * 2;

        int i = 0;
        int j = 0;
        int cur = arr[j];
        while (i <= j && j < arr.length) {
            cur &= arr[j];
            for (int k = 0; k < 21; k ++) {
                if ((arr[j] & pow[k]) == 0) {
                    bitZeroNum[k] ++;
                }
            }
            ans = Math.min(ans, Math.abs(cur - target));
            if (ans == 0) return ans;
            if (cur > target) {
                j ++;
            } else {
                for (int k = 0; k < 21; k ++) {
                    if ((arr[i] & pow[k]) == 0) {
                        bitZeroNum[k] --;
                        if (bitZeroNum[k] == 0) {
                            cur |= pow[k];
                        }
                    }
                }
                i ++;
                if (i > j) {
                    j ++;
                    if (j == arr.length) break;
                    cur = arr[j];
                    Arrays.fill(bitZeroNum, 0);
                }
            }
        }
        return ans;
    }
}