Leetcode算法题：岛屿数量（BFS&DFS）

最新推荐文章于 2022-07-02 15:07:33 发布

yfy2022yfy

最新推荐文章于 2022-07-02 15:07:33 发布

阅读量587

点赞数

分类专栏：数据结构&算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/yfy1127yfy/article/details/102955020

版权

数据结构&算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

示例 2:

思路：把一座岛的每一个‘1’都访问过了，就重新去访问下一座岛，这时候岛的数量+1。

1、广度优先搜索（BFS）

（1）使用队列和BFS，从根节点开始，把所有相邻（上下左右）子节点‘1’放入队列

（2）对队列中的节点依次进行访问并标记，将它们各自的相邻子节点也放入队列

（3）重复（1）（2）步骤，遍历访问第一座岛所有‘1’之后会跳出循环

（4）如果网格中还有坐标没访问，就继续访问，尝试重复（1）（2）（3）

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.size() == 0) return false;
        int number = 0;
        rows = grid.size();
        cols = grid[0].size();
        vector<vector<bool>> visited(rows,vector<bool>(cols,0));
        for(int i=0;i<rows;i++)
        {
            for(int j=0;j<cols;j++)
            {
                if(grid[i][j]=='1' && visited[i][j]==false)
                {
                    number++;
                    bfs_search(grid,visited,i,j);
                }
            }
        }
        return number;
    }

private:
    
    int rows;
    int cols;
    void bfs_search(vector<vector<char>>& grid,vector<vector<bool>>& visited,int i,int j) {
        queue<pair<int,int>> nerghbor;
        nerghbor.push(make_pair(i,j));
        while(!nerghbor.empty())
        {
            int m,n;
            m=nerghbor.front().first;
            n=nerghbor.front().second;
            nerghbor.pop();
            add_Sub_Node(grid,visited,nerghbor,m-1,n);
            add_Sub_Node(grid,visited,nerghbor,m+1,n);
            add_Sub_Node(grid,visited,nerghbor,m,n-1);
            add_Sub_Node(grid,visited,nerghbor,m,n+1);
           
        }       
    }

    void add_Sub_Node(vector<vector<char>>& grid,vector<vector<bool>>& visited,queue<pair<int,int>> &nerghbor,int i,int j)
    {
        if(i>=0 && i<rows && j>=0 && j<cols)
        {
            if(grid[i][j]=='1' && visited[i][j]==false)
            {
                visited[i][j]=true;
                nerghbor.push(make_pair(i,j));
            }
        }
    }
};

2、DFS深度优先搜索

（1）使用递归的方法，从根节点开始，深入每个方向（上下左右），依次访问该方向相邻的‘1’，并标记为已访问，直到边界或‘0’或已访问的值。

（2）遍历访问第一座岛所有‘1’之后会跳出循环

（4）如果网格中还有坐标没访问，就继续访问，尝试重复（1）（2）

class DFS_numIlands {
public:
    int numIslands(vector<vector<char>>& grid) {
        if (grid.size() == 0) return false;
        int number = 0;
        rows = grid.size();
        cols = grid[0].size();
        vector<vector<bool>> visited(rows, vector<bool>(cols, 0));
        for (int i = 0; i<rows; i++)
        {
            for (int j = 0; j<cols; j++)
            {
                if (grid[i][j] == '1' && visited[i][j] == false)
                {
                    number++;
                    dfs_search(grid, visited, i, j);

                }
            }
        }
        return number;
    }

private:

    int rows;
    int cols;
    void dfs_search(vector<vector<char>>& grid, vector<vector<bool>>& visited, int i, int j)
    {
        if (i >= 0 && i<rows && j >= 0 && j<cols)
        {
            if (grid[i][j] == '1' && visited[i][j] == false)
            {
                visited[i][j] = true;
                dfs_search(grid, visited, i - 1, j);
                dfs_search(grid, visited, i + 1, j);
                dfs_search(grid, visited, i, j - 1);
                dfs_search(grid, visited, i, j + 1);
            }
        }
    }
};