LeetCode 1034. 边界着色 / 689. 三个无重叠子数组的最大和（三个区间的滑动窗口，带回溯求具体值的动规） / 794. 有效的井字游戏

最新推荐文章于 2022-03-31 10:49:11 发布
最新推荐文章于 2022-03-31 10:49:11 发布
阅读量123 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/windyjcy/article/details/121761906
版权

1034. 边界着色

2021.12.7 每日一题

题目描述

给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。

当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一 连通分量 。

连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻（四个方向上）的所有网格块，或者在网格的边界上（第一行/列或最后一行/列）的所有网格块。

请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色，并返回最终的网格 grid 。

示例 1：

输入：grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
输出：[[3,3],[3,2]]

示例 2：

输入：grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
输出：[[1,3,3],[2,3,3]]

示例 3：

输入：grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
输出：[[2,2,2],[2,1,2],[2,2,2]]

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 50
1 <= grid[i][j], color <= 1000
0 <= row < m
0 <= col < n

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

思路

bfs

class Solution {
    int[][] direction = {{0,1},{0,-1},{1,0},{-1,0}};
    public int[][] colorBorder(int[][] grid, int row, int col, int color) {
        //就是一个dfs或者bfs吧，找到是边界的或者周围有不在分量中的网格块，就着色
        int m = grid.length;
        int n = grid[0].length;
    
        int baseColor = grid[row][col];
        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[m][n];

        queue.offer(new int[]{row, col});
        visited[row][col] = true;

        Set<String> set = new HashSet();
        set.add(row + "+" + col);
        
        while(!queue.isEmpty()){
            int[] top = queue.poll();
            //如果在边界的话
            if(top[0] == 0 || top[0] == m - 1 || top[1] == 0 || top[1] == n - 1)
                grid[top[0]][top[1]] = color;
            
            for(int i = 0; i < 4; i++){
                int nr = top[0] + direction[i][0];
                int nc = top[1] + direction[i][1];
                if(nr < 0 || nr >= m || nc < 0 || nc >= n)
                    continue;
                //如果这个位置遍历过同时这个位置的颜色不是所给颜色，那么当前位置可以涂色
                if(visited[nr][nc] && !set.contains(nr + "+" + nc)){
                    grid[top[0]][top[1]] = color;
                    continue;
                }
                if(visited[nr][nc])    
                    continue;
                visited[nr][nc] = true;
                if(grid[nr][nc] == baseColor){
                    queue.offer(new int[]{nr, nc});
                    set.add(nr + "+" + nc);
                }
                //如果不是所给颜色
                else
                    grid[top[0]][top[1]] = color;
            }
        }
        return grid;
    }
}

689. 三个无重叠子数组的最大和

2021.12.8 每日一题

题目描述

给你一个整数数组 nums 和一个整数 k ，找出三个长度为 k 、互不重叠、且 3 * k 项的和最大的子数组，并返回这三个子数组。

以下标的数组形式返回结果，数组中的每一项分别指示每个子数组的起始位置（下标从 0 开始）。如果有多个结果，返回字典序最小的一个。

示例 1：

输入：nums = [1,2,1,2,6,7,5,1], k = 2
输出：[0,3,5]
解释：子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。

示例 2：

输入：nums = [1,2,1,2,1,2,1,2,1], k = 2
输出：[0,2,4]

提示：

1 <= nums.length <= 2 * 10^4
1 <= nums[i] < 2^16
1 <= k <= floor(nums.length / 3)

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-sum-of-3-non-overlapping-subarrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

三个区间滑动窗口，学到了

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        //首先肯定要计算出所有k长度子数组的和
        //如果是两个子数组，怎么滑动
        //首先维护两个窗口，然后在向右滑动的过程中，记录第一个窗口的最大值，
        //同时记录当前第二个窗口和第一个窗口最大值的和，这样可以保证和是最大的
        //如果是三个子数组，那么先维护三个窗口，然后开始滑动，同时维护前两个窗口的最大值
        
        //自己写一下试试
        int[] res = new int[3];
        int l = nums.length;
        int sum1 = 0, max1 = 0, max1idx1 = 0;
        int sum2 = 0, max12 = 0, max12idx1 = 0, max12idx2 = 0;
        int sum3 = 0, max123 = 0;
        for(int i = 2 * k; i < l; i++){
            sum1 += nums[i - 2 * k];
            sum2 += nums[i - k];
            sum3 += nums[i];
            //如果三个区间满了，那么就开始判断
            if(i >= 3 * k - 1){
                //第一个区间最大
                if(sum1 > max1){
                    max1 = sum1;
                    max1idx1 = i - 3 * k + 1;
                }
                //前两个区间最大
                if(max1 + sum2 > max12){
                    max12 = max1 + sum2;
                    max12idx1 = max1idx1;
                    max12idx2 = i - 2 * k + 1;
                }
                if(max12 + sum3 > max123){
                    max123 = max12 + sum3;
                    res[0] = max12idx1;
                    res[1] = max12idx2;
                    res[2] = i - k + 1;
                }
                sum1 -= nums[i - 3 * k + 1];
                sum2 -= nums[i - 2 * k + 1];
                sum3 -= nums[i - k + 1];
            }
        }
        return res;
    }
}

动态规划求解最大值，然后回溯得到三个区间的下标
回溯求字典序最小，两个思路，一个是反序dp，一个是反转数组
反转数组：

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        //写一下动态规划的
        //dp[i][j]表示前i个数，分成j个子数组的最大和
        //dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
        //主要问题是动规能计算出最大值，但是怎么知道是哪三个数组呢

        //又得学了，三叶姐给出两个思路
        //要求出三个数组的开始下标就需要回溯得到
        //因为这样动态规划，回溯的话只能得到字典序最大的下标
        //所以需要特殊处理，两种方案，第一种是反序dp，第二种的反转数组

        //先写个反转数组的

        int l = nums.length;
        reverse(nums);
        //先写个前缀和，方便计算区间值
        long[] presum = new long[l + 1];
        for(int i = 0; i < l; i++){
            presum[i + 1] = presum[i] + nums[i];
        }
        long[][] dp = new long[l + 1][4];
        for(int i = k; i <= l; i++){
            for(int j = 1; j <= 3; j++){
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + presum[i] - presum[i - k]);
            }
        }
        //得到这么一个结果
        //回溯
        int[] res = new int[3];
        int i = l;
        int j = 3;
        int idx = 0;
        while(j > 0){
            //如果前者大于后者，那么说明是从前者转移来的，所以i--
            if(dp[i - 1][j] > dp[i - k][j - 1] + presum[i] - presum[i - k]){
                i--;
            //如果是后者，那么说明包含这个i的区间被选择了，所以可以更新res
            }else{
                j--;
                res[idx++] = l - i; 
                i -= k;
            }
        }
        return res;
    }

    public void reverse(int[] nums){
        int l = 0;
        int r = nums.length - 1;
        while(l < r){
            int t = nums[l];
            nums[l] = nums[r];
            nums[r] = t;
            l++;
            r--;
        }
    }
}

反序dp，也就是从后往前算，这样做是为了在回溯的时候就能先得到字典序小的下标
需要注意的是各种下标的值

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        //写一下动态规划的
        //dp[i][j]表示前i个数，分成j个子数组的最大和
        //dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
        //主要问题是动规能计算出最大值，但是怎么知道是哪三个数组呢

        //又得学了，三叶姐给出两个思路
        //要求出三个数组的开始下标就需要回溯得到
        //因为这样动态规划，回溯的话只能得到字典序最大的下标
        //所以需要特殊处理，两种方案，第一种是反序dp，第二种的反转数组

        //反序dp

        int l = nums.length;
        //先写个前缀和，方便计算区间值
        long[] presum = new long[l + 1];
        for(int i = 0; i < l; i++){
            presum[i + 1] = presum[i] + nums[i];
        }
        long[][] dp = new long[l + 2][4];
        //反序dp
        //也就是dp[i][j] = Math.max(dp[i + 1][j], dp[i + k][j - 1] + 当前子数组)
        for(int i = l - k + 1; i >= 1; i--){
            for(int j = 1; j <= 3; j++){
                dp[i][j] = Math.max(dp[i + 1][j], dp[i + k][j - 1] + presum[i + k - 1] - presum[i - 1]);
            }
        }
        //得到这么一个结果
        //回溯
        int[] res = new int[3];
        int i = 1;
        int j = 3;
        int idx = 0;
        while(j > 0){
            //如果前者大于后者，那么说明是从前者转移来的，所以i--
            if(dp[i + 1][j] > dp[i + k][j - 1] + presum[i + k - 1] - presum[i - 1]){
                i++;
            //如果是后者，那么说明包含这个i的区间被选择了，所以可以更新res
            }else{
                j--;
                res[idx++] = i - 1; 
                i += k;
            }
        }
        return res;
    }
}

或者不用反序，也不用反转数组；相等的时候取前面的值就行了

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        //写一下动态规划的
        //dp[i][j]表示前i个数，分成j个子数组的最大和
        //dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + 当前子数组)
        //主要问题是动规能计算出最大值，但是怎么知道是哪三个数组呢

        //又得学了，三叶姐给出两个思路
        //要求出三个数组的开始下标就需要回溯得到
        //因为这样动态规划，回溯的话只能得到字典序最大的下标
        //所以需要特殊处理，两种方案，第一种是反序dp，第二种的反转数组

        //直接往前递推

        int l = nums.length;

        //先写个前缀和，方便计算区间值
        long[] presum = new long[l + 1];
        for(int i = 0; i < l; i++){
            presum[i + 1] = presum[i] + nums[i];
        }
        long[][] dp = new long[l + 1][4];
        for(int i = k; i <= l; i++){
            for(int j = 1; j <= 3; j++){
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - k][j - 1] + presum[i] - presum[i - k]);
            }
        }
        //得到这么一个结果
        //回溯
        int[] res = new int[3];
        int i = l;
        int j = 3;
        int idx = 2;
        while(j > 0){
            //如果前者大于后者，那么说明是从前者转移来的，所以i--
            if(dp[i - 1][j] >= dp[i - k][j - 1] + presum[i] - presum[i - k]){
                i--;
            //如果是后者，那么说明包含这个i的区间被选择了，所以可以更新res
            }else{
                j--;
                res[idx--] = i - k; 
                i -= k;
            }
        }
        return res;
    }


}

794. 有效的井字游戏

2021.12.9 每日一题

题目描述

用字符串数组作为井字游戏的游戏板 board。当且仅当在井字游戏过程中，玩家有可能将字符放置成游戏板所显示的状态时，才返回 true。

该游戏板是一个 3 x 3 数组，由字符 " "，“X” 和 “O” 组成。字符 " " 代表一个空位。

以下是井字游戏的规则：

玩家轮流将字符放入空位（" "）中。
第一个玩家总是放字符 “X”，且第二个玩家总是放字符 “O”。
“X” 和 “O” 只允许放置在空位中，不允许对已放有字符的位置进行填充。
当有 3 个相同（且非空）的字符填充任何行、列或对角线时，游戏结束。
当所有位置非空时，也算为游戏结束。
如果游戏结束，玩家不允许再放置字符。

示例 1:

输入: board = ["O ", " ", " "]
输出: false
解释: 第一个玩家总是放置“X”。

示例 2:

输入: board = [“XOX”, " X ", " "]
输出: false
解释: 玩家应该是轮流放置的。

示例 3:

输入: board = [“XXX”, " ", “OOO”]
输出: false

示例 4:

输入: board = [“XOX”, “O O”, “XOX”]
输出: true

说明:

游戏板 board 是长度为 3 的字符串数组，其中每个字符串 board[i] 的长度为 3。
board[i][j] 是集合 {" ", “X”, “O”} 中的一个字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-tic-tac-toe-state
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

改了半天，终于改出来一版正确的代码
然后改完发现，其实只需要判断哪些不满足条件就可以了，因为填满了，也返回true
所以只需要记录刚开始填充的X和O是否是不合理的，如果不合理的话，就返回false
如果合理的话，那么后面不管怎么填，无非是成线提前结束或者最后填满了还没成线，都会返回true

class Solution {
    public boolean validTicTacToe(String[] board) {
        //首先这个题要好好弄懂题意，根据所给的例子，以及自己的测试
        //1.刚开始给定的几个字符要满足规则，也就是先放X再放O，第一个放X，如果不满足，直接false
        //2.刚开始放置的位置如果连成线了，是不行的，必须是新放置的和原来放置的连线才可以
        //3.不是两个人进行博弈，而是尽可能去连成线就行了

        //看了答案，结合出错的示例，发现，不是开始放置的字符不算，而是如果开始放置的字符已经出现了满足条件的情况
        //那么是合理的，但是如果同时O也相连，那么就不可能，比如第三个例子
        //所以看刚开始的情况，如果O出现了相连，那么O的数目和X数目相同，并且X不能相连
        //如果X出现了相连，那么X的数目要比O多一个
        int x = 0;
        int o = 0;
        for(int i = 0; i < 3; i++){
            String s = board[i];
            for(int j = 0; j < 3; j++){
                if(s.charAt(j) == 'X')
                    x++;
                else if(s.charAt(j) == 'O')
                    o++;
            }
        }
        int black = 9 - x - o;
        //如果刚开始放置的不满足条件，false
        if(o > x || x > o + 1)
            return false;
        
        boolean x3 = false;     //刚开始相连的情况
        boolean o3 = false;     //刚开始相连的情况
        boolean res = false;    //可行不可行

        //此时x和o还可以放置几个
        int xl = 5 - x;
        int ol = 4 - o;
        //首先看行
        for(int i = 0; i < 3; i++){
            String s = board[i];
            int tx = 0;
            int to = 0;
            for(int j = 0; j < 3; j++){
                if(s.charAt(j) == 'X')
                    tx++;
                else if(s.charAt(j) == 'O')
                    to++;
            }
            //如果是混杂的，那么不行
            if(tx != 0 && to != 0)
                continue;
            else if(tx == 3)
                x3 = true;
            else if(to == 3)
                o3 = true;
            else if(tx != 0 && xl >= 3 - tx)
                res = true;
            else if(to != 0 && ol >= 3 - to)
                res = true;
            else if(tx == 0 && to == 0 && xl >= 3)
                res = true;
        }

        //看列
        for(int i = 0; i < 3; i++){
            int tx = 0;
            int to = 0;
            for(int j = 0; j < 3; j++){
                String s = board[j];
                if(s.charAt(i) == 'X')
                    tx++;
                else if(s.charAt(i) == 'O')
                    to++;
            }
            //如果是混杂的，那么不行
            if(tx != 0 && to != 0)
                continue;
            else if(tx == 3)
                x3 = true;
            else if(to == 3)
                o3 = true;
            else if(tx != 0 && xl >= 3 - tx)
                res = true;
            else if(to != 0 && ol >= 3 - to)
                res = true;
            else if(tx == 0 && to == 0 && xl >= 3)
                res = true;
        }

        //正对角线
        int tx = 0;
        int to = 0;
        for(int i = 0; i < 3; i++){
            if(board[i].charAt(i) == 'X')
                tx++;
            else if(board[i].charAt(i) == 'O')
                to++;
        }
        //如果是混杂的，那么不行
        if(tx != 0 && to != 0){

        }
        else if(tx == 3)
            x3 = true;
        else if(to == 3)
            o3 = true;
        else if(tx != 0 && xl >= 3 - tx)
            res = true;
        else if(to != 0 && ol >= 3 - to)
            res = true;
        else if(tx == 0 && to == 0 && xl >= 3)
            res = true;
        
        //反对角线
        tx = 0;
        to = 0;
        for(int i = 0; i < 3; i++){
            if(board[i].charAt(2 - i) == 'X')
                tx++;
            else if(board[i].charAt(2 - i) == 'O')
                to++;
        }
        //如果是混杂的，那么不行
        if(tx != 0 && to != 0){

        }
        else if(tx == 3)
            x3 = true;
        else if(to == 3)
            o3 = true;
        else if(tx != 0 && xl >= 3 - tx)
            res = true;
        else if(to != 0 && ol >= 3 - to)
            res = true;
        else if(tx == 0 && to == 0 && xl >= 3)
            res = true;
        //如果都为true，不可能
        
        if(x3 && o3)`在这里插入代码片`
            return false;
        //如果o为true，那么初始x数量必须和o相同
        else if(o3 && x != o)
            return false;
        else if(x3 && x != o + 1)
            return false;
        else if(o3 || x3)
            return true;
        if(res)
            return true;
        return true;
    }
}

所以删去多余的代码
题解多是把循环去掉，因为字符串长度只有3，所以代码看起来会更简洁

class Solution {
    public boolean validTicTacToe(String[] board) {
        //首先这个题要好好弄懂题意，根据所给的例子，以及自己的测试
        //1.刚开始给定的几个字符要满足规则，也就是先放X再放O，第一个放X，如果不满足，直接false
        //2.刚开始放置的位置如果连成线了，是不行的，必须是新放置的和原来放置的连线才可以
        //3.不是两个人进行博弈，而是尽可能去连成线就行了
        //4.如果填满了，那么就是游戏结束，也是true

        //看了答案，结合出错的示例，发现，不是开始放置的字符不算，而是如果开始放置的字符已经出现了满足条件的情况
        //那么是合理的，但是如果同时O也相连，那么就不可能，比如第三个例子
        //所以看刚开始的情况，如果O出现了相连，那么O的数目和X数目相同，并且X不能相连
        //如果X出现了相连，那么X的数目要比O多一个
        int x = 0;
        int o = 0;
        for(int i = 0; i < 3; i++){
            String s = board[i];
            for(int j = 0; j < 3; j++){
                if(s.charAt(j) == 'X')
                    x++;
                else if(s.charAt(j) == 'O')
                    o++;
            }
        }

        //如果刚开始放置的不满足条件，false
        if(o > x || x > o + 1)
            return false;
        
        boolean x3 = false;     //刚开始相连的情况
        boolean o3 = false;     //刚开始相连的情况

        //首先看行
        for(int i = 0; i < 3; i++){
            String s = board[i];
            int tx = 0;
            int to = 0;
            for(int j = 0; j < 3; j++){
                if(s.charAt(j) == 'X')
                    tx++;
                else if(s.charAt(j) == 'O')
                    to++;
            }
            if(tx == 3)
                x3 = true;
            else if(to == 3)
                o3 = true;
        }

        //看列
        for(int i = 0; i < 3; i++){
            int tx = 0;
            int to = 0;
            for(int j = 0; j < 3; j++){
                String s = board[j];
                if(s.charAt(i) == 'X')
                    tx++;
                else if(s.charAt(i) == 'O')
                    to++;
            }
            if(tx == 3)
                x3 = true;
            else if(to == 3)
                o3 = true;
        }

        //正对角线
        int tx = 0;
        int to = 0;
        for(int i = 0; i < 3; i++){
            if(board[i].charAt(i) == 'X')
                tx++;
            else if(board[i].charAt(i) == 'O')
                to++;
        }
        if(tx == 3)
            x3 = true;
        else if(to == 3)
            o3 = true;
        
        //反对角线
        tx = 0;
        to = 0;
        for(int i = 0; i < 3; i++){
            if(board[i].charAt(2 - i) == 'X')
                tx++;
            else if(board[i].charAt(2 - i) == 'O')
                to++;
        }
        if(tx == 3)
            x3 = true;
        else if(to == 3)
            o3 = true;
        
        //如果都为true，不可能
        if(x3 && o3)
            return false;
        //如果o为true，那么初始x数量必须和o相同
        else if(o3 && x != o)
            return false;
        //如果x为true，那么初始o比x少一个
        else if(x3 && x != o + 1)
            return false;

        //剩余情况下，不是填满就是能连成线，所以true
        return true;
    }
}
Zephyr丶J
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 区间问题
Wuuuuuu2019的博客
09-03 573
文章目录304. 二维区域和检索 - 矩阵不可变【前缀和】二维前缀和二维前缀和一维前缀和模板总结995. K 连续位的最小翻转次数【贪心、差分、滑动窗口】！！！贪心差分滑动窗口总结354. 俄罗斯套娃信封问题【朴素dp，二分dp，树状数组】朴素dp二分+dp树状数组300. 最长递增子序列【朴素dp、贪心+二分】！！！贪心+二分思路1893. 检查是否区域内所有整数都被覆盖【差分】差分1310. 子数组异或查询【前缀和、树状数组】 304. 二维区域和检索 - 矩阵不可变【前缀和】 给定一个二维矩阵 mat
asshead123#my-leetcode#数组（滑动窗口）-239. 滑动窗口最大值[困难]1
07-25
示例 1：输出：[3,3,5,5,6,7]解释：滑动窗口的位置 最大值[1 3 -1] -3 5 3 6 7 31 [3 -1 -3] 5 3 6 7 31 3
LeetCode 327 区间和的个数 HERODING的LeetCode之路
HERODING23的博客
11-07 221
给定一个整数数组 nums，返回区间和在 [lower, upper] 之间的个数，包含 lower 和 upper。 区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。 说明: 最直观的算法复杂度是 O(n2) ，请在此基础上优化你的算法。 示例: 输入: nums = [-2,5,-1], lower = -2, upper = 2, 输出: 3 解释: 3个区间分别是: [0,0], [2,2], [0,2]，它们表示的和分别为: -2,
反证法-合并区间
cxu123321的博客
04-17 375
合并区间 力扣官方题解发布于2 天前11.7k官方C++Python排序 方法一：排序 思路 如果我们按照区间的左端点排序，那么在排完序的列表中，可以合并的区间一定是连续的。如下图所示，标记为蓝色、黄色和绿色的区间分别可以合并成一个大区间，它们在排完序的列表中是连续的： 算法 我们用数组merged存储最终的答案。 首先，我们将列表中的区间按照左端点升序排序。然后我们将第一...
LeetCode解题汇总目录
热门推荐
Michael是个半路程序员
09-06 7万+
此篇为学习完《数据结构与算法之美》后，在LeetCode刷题的汇总目录，方便大家查找（Ctrl+Find），一起刷题，一起PK交流！如果本文对你有帮助，可以给我点赞加油！ Updated on 2022.6.12刷题可以按照不同的专题进行，便于加强某个知识点的理解。另有《剑指Offer》面试题（更新完毕）、《程序员面试金典》面试题（更新完毕）、LintCode代码能力测试CAT。LeetCode MySQL 数据库解题目录点击访问 我的 LeetCode 主页我的 GitHub 主页注：本文超过字数限制，
leetcode 239. 滑动窗口最大值
12-22
给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 示例: 输入: nums = [1,3,-1,-...
LeetCode 1248. 统计「优美子数组」
01-20
如果某个 连续 子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。 请返回这个数组中「优美子数组」的数目。 示例 1： 输入：nums = [1,1,2,1,1], k = 3 输出：2 解释：包含 3 个奇数的子数组是 ...
gasstationleetcode-leetcode:https://leetcode-cn.com
06-30
【最大239滑动窗口】 [295 从数据流中查找中值] 【53最大子阵】 [325 最大大小子阵列总和等于 k] [209 最小尺寸子阵列总和] 【238阵除自身的乘积】 【152最大积子阵】 [228个汇总范围] [163 缺失范围] 柜台 （简单的...
滑动窗口最大值测试用例数组，长度为10W
最新发布
01-30
题目239：滑动窗口最大值 说明：给你一个整数数组 `nums`，有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位 本测试用例为10W...
LeetCode 2038. 如果相邻两个颜色均相同则删除当前颜色 / 440. 字典序的第K小数字（类字典树思路） / 661. 图片平滑器
windyjcy的博客
03-31 3168
2038. 如果相邻两个颜色均相同则删除当前颜色 2022.3.22 每日一题 题目描述 总共有 n 个颜色片段排成一列，每个颜色片段要么是 ‘A’ 要么是 ‘B’ 。给你一个长度为 n 的字符串 colors ，其中 colors[i] 表示第 i 个颜色片段的颜色。 Alice 和 Bob 在玩一个游戏，他们 轮流 从这个字符串中删除颜色。Alice 先手 。 如果一个颜色片段为 ‘A’ 且 相邻两个颜色 都是颜色 ‘A’ ，那么 Alice 可以删除该颜色片段。Alice 不可以 删除任何颜色 ‘B
LeetCode 1185. 一周中的第几天 / 913. 猫和老鼠（博弈，动态规划） / 1576. 替换所有的问号
windyjcy的博客
01-05 2494
1185. 一周中的第几天 2021.1.3 每日一题 题目描述 给你一个日期，请你设计一个算法来判断它是对应一周中的哪一天。 输入为三个整数：day、month 和 year，分别表示日、月、年。 您返回的结果必须是这几个值中的一个 {“Sunday”, “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”}。 示例 1： 输入：day = 31, month = 8, year = 2019 输出：“Saturday”
LeetCode 539. 最小时间差 / 219. 存在重复元素 II / 2029. 石子游戏 IX（博弈，总结规律）
windyjcy的博客
01-25 2426
539. 最小时间差 2022.1.18 每日一题，今天回家了 题目描述 给定一个 24 小时制（小时:分钟 “HH:MM”）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。 示例 1： 输入：timePoints = [“23:59”,“00:00”] 输出：1 示例 2： 输入：timePoints = [“00:00”,“23:59”,“00:00”] 输出：0 提示： 2 <= timePoints.length <= 2 * 104 timePoints[i]
LeetCode 1345. 跳跃游戏 IV（双向bfs） / 1332. 删除回文子序列 / 2034. 股票价格波动
windyjcy的博客
01-27 2205
1345. 跳跃游戏 IV 2022.1.21 每日一题 题目描述 给你一个整数数组 arr ，你一开始在数组的第一个元素处（下标为 0）。 每一步，你可以从下标 i 跳到下标： i + 1 满足：i + 1 < arr.length i - 1 满足：i - 1 >= 0 j 满足：arr[i] == arr[j] 且 i != j 请你返回到达数组最后一个元素的下标处所需的 最少操作次数 。 注意：任何时候你都不能跳到数组外面。 示例 1： 输入：arr = [100,-23,-23,
ACM模式输入输出练习
windyjcy的博客
07-08 1573
跟着课程的问题来看下怎么在acm模式下写输入输出 这里先写几个想到的问题： 第一个：hasNextLine和hasNext的区别 hasNext是检查是否有非空字符。 hasNextLine是检查输入中是否还有linePattern。其中LinePattern其实是匹配一个正则表达式。 hsaNextInt是检查输入中是否有整数 采用has xxxx的话，后面也要用next xxxx。比如前面用hasNextLine，那么后面要用 nextLine 来处理输入。 sc.hasNext()----输入值后返回
LeetCode 507. 完美数 / 2022. 将一维数组转变成二维数组 / 390. 消除游戏（等差数列模拟，约瑟夫环）
windyjcy的博客
01-04 1543
507. 完美数 2021.12.31 每日一题，年底最后一题，祝大家新年快乐 题目描述 对于一个 正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。 给定一个 整数 n， 如果是完美数，返回 true，否则返回 false 示例 1： 输入：num = 28 输出：true 解释：28 = 1 + 2 + 4 + 7 + 14 1, 2, 4, 7, 和 14 是 28 的所有正因子。 示例 2： 输入：num = 6 输出：true 示例 3： 输入：num =
LeetCode 495. 提莫攻击 / 629. K个逆序对数组（动规，不会） / 375. 猜数字大小 II（区间dp）
windyjcy的博客
11-15 1486
495. 提莫攻击 2021.11.10 每日一题 题目描述 在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。 当提莫攻击艾希，艾希的中毒状态正好持续 duration 秒。 正式地讲，提莫在 t 发起发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。如果提莫在中毒影响结束 前 再次攻击，中毒状态计时器将会 重置 ，在新的攻击之后，中毒影响将会在 duratio
LeetCode1744 / 牛客：万万没想到之聪明的编辑（体验ACM模式）
windyjcy的博客
06-01 1278
1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？ 2021.6.1 每日一题，也祝大家节日快乐啊 题目描述 给你一个下标从 0 开始的正整数数组 candiesCount ，其中 candiesCount[i] 表示你拥有的第 i 类糖果的数目。同时给你一个二维数组 queries ，其中 queries[i] = [favoriteTypei, favoriteDayi, dailyCapi] 。 你按照如下规则进行一场游戏： 你从第 0 天开始吃糖果。 你在吃完 所有 第 i - 1 类糖果之
LeetCode 807. 保持城市天际线 / 630. 课程表 III（贪心+优先队列）/ 851. 喧闹和富有（拓扑排序）
windyjcy的博客
12-15 1267
807. 保持城市天际线 2021.12.13 每日一题 题目描述 给你一座由 n x n 个街区组成的城市，每个街区都包含一座立方体建筑。给你一个下标从 0 开始的 n x n 整数矩阵 grid ，其中 grid[r][c] 表示坐落于 r 行 c 列的建筑物的 高度 。 城市的 天际线 是从远处观察城市时，所有建筑物形成的外部轮廓。从东、南、西、北四个主要方向观测到的 天际线 可能不同。 我们被允许为 任意数量的建筑物 的高度增加 任意增量（不同建筑物的增量可能不同） 。 高度为 0 的建筑物的高度也
leetcode 2031. 1 比 0 多的子数组个数
12-16
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，然后计算以该元素结尾的子数组中，1的个数比0多的个数。 我们可以定义一个变量count，用来记录当前遍历到的元素前面的子数组中，1的个数比0多的个数。初始化count为0。然后开始遍历数组。 对于当前遍历的元素，如果是1，则count加1。如果是0，则count减1。然后判断count的值。 如果count大于0，则说明当前元素前面的子数组中，1的个数比0多，我们将结果加上count。 如果count等于0，则说明当前元素前面的子数组中，1的个数和0的个数相等，我们将结果加上1，表示当前子数组中加上这个元素后，1的个数比0多。 最后，我们将结果返回，即为所求的答案。 下面是具体的代码实现： ```python def countSubarrays(nums): count = 0 result = 0 for num in nums: if num == 1: count += 1 else: count -= 1 if count > 0: result += count elif count == 0: result += 1 return result ``` 以上就是针对leetcode 2031题的问题，求解1比0多的子数组个数的详细解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值