代码随想录算法训练营第六十五天 | 岛屿数量 深搜、岛屿数量 广搜、岛屿的最大面积

岛屿数量 深搜

题目链接：99. 岛屿数量

文字讲解：99. 岛屿数量 | 代码随想录

解题思路

本题已经说明，只有水平方向和竖直方向才能组成岛屿 

本题思路，是遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。 

#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void dfs(const vector<vector<int>>& grid ,vector<vector<bool>>& visited , int x, int y)
{
      if(visited[x][y] || grid[x][y] == 0)
      {
          return;    //访问过了，或者遇到海水后就返回
      }
      visited[x][y] = true;
      for(int i =0 ; i<4; i++)
      {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            int n = grid.size();
            int m = grid[0].size();
            if(nextx<0 || nextx >=n || nexty < 0 || nexty >= m)
            continue;   //如果越界了，就直接下一个
            dfs(grid,visited,nextx,nexty);
      }
}

int main()
{
    int result,n,m;
    cin>>n >> m;
    vector<vector<int>> grid(n,vector<int>(m,0));
    vector<vector<bool>> visited(n,vector<bool>(m,false));
    for(int i =0 ; i< n ; i++)
    {
        for(int j =0 ; j< m ; j++)
        {
              cin >> grid[i][j];
        }
    }
    result = 0 ;   //目前岛屿为0
    for(int i =0 ; i< n ; i++)
    {
        for(int j =0 ; j< m ; j++)
        {
              if(!visited[i][j] && grid[i][j]==1)
              {
                  //没有访问过，并且是陆地的话
                  result++;
                  dfs(grid,visited,i,j);
              }
              
        }
    }
    cout<< result << endl;
}

岛屿数量 广搜

题目链接：99. 岛屿数量

文字讲解：99. 岛屿数量 | 代码随想录

解题思路

本题的思路是一样的

但是切记，入队就是标记为访问过了，否则会重复入队，如下图

 

#include<bits/stdc++.h>
using namespace std;
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void bfs(const vector<vector<int>>& grid ,vector<vector<bool>>& visited , int x, int y)
{
      queue<pair<int,int>> que;
      que.push({x,y});
      visited[x][y] = true;   //入队就代表访问过了
      while(!que.empty())
      {
           pair<int,int> cur = que.front();
           que.pop();
           int curx = cur.first;
           int cury = cur.second;
           for(int i =0 ;i<4 ; i++)
           {
               int nextx = curx + dir[i][0];
               int nexty = cury + dir[i][1];
               int n = grid.size();
               int m = grid[0].size();
               if(nextx<0 || nextx >= n || nexty<0 || nexty >= m)
               continue;   //越界就继续
               if(!visited[nextx][nexty]  && grid[nextx][nexty] == 1)
               {
                  que.push({nextx,nexty});
                  visited[nextx][nexty] = true;
               }
           }
      }
}

int main()
{
    int result,n,m;
    cin>>n >> m;
    vector<vector<int>> grid(n,vector<int>(m,0));
    vector<vector<bool>> visited(n,vector<bool>(m,false));
    for(int i =0 ; i< n ; i++)
    {
        for(int j =0 ; j< m ; j++)
        {
              cin >> grid[i][j];
        }
    }
    result = 0 ;   //目前岛屿为0
    for(int i =0 ; i< n ; i++)
    {
        for(int j =0 ; j< m ; j++)
        {
              if(!visited[i][j] && grid[i][j]==1)
              {
                  //没有访问过，并且是陆地的话
                  result++;
                  bfs(grid,visited,i,j);
              }
              
        }
    }
    cout<< result << endl;
}

岛屿的最大面积

题目链接：100. 岛屿的最大面积
文字讲解：100. 岛屿的最大面积 | 代码随想录

解题思路

与上两题一样的思路，这里使用广搜

using namespace std;
#include <bits/stdc++.h>
int dir[4][2] = {0,1,1,0,0,-1,-1,0};
void bfs(const vector<vector<int>>& grid , vector<vector<bool>>& visited , int x , int y, int& area)
{
    queue<pair<int,int>> que;
    que.push({x,y});
    visited[x][y] = true;
    area +=1;    //第一个点也是面积
    while(!que.empty())
    {
        pair<int,int> cur = que.front();
        que.pop();
        int curx = cur.first;
        int cury = cur.second;
        for(int i=0 ; i<4; i++)
        {
            int nextx = curx + dir[i][0];
            int nexty = cury + dir[i][1];
            int n = grid.size();
            int m = grid[0].size();
            if(nextx<0 || nextx>= n || nexty < 0 || nexty >=m)
                continue;
            if(!visited[nextx][nexty] && grid[nextx][nexty]==1)
            {
                 que.push({nextx,nexty});
                 visited[nextx][nexty] = true;
                 area+=1;
            }
        }
    }
}

int main()
{
    int result = 0;
    int n,m;
    cin>>n>>m;
    vector<vector<int>> grid(n,vector<int>(m,0));
    vector<vector<bool>> visited(n,vector<bool>(m,false));
    for(int i =0 ; i<n ; i++)
    {
        for(int j =0 ;j < m; j++)
        {
             cin>>grid[i][j];
        }
    }
    for(int i =0 ; i<n ; i++)
    {
        for(int j =0 ;j < m; j++)
        {
             if(!visited[i][j] && grid[i][j]==1)
             {
                  int area = 0;
                  bfs(grid,visited,i,j,area);
                  result = max(result,area);
             }
        }
    }
    cout << result << endl;
}