【力扣134场周赛 】5040 边框着色

给出一个二维整数网格 grid，网格中的每个值表示该位置处的网格块的颜色。 只有当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一连通分量。 连通分量的边界是指连通分量中的所有与不在分量中的正方形相邻（四个方向上）的所有正方形，或者在网格的边界上（第一行/列或最后一行/列）的所有正方形。给出位于 (r0, c0) 的网格块和颜色 color，使用指定颜色 color 为所给网格块的连通分量的边界进行着色，并返回最终的网格 grid 。
示例 1：
输入：grid = [[1,1],[1,2]], r0 = 0, c0 = 0, color = 3
输出：[[3, 3], [3, 2]]
示例 2：
输入：grid = [[1,2,2],[2,3,2]], r0 = 0, c0 = 1, color = 3
输出：[[1, 3, 3], [2, 3, 3]]
示例 3：
输入：grid = [[1,1,1],[1,1,1],[1,1,1]], r0 = 1, c0 = 1, color = 2
输出：[[2, 2, 2], [2, 1, 2], [2, 2, 2]]
提示：
1 <= grid.length <= 50
1 <= grid[0].length <= 50
1 <= grid[i][j] <=1000
0 <= r0 < grid.length
0 <= c0 < grid[0].length
1 <= color <= 1000

解题思路：

1. 从（r0,c0）开始，深度优先搜索其联通分量并标记。
2. 通过标记来确定联通分量的边界，改变联通分量的边界。

相关代码：

	class ZB{
       int x;
        int y;
        ZB(int x,int y){
            this.x = x;
            this.y = y;
        }
	}

    public int[][] colorBorder(int[][] grid, int r0, int c0, int color) {
        int[][] mark = new int[grid.length][grid[0].length];
        Stack<ZB> zbStack = new Stack<>();
        ZB tmp;
        int clr = grid[r0][c0];
        //标记当前节点
        mark[r0][c0] = 1;
        //将当前节点入栈
        ZB zb = new ZB(r0,c0);
        zbStack.push(zb);
        //标记当前节点的邻接点
        while(!zbStack.empty()){
            zb = zbStack.pop();
            //标记邻接点
            //上
            int topx = zb.x;
            int topy = zb.y-1;
            if(IsValid(topx,topy,grid)){
                if(mark[topx][topy]==0)
                    if(grid[topx][topy]==clr){
                        //该节点满足要求，访问之并入栈
                        mark[topx][topy] = 1;
                        tmp = new ZB(topx,topy);
                        zbStack.push(tmp);
                    }
            }
            //下
            int bomx = zb.x;
            int bomy = zb.y+1;
            if(IsValid(bomx,bomy,grid)){
                if(mark[bomx][bomy]==0)
                    if(grid[bomx][bomy]==clr){
                        //该节点满足要求，访问之并入栈
                        mark[bomx][bomy] = 1;
                        tmp = new ZB(bomx,bomy);
                        zbStack.push(tmp);
                    }
            }
            //左
            int leftx = zb.x-1;
            int lefty = zb.y;
            if(IsValid(leftx,lefty,grid)){
                if(mark[leftx][lefty]==0)
                    if(grid[leftx][lefty]==clr){
                        //该节点满足要求，访问之并入栈
                        mark[leftx][lefty] = 1;
                        tmp = new ZB(leftx,lefty);
                        zbStack.push(tmp);
                    }
            }
            //右
            int rightx = zb.x+1;
            int righty = zb.y;
            if(IsValid(rightx,righty,grid)){
                if(mark[rightx][righty]==0)
                    if(grid[rightx][righty]==clr){
                        //该节点满足要求，访问之并入栈
                        mark[rightx][righty] = 1;
                        tmp = new ZB(rightx,righty);
                        zbStack.push(tmp);
                    }
            }
        }

        for(int i=0;i<mark.length;i++){
            for(int j=0;j<mark[0].length;j++){
                if(Isborder(i,j,mark)){
                    grid[i][j] = color;
                }
            }
        }

        return grid;
    }

	//判断是否为边界
    private boolean Isborder(int i, int j, int[][] mark) {
        if(mark[i][j]==0)
            return false;
        //非边界区域元素，上下左右的标记都为1
        if(i>0&&i<mark.length-1){
            if(j>0&&j<mark[0].length-1){
                if(mark[i][j-1]==1&&mark[i][j+1]==1&&mark[i-1][j]==1&&mark[i+1][j]==1)
                    return false;
            }
        }
        return true;
    }

	//判断坐标是否在grid的有效区域
    private boolean IsValid(int topx, int topy, int[][] grid) {
        int row = grid.length-1;
        int col = grid[0].length-1;
        if(topx>=0&&topx<=row)
            if(topy>=0&&topy<=col)
                return true;
        return false;
    }
    

后来想了想，其实可以在寻找联通区域的过程中就确定边界：如果该点上下左右的点都有效（都在grid中），且上下左右的点的颜色都与grid[r0][c0]初始的颜色相同，则不是边界点。否则就是边界点，是边界点就改变其颜色为color。