一、原题

对于一个01矩阵A，求其中有多少片连成一片的1。每个1可以和上下左右的1相连。

请为下面的Solution类实现解决这一问题的函数countConnectedOnes，函数参数A为给出的01矩阵，A的行数和列数均不大于1000。函数的返回值是问题的答案。

例1：
A=
100
010
001
答案为3.

例2：
A=
1101
0101
1110
答案为2.

二、思路

该题明显就是一个图的广度优先遍历的题目，从图中一个1开始作为起点，使用广度优先遍历，遍历的步骤如下：

1. 将起点S（节点值为1）存入到一个队列中；
2. 从队列中取出一个节点N（第一次执行时候该节点便是起点S），将该节点N周边（左右上下四个方位）为1的节点也存储到队列中；
3. 重复步骤2直至队列为空；
4. 此时遍历完一个包含S的区域，结果值加1；
5. 重复步骤1直至遍历所有起点；

三、时间优化

大体思路如上，但还需注意一些细节，这些细节能够节省执行的时间：

• 对于每一个起点S，可以将该节点置为0，避免后面在广度优先遍历中重复将该起点S加入到队列中；
• 对于一个节点N的广度遍历，当扫描到下一个节点M为1时，立即将节点M置为0，能够防止别其他节点N'重复将M加入到队列中（这个是我前几次超时的主要原因）；

通过以上两点，能够保证矩阵每一个值为1节点只被放入到队列中一次，也就是保证每一个1只被检测一遍。

四、代码

struct Node {
    int x;
    int y;

    Node(int r, int c) {
        x = r;
        y = c;
    }
};

int countConnectedOnes(vector<vector<char>> &A) {
    if (A.empty() || A[0].empty()) {
        return 0;
    }

    set<Node> locOfOne;
    int row = A.size();
    int col = A[0].size();

    queue<Node> que;
    int ans = 0;

    for (int i = 0; i < row; ++i) {
        for (int j = 0; j < col; ++j) {
            if (A[i][j] == '0') {
                continue;
            }

            A[i][j] == '0';          
            Node n(i, j);
            while (!que.empty()) {
                que.pop();
            }
            que.push(n); // 步骤1

            while (!que.empty()) {
                Node tmp = que.front(); // 步骤2
                que.pop();

                // MOVE LEFT
                if (tmp.y - 1 >= 0 && A[tmp.x][tmp.y - 1] == '1') {
                    A[tmp.x][tmp.y - 1] = '0'; // 在这里设置为0能够防止一个节点被放入到队列两次，下同
                    Node left(tmp.x, tmp.y - 1);
                    que.push(left);
                }

                // MOVE RIGHT
                if (tmp.y + 1 < col && A[tmp.x][tmp.y + 1] == '1') {
                    A[tmp.x][tmp.y + 1] = '0';
                    Node right(tmp.x, tmp.y + 1);
                    que.push(right);
                }

                // MOVE UP
                if (tmp.x - 1 >= 0 && A[tmp.x - 1][tmp.y] == '1') {
                    A[tmp.x - 1][tmp.y] = '0';
                    Node up(tmp.x - 1, tmp.y);
                    que.push(up);
                }

                // MOVE DOWN
                if (tmp.x + 1 < row && A[tmp.x + 1][tmp.y] == '1') {
                    A[tmp.x + 1][tmp.y] = '0';
                    Node down(tmp.x + 1, tmp.y);
                    que.push(down);
                }
            } // 步骤3
            ans++; // 步骤4
        }
    } // 步骤5
    return ans;
}