简单深度优先遍历oj

最新推荐文章于 2022-05-05 13:06:16 发布

pandachen1

最新推荐文章于 2022-05-05 13:06:16 发布

阅读量238

点赞数

分类专栏：笔记文章标签： dfs leetcode 算法

本文链接：https://blog.csdn.net/ormosia2/article/details/111410301

版权

笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文通过讲解LeetCode中的四道题目，展示了深度优先遍历（DFS）算法在图像渲染、岛屿数量计算、被围绕区域处理以及水域大小计算上的应用。每个问题都提供了DFS的解题思路，如在搜索过程中更新状态或排除无效位置。

摘要由CSDN通过智能技术生成

简单深度优先遍历oj

leetcode733-图像渲染

思路：四个方向上分别试探，满足条件就修改颜色，不满足return

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        int cur = image[sr][sc];

        if(cur != newColor) {
            dfs(sr,sc,image,cur,newColor);
        }
        return image;
    }

    public void dfs(int sr,int sc,int[][] image,int cur,int newColor) {
        if(sr < 0 || sc < 0 || sr == image.length || sc == image[0].length || image[sr][sc] != cur) {
            return;
        }else {

            image[sr][sc] = newColor;

            dfs(sr - 1,sc,image,cur,newColor);
            dfs(sr + 1,sc,image,cur,newColor);
            dfs(sr,sc - 1,image,cur,newColor);
            dfs(sr,sc + 1,image,cur,newColor);
        }
    }
}

leetcode200-岛屿数量

思路：从起点开始搜索，每搜索到一个1就将其置为0，当本次搜索结束时，说明找到一个岛屿

class Solution {
    public int numIslands(char[][] grid) {
        if(grid.length == 0) {
            return 0;
        }

        int r = grid.length;
        int c = grid[0].length;
        int ans = 0;
        for(int i = 0;i < r;i++) {
            for(int j = 0; j < c;j++) {
                if(grid[i][j] == '1') {
                    dfs(i,j,grid);
                    ans++;
                }
            }
        }
        return ans;
    }

    public void dfs(int i,int j,char[][] grid) {
        if(check(i,j,grid)) {
            return;
        } 

        grid[i][j] = '0';

        dfs(i - 1,j,grid);
        dfs(i + 1,j,grid);
        dfs(i,j - 1,grid);
        dfs(i,j + 1,grid);
    }

    public boolean check(int i,int j,char[][] grid) {
        return i < 0 || j < 0 || i == grid.length || j == grid[0].length || grid[i][j] == '0'; 
    }
}

leetcode130-被围绕的区域

思路：与常规思路不同，本题用DFS排除掉不合理的位置，而不是直接DFS求解

class Solution {
    public void solve(char[][] board) {
        if(board.length == 0) {
            return;
        }
        int r = board.length;
        int c = board[0].length;

        for(int i = 0; i < r;i++) {  //排除行中的不合理项
        dfs(board,i,0);
        dfs(board,i,c - 1);    
        }

        for(int i = 1; i < c;i++) {  //排除列中的不合理项
            dfs(board,0,i);
            dfs(board,r - 1,i);
        }

        for(int i = 0; i < r;i++) {
            for(int j = 0; j < c;j++) {
                if(board[i][j] == 'Q') {  //遍历将Q改为O
                    board[i][j] = 'O';
                }else if(board[i][j] == 'O') { //剩下的O就是被围绕的地方
                    board[i][j] = 'X';
                }
            }
        }
    }

    public void dfs(char[][] board,int i,int j) {
        if(i < 0 || j < 0 || i == board.length || j == board[0].length || board[i][j] != 'O'){
            return;
        }

        board[i][j] = 'Q';  //将不合理项都改为Q，用来辨识该项是否合理

        dfs(board,i - 1,j);
        dfs(board,i + 1,j);
        dfs(board,i,j - 1);
        dfs(board,i,j + 1);

    }
}

leetcode面试题16.19-水域大小

思路：DFS搜索八个方向，将搜索过的值置为-1

class Solution {
    public int[] pondSizes(int[][] land) {
        int r = land.length;
        int c = land[0].length;
        List<Integer> ans = new ArrayList<>();
        for(int i = 0; i < r;i++) {
            for(int j = 0; j < c;j++) {
                if(land[i][j] == 0) {
                int temp =  dfs(i,j,land);
                ans.add(temp);    
                }
            }
        }
        Collections.sort(ans);
     int[] res = new int[ans.size()];
     for(int i = 0; i < res.length;i++) {
         res[i] = ans.get(i);
     } 
     return res;
    }

    public int dfs(int i,int j,int[][] land) {
        int count = 0;
        if(!check(i,j,land)) {
            return count;
        }

            count++;
        land[i][j] = -1;

       count += dfs(i - 1,j,land);
       count += dfs(i + 1,j,land);
       count += dfs(i,j - 1,land);
       count += dfs(i,j + 1,land);

       count += dfs(i - 1,j - 1,land);
       count += dfs(i - 1,j + 1,land);
       count += dfs(i + 1,j - 1,land);
       count += dfs(i + 1,j + 1,land);

         return count;
    }

    public boolean check(int i,int j,int[][] land) {
        if(i < 0 || j < 0 || i == land.length || j == land[0].length || land[i][j] != 0) {
            return false;
        }else {
            return true;
        }
    }
}