【力扣】dfs(深度优先搜索)

DFS(深度优先搜索)

开头

​ 当我像一只无头苍蝇时，不妨试试爆搜，剩下的交给奇迹

​ - - - 五星上将麦克阿瑟

200.岛屿数量

200. 岛屿数量

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

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

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

class Solution {
    public int numIslands(char[][] grid) {
        int n=grid.length;
        int m=grid[0].length;
        int ans=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                //如果是一个岛屿的个点，通过dfs暴搜一整座岛屿，然后将岛屿数量+1
                if(grid[i][j]=='1')
                {
                    ans++;
                    dfs(grid,i,j);
                }
            }
        }
        return ans;
    }
    public void dfs(char[][] grid,int i,int j)
    {
        //判断边界条件
        if(i<0 || i>grid.length-1 || j<0 || j>grid[0].length-1)
        {
            return;
        }
        //判断是否符合继续下一步条件
        if(grid[i][j]=='1')
        {
            //将所有遍历过为1的数，都改变成0
            grid[i][j]='0';
            dfs(grid,i,j+1);
            dfs(grid,i+1,j);
            dfs(grid,i,j-1);
            dfs(grid,i-1,j);
        }
        return;
    }
}

130. 被围绕的区域

130. 被围绕的区域

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例 1：

输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

class Solution {
    public void solve(char[][] board) {

        int n=board.length;
        int m=board[0].length;
        //搜第一列和最后一列
        for(int i=0;i<n;i++)
        {
            if(board[i][0]=='O')
                dfs(board,i,0);
            if(board[i][m-1]=='O')
                dfs(board,i,m-1);
        }

        //搜第一行和最后一行
        for(int j=0;j<m;j++)
        {
            if(board[0][j]=='O')
                dfs(board,0,j);
            if(board[n-1][j]=='O')
            {
                dfs(board,n-1,j);
            }
        }
        //到目前为止,A为与边界相邻,O为未与边界相邻,
        //现在要把没有与边界相连的换X，O->X
        //同时将A岛屿换成O，结束战斗
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(board[i][j]=='O')
                    board[i][j]='X';
                if(board[i][j]=='A')
                    board[i][j]='O';
            }
        }

    }
    public void dfs(char[][] board,int i,int j)
    {
        //判断边界条件
        if(i<0 || i>board.length-1 || j<0 || j>board[0].length-1)
        {
            return;
        }
        //如果是一个"O" 通过dfs接着搜
        if(board[i][j]=='O')
        {
            //我规定一下A为被搜过
            board[i][j]='A';
            dfs(board,i,j+1);
            dfs(board,i+1,j);
            dfs(board,i,j-1);
            dfs(board,i-1,j);
        }
        return ;
    }
}

417. 太平洋大西洋水流问题

417. 太平洋大西洋水流问题

有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。

这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights ， heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度 。

岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。

返回网格坐标 result 的 2D 列表 ，其中 result[i] = [ri, ci] 表示雨水从单元格 (ri, ci) 流动 既可流向太平洋也可流向大西洋 。

示例 1：

输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]

解题思路

​ 我的想法就是每个都dfs遍历一遍，碰到哪个边界，就把哪个边界+1。

​ 第一眼看到的时候还以为是大于条件，就想这不用visit了，后来才看到有等于条件，不做标记的话可能回进入无限递归

class Solution {
    static boolean left,right;
    public List<List<Integer>> pacificAtlantic(int[][] heights) {
        int n=heights.length;
        int m=heights[0].length;
        List<List<Integer>> list=new ArrayList<>();
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                boolean[][] visit=new boolean[n][m];
                //初始化能否到达两端的海面
                left=false;
                right=false;
                dfs(heights,i,j,visit);
                if(left==true && right==true)
                {
                     List<Integer> l=new ArrayList<>();
                     l.add(i);
                     l.add(j);
                     list.add(l);
                }
            }
        }
        return list;
    }
    public void dfs(int[][] heights,int i,int j,boolean[][] visit)
    {
        //判断是否达到海面
        if(i==0 || j==0)
        {
            left=true;
        }
        if(i==heights.length-1 || j==heights[0].length-1)
        {
            right=true;
        }
        //标记为已访问过
        if(visit[i][j]==true)
            return;
        visit[i][j]=true;
        //判断搜索条件
        if( j+1<heights[0].length &&  heights[i][j]>=heights[i][j+1])
            dfs(heights,i,j+1,visit);
        if( i+1<heights.length && heights[i][j]>=heights[i+1][j])
            dfs(heights,i+1,j,visit);
        if( j-1>=0 && heights[i][j]>=heights[i][j-1])
            dfs(heights,i,j-1,visit);
        if( i-1>=0 && heights[i][j]>=heights[i-1][j])
            dfs(heights,i-1,j,visit);
        return;
    }
}

419. 甲板上的战舰

419. 甲板上的战舰

给你一个大小为 m x n 的矩阵 board 表示甲板，其中，每个单元格可以是一艘战舰 'X' 或者是一个空位 '.' ，返回在甲板 board 上放置的 战舰 的数量。

战舰 只能水平或者垂直放置在 board 上。换句话说，战舰只能按 1 x k（1 行，k 列）或 k x 1（k 行，1 列）的形状建造，其中 k 可以是任意大小。两艘战舰之间至少有一个水平或垂直的空位分隔 （即没有相邻的战舰）。

示例 1：

输入：board = [[“X”,“.”,“.”,“X”],[“.”,“.”,“.”,“X”],[“.”,“.”,“.”,“X”]]
输出：2

class Solution {
    int n,m;
    public int countBattleships(char[][] board) {
        n=board.length;
        m=board[0].length;
        int s=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {

                if(board[i][j]=='X')
                {
                    dfs(board,i,j);
                    s++;
                }
            }
        }
        return s;
    }
    public void dfs(char[][] board,int i,int j)
    {
        //判断边界条件
        if(i<0 || j<0 || i>board.length-1 || j>board[0].length-1)
        {
            return;
        }
        //判断递归条件
        if(board[i][j]!='X')
        {
            return;
        }
        //标记为以访问过
        board[i][j]='.';
        //上面判断过了，直接递归
        dfs(board,i,j+1);
        dfs(board,i+1,j);
        dfs(board,i,j-1);
        dfs(board,i-1,j);
        return;
    }
}

695. 岛屿的最大面积

695. 岛屿的最大面积

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int res = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 1) {
                    res = Math.max(res, dfs(i, j, grid));
                }
            }
        }
        return res;
    }
    private int dfs(int i, int j, int[][] grid) {
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[i].length || grid[i][j] == 0) {
            return 0;
        }
        grid[i][j] = 0;
        //原本的点是1，再加上下左右爆搜出来的数量进行累加，然后返回
        return 1+dfs(i + 1, j, grid)+dfs(i - 1, j, grid)+dfs(i, j + 1, grid)+dfs(i, j - 1, grid);
    }
}

733. 图像渲染

733. 图像渲染

有一幅以 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 {
    static int n,m,oldColor;

    public int[][] floodFill(int[][] image, int sr, int sc, int color) {

        n=image.length;
        m=image[0].length;
        oldColor=image[sr][sc];
        if(oldColor==color)return image;
        dfs(image,sr,sc,color);
        return image;
    }
    public void dfs(int[][] image,int i,int j,int newColor)
    {
        //判断边界条件
        if(i<0 || j<0 || i>=n || j>=m)
        {
            return;
        }
        //判断是否进入递归条件

        if(image[i][j]==oldColor)
        {
            image[i][j]=newColor;
        }else{
            return;
        }
        dfs(image,i-1,j,newColor);
        dfs(image,i+1,j,newColor);
        dfs(image,i,j-1,newColor);
        dfs(image,i,j+1,newColor);
    }
}

1020. 飞地的数量

1020. 飞地的数量

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 1：

输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出：3
解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

class Solution {
    static int n,m;
    public int numEnclaves(int[][] grid) {
        //本题只需要从边界dfs往里面搜

        n=grid.length;
        m=grid[0].length;
        //左边界和有边界
        for(int i=0;i<n;i++)
        {
            dfs(grid,i,0);
            dfs(grid,i,m-1);
        }
        //上边界和下边界
        for(int j=0;j<m;j++)
        {
            dfs(grid,0,j);
            dfs(grid,n-1,j);
        }
        int sum=0;
        //再遍历一次,剩下的1就都是答案要求的1
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(grid[i][j]==1)
                {
                    sum++;
                }
            }
        }
        return sum;
    }
    public void dfs(int[][] grid,int i,int j)
    {
        //判断边界条件
        if(i<0 || j<0 || i>=n || j>=m)
        {
            return;
        }
        //判断是否进入递归条件
        if(grid[i][j]==0)
        {
            return;
        }
        grid[i][j]=0;
        //四个方向
        dfs(grid,i-1,j);
        dfs(grid,i+1,j);
        dfs(grid,i,j-1);
        dfs(grid,i,j+1);

    }
}