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

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

示例 1:

输入:
11110
11010
11000
00000

输出: 1

示例 2:

输入:
11000
11000
00100
00011

输出: 3

思路：把一座岛的每一个‘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);
            }
        }
    }
};