Leetcode岛屿数量(C++)

https://leetcode-cn.com/explore/learn/card/queue-stack/217/queue-and-bfs/872/

题目描述：

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

样例1：

输入:
11110
11010
11000
00000
输出: 1

样例2：

输入:
11000
11000
00100
00011
输出: 3

解题思路：

要求：没有被访问过且值为‘1’

依次访问每个方格，如果该方格要求，则将该方格设置为被访问过，并将该方格x、y坐标加入队列，然后获取其上下左右方格位置，符合要求也将x、y坐标加入队列。按照队列顺序依次访问方格。

这里使用了BFS(以二叉树为例，逐层遍历节点)，此处提供模板：

/**
 * Return the length of the shortest path between root and target node.
 */
int BFS(Node root, Node target) {
    Queue<Node> queue;  // store all nodes which are waiting to be processed
    Set<Node> used;     // store all the used nodes
    int step = 0;       // number of steps neeeded from root to current node
    // initialize
    add root to queue;
    add root to used;
    // BFS
    while (queue is not empty) {
        step = step + 1;
        // iterate the nodes which are already in the queue
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                if (next is not in used) {
                    add next to queue;
                    add next to used;
                }
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

解题代码：

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

#include
#include
#include
using namespace std;

class Solution{
    private:
        queue<int> que; //存储符合要求的坐标
        int x=0;
        int y=0;
        int xx=0;
        int yy=0;
        int cur=0;
    public:
        int numIslands(vector<vector<char> >& grid) {
            // 当前方格的行列数
            int row=grid.size();
            int col=row>0?grid[0].size():0;
            // 当前点上下左右坐标
            int dx[]={-1,0,1,0};
            int dy[]={0,-1,0,1};
            if(row==0 || col==0){
                return 0;
            }
            for(int i=0;i<row;i++){
                for(int j=0;j<col;j++){
                    // 访问值为1的格子 然后置为0
                    if(grid[i][j]=='1'){
                        grid[i][j]='0';
                        que.push(i);
                        que.push(j);
                        while(!que.empty()){
                            x=que.front();
                            que.pop();
                            y=que.front();
                            que.pop();
                            for(int k=0;k<4;k++){
                                xx=x+dx[k];
                                yy=y+dy[k];
                                if(xx<0 || xx>=row || yy<0 || yy>=col){
                                    continue;
                                }

                                if(grid[xx][yy]=='1'){
                                    grid[xx][yy]='0';
                                    que.push(xx);
                                    que.push(yy);
                                }
                            }
                        }
                        cur++;
                    }
                }
            }
            return cur;
        }
};
int main()
{
    vector<vector<char> > data;
    int cur;
    Solution* obj = new Solution();
    char a;
    // 设置二维队列的行数
    for(int i=0;i<4;i++)
    {
        data.push_back(vector<char>());
    }
    // 二维队列输入
    for(int i=0;i<data.size();i++)
    {
        for(int j=0;j<5;j++){
            cin>>a;
            data[i].push_back(a);
        }
    }
    /* 输出测试
    for(int i=0;i
    cur = obj->numIslands(data);
    cout<<cur<<endl;
    return 0;
}