LeetCode-1034边界着色问题

一，问题描述

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

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

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

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

原题Link：https://leetcode-cn.com/problems/coloring-a-border/

1.1 解释

对于这道题，我觉得有必要解释一下题目想表达的意思。开始的时候，看到这题，我以为是一道普通的DFS,BFS的模板题，直接套用模板就可以解决。（实际上也是这样）。
本题是对 连通分量的边界进行着色，不是对边界中的某个颜色进行着色。举个几个例子：

对于[0,1]坐标着色为3，对于[0,1]所对应的连通分量的边界进行着色，效果如右图所示。
对于例子2：对于坐标[1,3]着色为3,对于[1,3]所对应的连通分量的边界进行着色，效果如右图所示

现在大概能够了解题目是什么意思。

二，题解

使用深度优先搜索或者广度优先搜索来寻找出位置(row,col) 的所在的连通分量，额外要做的是搜索的时候需要判断当前的点是否属于边界。如果属于边界，则直接把当前点的颜色进行改变。
这里我们需要借助一个visited数组来记录是否被访问。

2.1 DFS解法

代码

思路：我们用递归来实现深度优先搜索遍历连通分量，用一个大小和grid相同的矩阵 visited来记录当前节点是否被访问过，并用一个flag来记录当前的上下左右是否都是当前分量，如果不都是当前分量，说明当前不是边界，不进行颜色的改变。反之，则改变颜色。

public int[][] colorBorder(int[][] grid, int row, int col, int color) {
        dfs(grid, row, col, new boolean[grid.length][grid[0].length], color);
        return grid;
    }
    private void dfs(int[][] grid, int i, int j, boolean[][] visited, int color){
        visited[i][j] = true;
        // 记录当前坐标上下左右中为当前连通分量元素的个数
        int flag = 0;
        for (int k = 0; k < 4; k++) {
            int x = i + dirc[k][0];
            int y = j + dirc[k][1];
//            在边界内，并且没有被染色，没有被访问
            if(inBound(grid, x, y) && grid[x][y] == grid[i][j] && !visited[x][y]){
                dfs(grid,x,y,visited,color);
            }
            if(inBound(grid,x,y) && visited[x][y]){
                flag++;
            }
            // 说明当前坐标的上下左右并不全是当前连通分量的元素。（是边界）
            if(flag != 4) grid[i][j] = color;
        }
    }
    private final int[][] dirc = new int[][]{{-1,0},{1,0},{0,-1},{0,1}};

    private boolean inBound(int[][] grid, int x, int y){
        return x >= 0 && y >=0 && x < grid.length && y < grid[0].length;
    }

复杂度分析

• 时间复杂度：O(mn)，其中 m 和n 分别是grid的行数和列数。在最坏情况下，我们需要访问到 grid 中的每个点。

• 空间复杂度：主要来源于递归。不超过 O(mn).

2.2 BFS解法

代码

思路：我们用一个队列来实现广度优先搜索遍历连通分量，并用一个大小和 grid相同的矩阵 visited 来记录当前节点是否被访问过，将所有没有访问过的都放入队列中，同样定义一个flag，作用和上述的一样。

 public int[][] colorBorder(int[][] grid, int row, int col, int color) {
        int m = grid.length, n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        Deque<int[]> queue = new LinkedList<>();
        queue.add(new int[]{row, col});
        visited[row][col] = true;
        while (!queue.isEmpty()) {
            final int[] cell = queue.pollLast();
            int x = cell[0], y = cell[1];
            int flag = 0;
            // end condition
            for (int k = 0; k < 4; k++) {
                int nx = x + dirc[k][0];
                int ny = y + dirc[k][1];
                if(inBound(grid, nx, ny) && grid[nx][ny] == grid[x][y] 
                && !visited[nx][ny] ){
                    queue.addFirst(new int[]{nx, ny});
                    visited[nx][ny] = true;
                }
                if(inBound(grid,nx,ny) && visited[nx][ny])
                    flag++;
            }
            if(flag != 4)
                grid[x][y] = color;
        }
        return grid;
    }
    private final int[][] dirc = new int[][]{{-1,0},{1,0},{0,-1},{0,1}};
    private boolean inBound(int[][] grid, int x, int y){
        return x >= 0 && y >=0 && x < grid.length && y < grid[0].length;
    }

复杂度分析

• 时间复杂度：O(mn)，其中 m 和n 分别是grid的行数和列数。在最坏情况下，我们需要访问到 grid 中的每个点。

• 空间复杂度：主要来源于队列。不超过 O(mn).

三，总结

一般大部分场景，BFS和DFS都是可以解决同一问题，但是对于某些场景可能就只能针对性的解决。