算法专题十八：FloodFill算法（使用dfs）

原创已于 2025-10-31 16:08:17 修改 · 364 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #dfs #floodfill

于 2025-10-31 16:01:07 首次发布

算法专题专栏收录该内容

26 篇文章

订阅专栏

图像渲染

733. 图像渲染 - 力扣（LeetCode）

class Solution {
    int[] dx={1,-1,0,0};
    int[] dy={0,0,1,-1};
    int m,n;
    int prev;
    public int[][] floodFill(int[][] image, int sr, int sc, int color) {
        m=image.length;
        n=image[0].length;
        if(image[sr][sc]==color){
            return image;
        }
        prev=image[sr][sc];
        dfs(image,sr, sc,color);

        return image;
    }
    public void dfs(int[][] image, int sr, int sc, int color){
        image[sr][sc]=color;

    for(int k=0;k<4;k++){
        int x=sr+dx[k];
        int y=sc+dy[k];
        if(x>=0 && x<m && y>=0 && y<n && image[x][y]==prev){
            dfs(image,x,y,color);
        }
    }
    }
    
}

岛屿数量

200. 岛屿数量 - 力扣（LeetCode）

class Solution {
    int[] dx={1,-1,0,0};
    int[] dy={0,0,-1,1};
    int m,n;
    boolean[][] check;
    int ret;
    public int numIslands(char[][] grid) {
        m=grid.length;
        n=grid[0].length;
        ret=0;
        check=new boolean[m][n];

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(check[i][j]==false && grid[i][j]=='1'){
                    ret++;
                    dfs(grid,i,j);
                }
            }
        }
        return ret;
    }
    public void dfs(char[][] grid,int i,int j){
        check[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 && check[x][y]==false && grid[x][y]=='1'){
                dfs(grid,x,y);
            }
        }
    }
}

岛屿的最大数量

695. 岛屿的最大面积 - 力扣（LeetCode）

class Solution {
    int[] dx={0,0,1,-1};
    int[] dy={1,-1,0,0};
    boolean[][] check;
    int m;
    int n;
    int count;
    public int maxAreaOfIsland(int[][] grid) {
        m=grid.length;
        n=grid[0].length;
        int ret=0;
        check=new boolean[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(check[i][j]==false && grid[i][j]==1){
                    count=0;
                    dfs(grid,i,j);
                    ret=Math.max(ret,count);
                }
            }
        }
        return ret;
    }
    public int dfs(int[][] grid,int i,int j){
        count++;
        check[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 && check[x][y]==false && grid[x][y]==1){
                dfs(grid,x,y);
            }
        }
        return count;
    } 
}

被围绕的区域

130. 被围绕的区域 - 力扣（LeetCode）

class Solution {
    int[] dx={0,0,1,-1};
    int[] dy={1,-1,0,0};
    int m,n;
    public void solve(char[][] board) {
        m=board.length;
        n=board[0].length;
        for(int i=0;i<m;i++){
            if(board[i][0]=='O'){
                dfs(board,i,0);
            }
            if(board[i][n-1]=='O'){
                dfs(board,i,n-1);
            }
        }
        for(int j=0;j<n;j++){
            if(board[0][j]=='O'){
                dfs(board,0,j);
            }
            if(board[m-1][j]=='O'){
                dfs(board,m-1,j);
            }     
        }

        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(board[i][j]=='O'){
                    board[i][j]='X';
                }
                if(board[i][j]=='.'){
                    board[i][j]='O';
                }
            }
        }
    }
    public void dfs(char[][] board,int i,int j){
        board[i][j]='.';
        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 && board[x][y]=='O'){
                dfs(board,x,y);
            }
        }
    }
}

太平洋大西洋的水流问题

417. 太平洋大西洋水流问题 - 力扣（LeetCode）

class Solution {
    int[] dx={1,-1,0,0};
    int[] dy={0,0,-1,1};
    int m,n;
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        m=heights.length;
        n=heights[0].length;
        boolean[][] pa=new boolean[m][n];
        boolean[][] at=new boolean[m][n];
        for(int j=0;j<n;j++){
            dfs(heights,0,j,pa);
        }
        for(int i=0;i<m;i++){
            dfs(heights,i,0,pa);
        }
        for(int j=0;j<n;j++){
            dfs(heights,m-1,j,at);
        }
        for(int i=0;i<m;i++){
            dfs(heights,i,n-1,at);
        }

        List<List<Integer>> ret=new ArrayList<>();
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(at[i][j]  && pa[i][j]){
                    List<Integer> p=new ArrayList<>();
                    p.add(i);
                    p.add(j);
                    ret.add(p);
                }
            }
        }
        return ret;
    }

    public void dfs(int[][] heights,int i,int j,boolean[][] check){
        check[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 && check[x][y]==false && heights[i][j]<=heights[x][y]){
                dfs(heights,x,y,check);
            }
        }
    }
}

扫雷游戏

529. 扫雷游戏 - 力扣（LeetCode）

class Solution {
    int[] dx={1,-1,0,0,1,1,-1,-1};
    int[] dy={0,0,1,-1,1,-1,-1,1};
    int m,n;

    public char[][] updateBoard(char[][] board, int[] click) {
        m=board.length;
        n=board[0].length;
        int x=click[0];
        int y=click[1];
        if(board[x][y]=='M'){
            board[x][y]='X';
            return board;
        }
        dfs(board,x,y);
        return board;
    }

    public void dfs(char[][] board,int i,int j){
        int count =0;
        for(int k=0;k<8;k++){
            int x=i+dx[k];
            int y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && board[x][y]=='M'){
                count++;
            }
        }
        if(count==0){
            board[i][j]='B';
            for(int k=0;k<8;k++){
            int x=i+dx[k];
            int y=j+dy[k];
            if(x>=0 && x<m && y>=0 && y<n && board[x][y]=='E'){
                dfs(board,x,y);
            }
            }
        }else{
            board[i][j]=(char)('0'+count);
            return ;
        }
        
    }
}

衣橱整理

LCR 130. 衣橱整理 - 力扣（LeetCode）

注：求的是数位之和，比如i=15，和为1+5

class Solution {
    int[] dx={0,0,1,-1};
    int[] dy={1,-1,0,0};
    int m,n;
    int ret;
    int cnt;
    boolean[][] check;
    public int wardrobeFinishing(int m1, int n1, int cnt1) {
        m=m1;
        n=n1;
        cnt=cnt1;
        ret=0;
        check=new boolean[m][n];
        dfs(0,0);
        return ret;
    }

    public void dfs(int i,int j){
        check[i][j]=true;
        ret++;
        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 && !check[x][y] && ch(x,y)){
                dfs(x,y);
            }
        }
    }

    public boolean ch(int i,int j){
        int tem=0;
        while(i!=0){
            tem+=i%10;
            i/=10;
        }

        while(j!=0){
            tem+=j%10;
            j/=10;
        }
        return tem<=cnt;
    }
}