LeetCode 1034 边界着色

最新推荐文章于 2022-05-11 14:25:08 发布
最新推荐文章于 2022-05-11 14:25:08 发布
阅读量211 收藏
点赞数
文章标签： dfs 算法 python java leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42419762/article/details/121782730
版权

给你一个大小为 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
Related Topics
  • 深度优先搜索
  • 广度优先搜索
  • 数组
  • 矩阵
\n
  • 👍 91
  • 👎 0
深度优先
/**
 * DFS
 *
 * @param grid
 * @param row
 * @param col
 * @param color
 * @return
 */
public static int[][] colorBorder(int[][] grid, int row, int col, int color) {
    if (grid == null || grid.length == 0 || grid[0].length == 0) {
        return new int[][]{};
    }

    // 判断是否为边界
    int rows = grid.length;
    int cols = grid[0].length;

    // 表示该位置是否为边界
    boolean[][] colorFlag = new boolean[rows][cols];
    // 表示该位置是否已遍历
    boolean[][] flag = new boolean[rows][cols];
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            colorFlag[i][j] = false;
            flag[i][j] = false;
        }
    }

    int target = grid[row][col];
    dfs(grid, target, row, col, colorFlag, flag);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (colorFlag[i][j] == true) {
                grid[i][j] = color;
            }
        }
    }
    return grid;
}

private static void dfs(int[][] grid, int target,
                        int i, int j,
                        boolean[][] colorFlag,
                        boolean[][] flag) {

    if (i < 0 || i >= grid.length
            || j < 0 || j >= grid[0].length
            || grid[i][j] != target || flag[i][j]) {
        return;
    }
    flag[i][j] = true;
    colorFlag[i][j] = true;
    if (i > 0) {
        dfs(grid, target, i - 1, j, colorFlag, flag);
    }
    if (i < grid.length - 1) {
        dfs(grid, target, i + 1, j, colorFlag, flag);
    }
    if (j > 0) {
        dfs(grid, target, i, j - 1, colorFlag, flag);
    }
    if (j < grid[0].length - 1) {
        dfs(grid, target, i, j + 1, colorFlag, flag);
    }

    flag[i][j] = false;
    isNotBoard(grid, target, i, j, colorFlag);
    return;
}

/**
 * 是否是边界：主要问题在于边界的判断
 *
 * @param row
 * @param col
 * @param colorFlag
 * @return
 */
private static void isNotBoard(int[][] grid, int target,
                               int row, int col, boolean[][] colorFlag) {

    /**
     * 网格第一行/列或最后一行/列都是边界
     */
    if (row == 0 || row == colorFlag.length - 1
            || col == 0 || col == colorFlag[0].length - 1) {
        colorFlag[row][col] = true;
        return;
    }
    /**
     * 4个方向相邻的都是边界或者都不是边界，说明该位置不是边界
     * 其他情况说明该位置是边界
     */
    boolean flag = (grid[row - 1][col] == target) && (grid[row][col - 1] == target)
            && (grid[row + 1][col] == target) && (grid[row][col + 1] == target);
    colorFlag[row][col] = !flag;
}
测试用例
public static void main(String[] args) {
    int[][] grid = new int[][]{{1, 1}, {1, 2}};
    int row = 0, col = 0;
    int color = 3;
    int[][] colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo01 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");

    grid = new int[][]{{1, 2, 2}, {2, 3, 2}};
    row = 0;
    col = 1;
    color = 3;
    colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo02 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");

    grid = new int[][]{{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
    row = 1;
    col = 1;
    color = 2;
    colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo03 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");

    grid = new int[][]{{1, 2, 1, 2, 1, 2}, {2, 2, 2, 2, 1, 2}, {1, 2, 2, 2, 1, 2}};
    row = 1;
    col = 3;
    color = 1;
    colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo04 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");

    grid = new int[][]{{1, 2, 2}, {2, 1, 2}, {1, 2, 3}, {3, 2, 1}};
    row = 1;
    col = 1;
    color = 3;
    colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo05 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");

    grid = new int[][]{{2, 1, 3, 2, 1, 1, 2},
            {1, 2, 3, 1, 2, 1, 2},
            {1, 2, 1, 2, 2, 2, 2},
            {2, 1, 2, 2, 2, 2, 2},
            {2, 3, 3, 3, 2, 1, 2}};
    row = 4;
    col = 4;
    color = 3;
    //{{2,1,3,2,1,1,3},{1,2,3,1,3,1,3},{1,2,1,3,2,3,3},{2,1,3,3,2,3,3},{2,3,3,3,3,1,3}}
    colorBoard = ColorBorder.colorBorder(grid, row, col, color);
    System.out.print("ColorBorder demo06 result : [");
    for (int i = 0; i < colorBoard.length; i++) {
        System.out.print("[");
        for (int j = 0; j < colorBoard[0].length; j++) {
            System.out.print("," + colorBoard[i][j]);
        }
        System.out.print("]");
    }
    System.out.println("]");
}
运行结果
ColorBorder demo01 result : [[,3,3][,3,2]]
ColorBorder demo02 result : [[,1,3,3][,2,3,3]]
ColorBorder demo03 result : [[,2,2,2][,2,1,2][,2,2,2]]
ColorBorder demo04 result : [[,1,1,1,1,1,2][,1,2,1,1,1,2][,1,1,1,1,1,2]]
ColorBorder demo05 result : [[,1,2,2][,2,3,2][,1,2,3][,3,2,1]]
ColorBorder demo06 result : [[,2,1,3,2,1,1,3][,1,2,3,1,3,1,3][,1,2,1,3,2,3,3][,2,1,3,3,2,3,3][,2,3,3,3,3,1,3]]
fustcyasdy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Sunny Code1034极大独立集
qq_42681421的博客
09-05 417
极大独立集 Problem Description 对一个给定的无向图G(V,E)，点集V'是V的子集。如果V'中的任意两个顶点之间都没有边，就称点集V'是图G的独立集（Independent Set）。在此基础上，如果往V'中添加任何一个在V中但不在V'中的顶点，都会使V'变成非独立集，那么就称V'是图...
algoboy101#note_blog_leetcode#[1034]边框着色1
07-25
示例 1：输出：[[3, 3], [3, 2]]示例 2：输出：[[1, 3, 3], [2, 3, 3]]示例 3：输出：[[2, 2, 2], [2, 1,
leetcode1034
weixin_33971130的博客
04-28 135
1 class Solution: 2 def __init__(self): 3 self.V = list() 4 5 def bfs(self,grid,color,rows,coloums,r,c,ocolor): 6 cur = [r,c] 7 if cur[0]-1 >=0 and s...
leetcode 1034. 边界着色【BFS】
R
12-08 95
import queue class Solution: def colorBorder(self, grid: List[List[int]], row: int, col: int, color: int) -> List[List[int]]: def judeg(grid, x, y, m, n, dir, source): if x == 0 or y == 0 or x == m-1 or y == n-1: .
leetcode 1034. 边界着色
qq_45908682的博客
12-07 196
为了12月打卡的小牌～～～ 感谢大佬！！！（照着敲了一遍 学习了一下！！！） class Solution { private int N; private int M; private boolean[][] isValid; public int[][] colorBorder(int[][] grid, int row, int col, int color) { N = grid.length; M = grid[0].lengt
leetcode1034. 边界着色(mid)(每日一题)
qq_43478625的博客
12-08 261
边界着色题目描述解题思路代码(dfs)复杂度 力扣链接 题目描述 给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。 两个网格块属于同一 连通分量 需满足下述全部条件： 两个网格块颜色相同 在上、下、左、右任意一个方向上相邻 连通分量的边界 是指连通分量中满足下述条件之一的所有网格块： 在上、下、左、右四个方向上与不属于同一连通分量的网格块相邻 在网格的边界上（第一行/列或最后一行/列） 请你使用
leetcode边界情况-leetcode:Leetcode题解及算法积累
07-07
leetcode 边界情况
LeetCode Solutions
最新发布
06-13
C++ LeetCode 题解指导
leetcode
03-30
Leetcode题解
leetcode题目精选
03-15
leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode题目精选，JAVA算法刷题，算法题leetcode...
[leetcode] 1034. Coloring A Border
Learning from the mistakes
01-05 120
Description Given a 2-dimensional grid of integers, each value in the grid represents the color of the grid square at that location. Two squares belong to the same connected component if and only if they have the same color and are next to each other in an
Leecode 1034. 边界着色 DFS/BFS
想买很多漂亮衣服但是买不起的博客
05-11 351
原题链接：Leecode 1034. 边界着色 这题题目不太好理解 DFS class Solution { public: int x[4]={-1,1,0,0}; int y[4]={0,0,-1,1}; vector<vector<int>> vis; bool dfs(vector<vector<int>>& grid,int i,int j,int col,int color) {
leetcode-1034：边界着色
菊头蝙蝠的博客
12-07 404
leetcode-1034：边界着色题目解题方法一：BFS 题目 题目链接 给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。 当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一 连通分量 。 连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻（四个方向上）的所有网格块，或者在网格的边界上（第一行/列或最后一行/列）的所有网格块。 请你使用指定颜色 color 为所有
LeetCode 1034:边界着色
li4692625的博客
12-07 632
问题描述： 给你一个大小为m x n的整数矩阵grid，表示一个网格。另给你三个整数row、col和color。网格中的每个值表示该位置处的网格块的颜色。 将给定单元格[row,col]的联通区域的边界着色成color； 思路：DFS从给定单元格开始遍历，记录visited 从上下左右四个方向开始扩展，如果出界或者值不是原有颜色则是边界存到boarders中； 只要任意方向满足条件那么当前单元格就是边界，存起来； 最后统一处理进行着色； 代码： class Solutio...
Leetcode 1034 边界着色
博学 笃志 切问 近思
12-07 165
题目 给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。 两个网格块属于同一 连通分量 需满足下述全部条件： 两个网格块颜色相同 在上、下、左、右任意一个方向上相邻 连通分量的边界 是指连通分量中满足下述条件之一的所有网格块： 在上、下、左、右四个方向上与不属于同一连通分量的网格块相邻 在网格的边界上（第一行/列或最后一行/列） 请你使用指定颜色 color 为所有包含网格块&nb
LeetCode 1034 边界着色[dfs] HERODING的LeetCode之路
HERODING23的博客
12-07 577
解题思路 令人头皮发麻的翻译，花了一个小时才真正理解题目的本意，首先连通分量大家都理解，那么在从初始点出发的时候，你是不知道你所在的连通分量是什么样的，那么我们就上下左右找，但是找之前要判断一下你所在的点是否在连通分量的边界处，边界条件是：在网格的边界，或者该点的四周存在颜色不同的点。判断完成后，如果是边界就加入到border数组中，不在继续深搜了，不是边界，标记下一个位置已访问，并继续深搜，代码如下： 代码 class Solution { private: vector<pair<.
codevs1034（网络流）
zhhx2001的博客
07-31 785
问最少的时间， 这是网络流的一个类型，即动态流问题：题目要求的不是能送最多多少人，而是限定了流量，求最少需要多少时间。我们面临着难题，一般的流网络无法表示两点间不同时刻的不同容量和流量，因此我们要拆点。 如果最短时间是t，就把每个点Vi（包括源点和汇点）拆成Vi0,Vi1,Vi2,……,Vit这t+1个点，这样太空船在t-1时刻从vi出发在t时刻到达Vj就可以表示成Vit-1~~~
leetcode 1034. 边界着色 python
ganggang的博客
12-07 137
题目描述： 题解：回溯 思路：先将[row,col]的所有连通位置都染色为color，然后再将其中不为边界的部分，重新赋值为原来grid[row][col]的值。 1.oricolor记录原始[row,col]位置的颜色，directions记录上下左右的移动方式，visited记录哪些位置被染色。 2.dfs函数输入为posx,posy,visited,oricolor，如果[posx,posy]位置合法并且grid[posx][posy]=oricolor，则将grid[posx][..
LeetCode题解(1034)：边框着色(Python)
长行
02-05 319
题目：原题链接（中等） 标签：广度优先搜索、深度优先搜索 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(M×N)O(M×N)O(M×N) O(M×N)O(M×N)O(M×N) 132ms (82.52%) Ans 2 (Python) Ans 3 (Python) 解法一： class Solution: def colorBorder(self, grid: List[List[int]], r0: int, c0: int, c
leetcode vscode
08-21
LeetCode是一个很受程序员和面试者欢迎的在线编程平台，提供了大量的算法和数据结构题目。VSCode是一款流行的代码编辑器，提供了丰富的功能和插件支持。两者结合使用可以帮助开发者更高效地解决LeetCode的问题。 在VSCode中使用LeetCode可以方便地编写、调试和测试代码。有一些插件可以在VSCode中安装来增强LeetCode的支持，例如"LeetCode"和"LeetCode Runner"等插件。这些插件可以帮助你直接在VSCode中获取题目、提交代码和查看结果。 使用VSCode解决LeetCode问题的一般步骤是： 1. 在VSCode中安装相关的LeetCode插件。 2. 打开LeetCode平台，选择一个题目并复制题目的描述。 3. 在VSCode中创建一个新文件，并将题目的描述粘贴到文件中。 4. 编写解题代码，并在VSCode中进行调试和测试。 5. 将代码提交到LeetCode平台，查看测试结果和错误信息。 6. 根据测试结果和错误信息修改代码并重新测试，直到通过所有测试用例。 希望这些信息对你有帮助！如果你还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值