搜索算法----烦人的岛屿问题

最新推荐文章于 2023-10-16 18:06:49 发布

凌星An

最新推荐文章于 2023-10-16 18:06:49 发布

阅读量220

点赞数 1

分类专栏：有趣的OJ 文章标签： leetcode dfs 算法深度优先搜索

本文链接：https://blog.csdn.net/weixin_43519514/article/details/112093456

版权

有趣的OJ 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

被围绕的区域

给定一个二维的矩阵，包含 'X' 和 'O'（大写字母X和 O）。

找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/surrounded-regions

题解：

本题中最难的一点进行我们采用搜索算法的时候，如果对X进行判断，那么我们需要判断对角线，换需要判断是否可以构成封闭的区域等等一系列的问题。

所以我们需要转换一下思路，看看能不能通过判断O来进行解答；

如果我们判断O的话，首先我们仅仅需要判断上下左右，不需要判断对角线的位置，相对来说，更容易进行判断；

其次，我们判断X围成的区域，如果O处于边界的时候，该位置一定不处于X围成的区域；同样的，与该位置相邻的O也一定不处于X围成的区域；

所以本体的思路基本就已经形成了：

我们首先依次判断数组的判断位置，如果该位置是O的话，我们用其他字符来标识（代码中使用#，标识该位置不是出于X围成的区域中的O）；

同时采用搜索算法，将其相邻的O也用#标识；

全部判断完毕之后，将数组中的O全部变成X，将数组中的#全部变成O；

void dfs(vector<vector<char>>& board,int row,int col,int rows,int cols)
    {
        vector<vector<int>> move={{-1,0},{1,0},{0,-1},{0,1}};
         board[row][col]='#';
        for(int i=0;i<4;++i)
        {
            int x=row+move[i][0];
            int y=col+move[i][1];
            if(x>=0&&x<rows&&y>=0&&y<cols)
            {
                
                if(board[x][y]=='O')
                dfs(board,x,y,rows,cols);
            }
        }
    }
public:
    void solve(vector<vector<char>>& board) {
        if(board.empty())
        {
            return ;
        }
        int rows=board.size();
        int cols=board[0].size();
        
        for(int i=0;i<cols;++i)
        {
            if(board[0][i]=='O')
            {
               dfs(board,0,i,rows,cols);
            }
            if(board[rows-1][i]=='O')
            {
              dfs(board,rows-1,i,rows,cols);
            }
        }
        for(int i=0;i<rows;++i)
        {
            if(board[i][0]=='O')
            {
                 dfs(board,i,0,rows,cols);
            }
            if(board[i][cols-1]=='O')
            {
                 dfs(board,i,cols-1,rows,cols);
            }
        }
       

        for(int i=0;i<rows;++i)
        {
            for(int j=0;j<cols;++j)
            {
                if(board[i][j]=='O')
                {
                    board[i][j]='X';
                }
                if(board[i][j]=='#')
                {
                    board[i][j]='O';
                }
            }
        }
        return ;
        
    }

岛屿的周长

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

示例 1：

输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/island-perimeter

题解：

此题，我们主要用到了深度优先搜索算法的思想，我们需要遍历整个grid数组，每次以当前遍历的位置为基点，向周围遍历，进行搜索；

我们要求取的是陆地的周长，数组中数值为1，代表陆地，所以我们在遍历数组的时候，如果为1，进行搜索；为0的话，表示不需要以此为基点进行搜索；

当我们以陆地为基点的时候济宁搜索的时候，我们仅仅需要对齐四周进行搜索，如果一边的值为0，那么岛屿的周长便可以加一；

当然，如果我们判断的位置在数组的边界时，我们要判断的位置如果越界，岛屿周围也要加一

 int islandPerimeter(vector<vector<int>>& grid) {
        if(grid.empty())
          return 0;
        int rows=grid.size();
        int cols=grid[0].size();
        vector<vector<int>> move={{-1,0},{1,0},{0,-1},{0,1}};
        int ret=0;
        for(int i=0;i<rows;++i)
        {
            for(int j=0;j<cols;++j)
            {
                if(grid[i][j]==1)
                {
                    
                    int count=0;
                    for(int k=0;k<4;++k)
                    {   
                        int x=i+move[k][0];
                        int y=j+move[k][1];
                        if(x>=0&&x<rows&&y>=0&&y<cols)
                          {
                              if(grid[x][y]==0)
                              count++;
                          }
                          else
                          {
                              count++;
                          }
                    }
                    ret+=count;
                }
                
            }
        }
     return ret;
    }

岛屿数量

给你一个由 '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
示例 2：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands

题解：

这道题，我们同样需要遍历二维数组，不过与前两题不同的是，相邻的1是处于一片陆地的，所以，我们需要对遍历过的地方进行标记，否则程序将会出现死循环；

代码思路：

1.遍历二维数组grid

2.如果该位置为1，我们需要进行搜索附近的陆地，我们将搜索过的陆地标记为2，避免程序死循环；

vector<vector<int>> move={{-1,0},{1,0},{0,-1},{0,1}};
    void dfs(vector<vector<char>>& grid,int row,int col,int rows,int cols)
    {
         
        grid[row][col]='2';
        for(int i=0;i<4;++i)
        {
            int x=row+move[i][0];
            int y=col+move[i][1];
            if(x>=0&&x<rows&&y>=0&&y<cols)
            {
                if(grid[x][y]=='1')
                dfs(grid,x,y,rows,cols);
            }
        }
        
    }

    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty())
         return 0;
        
        int rows=grid.size();
        int cols=grid[0].size();

         int ret=0;
        for(int i=0;i<rows;++i)
        {
            for(int j=0;j<cols;++j)
            {
                if(grid[i][j]=='1')
                 {
                     ret++;
                     dfs(grid,i,j,rows,cols);
                 }
            }
        }
        return ret;
    }

岛屿的最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid 。

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

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

示例 1:

[[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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-area-of-island

这道题与上个题的解法类似，同样要注意的问题就是，我们要对访问过得地方进行标记，避免出现死循环的情况；

vector<vector<int>>  move={{-1,0},{1,0},{0,-1},{0,1}};
     void dfs(vector<vector<int>>& grid,int row,int col,int rows,int cols,int& cur)
     {
         cur+=1;
         grid[row][col]=2;
         for(int i=0;i<4;++i)
         {
             int x=row+move[i][0];
             int y=col+move[i][1];
             if(x>=0&&x<rows&&y>=0&&y<cols)
             {
                 if(grid[x][y]==1)
                 dfs(grid,x,y,rows,cols,cur);
             }
         }
     }

    int maxAreaOfIsland(vector<vector<int>>& grid) {
        if(grid.empty())
        {
            return 0;
        }

        int rows=grid.size();
        int cols=grid[0].size();
        
        int ret=0;//整个区域的最大陆地面积
        int cur=0;//我们遍历的当前的陆地面积
        for(int i=0;i<rows;++i)
        {
            for(int j=0;j<cols;++j)
            {
            if(grid[i][j]==1)
            {
                cur=0;
                dfs(grid,i,j,rows,cols,cur);
                ret=max(ret,cur);
            }
               
            }
        }
        return ret;
    }

注：如果本篇博客有任何错误和建议，欢迎伙伴们留言，你快说句话啊！

凌星An

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
搜索算法----烦人的岛屿问题

岛屿的周长给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。示例 1：输入：g.
复制链接

扫一扫