dfs--不同路径Ⅲ&Floodfill--图像渲染，岛屿数量

class Solution {
    int r=0;
    //原始值与要修改成为的值相同的话就可能导致反复在同一个位置
    //不过也不用boolean一个数组，直接返回，而且这个题直接修改
    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        if(image[sr][sc]==color) return image;
        r=image[sr][sc];
        dfs(image,sr,sc,color);
        return image;
    }
    int[] dx={0,0,-1,+1};int[] dy={1,-1,0,0};
    void dfs(int[][] image,int sr,int sc,int color){
        image[sr][sc]=color;//👻
        for(int k=0;k<4;k++){
            int x=dx[k]+sr;int y=dy[k]+sc;
            if(x<image.length&&x>=0&&y>=0&&y<image[0].length&&image[x][y]==r){
             //   image[x][y]=color;
                dfs(image,x,y,color);
            }
        }
        return;
    }

}

在二维网格 grid 上，有 4 种类型的方格：

• 1 表示起始方格。且只有一个起始方格。
• 2 表示结束方格，且只有一个结束方格。
• 0 表示我们可以走过的空方格。
• -1 表示我们无法跨越的障碍。

返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目。

每一个无障碍方格都要通过一次，但是一条路径中不能重复通过同一个方格。

示例 1：

输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]]
输出：2
解释：我们有以下两条路径：
1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)

关键：step=count(0的个数)+2（1,2两个结束位置）

才开始错误的原因是：我没有用bx和by,

直接在for循环里面写 if(grid[i][j]==2){check[i][j]=true;dfs(grid,i,j,1);}

这样会导致0的个数都没统计完你就去递归了😅必然错了

class Solution {
    boolean[][] check;int m,n, count=0,ret=0; 
    int[] dx={0,0,-1,1};  int[] dy={1,-1,0,0};
    public int uniquePathsIII(int[][] grid) {
        m=grid.length;
        n=grid[0].length;
        check=new boolean[m][n];
       int bx=0,by=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==0) count++;
                if(grid[i][j]==1) {bx=i;by=j;}
            }
        }
        check[bx][by]=true;
        dfs(grid,bx,by,1);
        return ret;
    }
    void dfs(int[][] grid,int i,int j,int step){
        if(grid[i][j]==2) {
            if(step-2==count) ret++;
            return;
        }
        for(int k=0;k<4;k++){
            int x=dx[k]+i;
            int y=dy[k]+j;
            if(x>=0&&x<m&&y>=0&&y<n&&!check[x][y]&&(grid[x][y]==0||grid[x][y]==2)){
                check[x][y]=true;
                dfs(grid,x,y,step+1);
                check[x][y]=false;
            }
        }
    }
}

有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。

你也被给予三个整数 sr ,  sc 和 newColor 。你应该从像素 image[sr][sc] 开始对图像进行 上色填充 。

为了完成 上色工作 ，从初始像素开始，记录初始坐标的 上下左右四个方向上 像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应 四个方向上 像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为 newColor 。

最后返回 经过上色渲染后的图像 。

示例 1:

输入: image = [[1,1,1],[1,1,0],[1,0,1]]，sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析: 在图像的正中间，(坐标(sr,sc)=(1,1)),在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，因为它不是在上下左右四个方向上与初始点相连的像素点。

class Solution {
    int r=0;
    //原始值与要修改成为的值相同的话就可能导致反复在同一个位置
    //不过也不用boolean一个数组，直接返回，而且这个题直接修改
    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        if(image[sr][sc]==color) return image;
        r=image[sr][sc];
        dfs(image,sr,sc,color);
        return image;
    }
    int[] dx={0,0,-1,+1};int[] dy={1,-1,0,0};
    void dfs(int[][] image,int sr,int sc,int color){
        image[sr][sc]=color;//👻
        for(int k=0;k<4;k++){
            int x=dx[k]+sr;int y=dy[k]+sc;
            if(x<image.length&&x>=0&&y>=0&&y<image[0].length&&image[x][y]==r){
             //   image[x][y]=color;
                dfs(image,x,y,color);
            }
        }
        return;
    }

}

200. 岛屿数量

中等

2.4K

相关企业

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

class Solution {//不要反向重复哦
    boolean[][] vis;
    int m,n;int[] dx={0,0,-1,1};int[] dy={1,-1,0,0};
    public int numIslands(char[][] grid) {
        m=grid.length;n=grid[0].length;
        vis=new boolean[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'&&!vis[i][j]){ 
                    ret++;
                    dfs(grid,i,j,1);                                      
                }
            }
        }
        return ret;      
    }
    int ret=0;
    void dfs(char[][] grid,int i,int j,int count){
          vis[i][j]=true;
        for(int k=0;k<4;k++){
            int x=i+dx[k];int y=j+dy[k];
            if(x>=0&&x<m&&y>=0&&y<n&&!vis[x][y]&&grid[x][y]=='1'){
                    dfs(grid,x,y,count+1);                
            }
        }
    }
}