给你一个大小为 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

    题解：
    我们先必须找到这个grid[row,col]这个连通块，然后找出连通块的边界，这儿的边界是指四周（上下左右）没有连通块包围，我们可以用一个cnt计数，当cnt为4代表被包围，就不是边界，否则就是边界。
    细节：
    我们可以先开一个数组来更新值，因为可以根据数组值是不是0来判断是否更新过，进行去重

    bfs

    1. class Solution {
    2.     public int[][] colorBorder(int[][] grid, int row, int col, int color) {
    3.         Queue<int[]> queue = new LinkedList<>();
    4.         int n = grid.length, m = grid[0].length;
    5.         int[] d = new int[]{-1,0,1,0,-1};           //坐标数组
    6.         queue.add(new int[]{row,col});
    7.         int c = grid[row][col];                     //c记录初始颜色
    8.         int[][] res = new int[n][m];
    9.         while(!queue.isEmpty()){
    10.             int[] q = queue.poll();
    11.             int x = q[0], y = q[1];
    12.             int cnt = 0;  //cnt记录当前坐标是不是边界（如果cnt为4代表不是边界）
    13.             //遍历四个方向
    14.             for(int i = 0; i < 4; ++i){
    15.                 int dx = x + d[i], dy = y + d[i+1];
    16.                 //当坐标出界或者不是同一个连通块（不等于初始颜色c）跳过
    17.                 if(dx < 0 || dx >= n || dy < 0 || dy >= m 
    18.                     || grid[dx][dy] != c) continue;
    19.                 if(grid[dx][dy] == c) cnt++;        //相等就cnt++
    20.                 if(res[x][y] != 0) continue;        //如果不为0代表已经遍历过
    21.                 queue.add(new int[]{dx,dy});
    22.             }
    23.             res[x][y] = cnt == 4 ? grid[x][y] : color;
    24.         }
    25.         //第二次遍历
    26.         for(int i = 0; i < n; ++i)
    27.             for(int j = 0; j < m; ++j)
    28.                 if(res[i][j] == 0)
    29.                     res[i][j] = grid[i][j];
    30.         return res;
    31.     }
    32. }

    dfs

    1. class Solution {
    2.     int[][] grid,res;
    3.     int color;
    4.     int n,m;    
    5.     int[] d = new int[]{-1,0,1,0,-1};       //坐标变换数组
    6.     int c;                                  //记录初始连通块的颜色
    7.     public int[][] colorBorder(int[][] grid, int row, int col, int color) {
    8.         this.grid = grid;
    9.         this.color = color;
    10.         c = grid[row][col];
    11.         n = grid.length; m = grid[0].length;
    12.         res = new int[n][m];
    13.         dfs(row,col);
    14.         //二次遍历
    15.         for(int i = 0; i < n; ++i)
    16.             for(int j = 0; j < m; ++j)
    17.                 if(res[i][j] == 0)  res[i][j] = grid[i][j];
    18.         return res;
    19.     }
    20.     public void dfs(int row, int col){
    21.         int cnt = 0;                        //记录是不是连通块边界(cnt != 4)
    22.         for(int i = 0; i < 4; ++i){
    23.             int dx = row + d[i], dy = col + d[i+1];
    24.             if(dx < 0 || dx >= n || dy < 0 || dy >= m) continue;
    25.             if(grid[dx][dy] != c) continue;
    26.             else cnt++;
    27.             if(res[dx][dy] != 0) continue;
    28.             //防止重复搜索
    29.             res[dx][dy] = -1;
    30.             dfs(dx,dy);
    31.         }
    32.         res[row][col] = cnt == 4 ? grid[row][col] : color;
    33.     }
    34. }