广度优先搜索（BFS）的一个（重要！）细节（可能因此卡题）

引言：

为了一个广度优先搜索的细节有必要水一整篇文章？有必要。

这个细节非常重要，以至于我在切Leetcode某一题的时候，明明和答案的高效率通过的代码相差无几，逻辑毫无错误，STL使用相同，但仍然有几个测试点卡不过去。

题目来源：200.岛屿数量

---

我原来的代码：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
       // vector<vector<bool>> visited(grid.size(),vector<bool>(grid[0].size(),false));
        //int dx[4] = {1,0,-1,0};
        //int dy[4] ={0,-1,0,1};
        int res = 0;
        int r= grid.size();
        int c = grid[0].size();
        for(int i = 0;i<r;++i){
            for(int j  =0;j<c;++j){
                if(grid[i][j] == '0')continue;
                queue<pair<int,int>> q;
                q.push({i,j});
                res ++;
                grid[i][j] = '1';
                while(!q.empty()){
                    int x = q.front().first;
                    int y = q.front().second;
                    q.pop();
                    grid[x][y] = '0';
                    /*
                    for(int k = 0;k<4;++k){
                        int xx = x+dx[k];
                        int yy = y+dy[k];
                        if(xx<0||xx>=grid.size() ||yy<0||yy>=grid[0].size()||grid[xx][yy]=='0'){
                            continue;
                        }
                        q.push(make_pair(xx,yy));
                    }*/
                    if(x-1>=0 && grid[x-1][y]=='1')q.push({x-1,y});
                    if(y-1>=0 &&grid[x][y-1]=='1')q.push({x,y-1});
                    if(x+1<r&&grid[x+1][y]=='1')q.push({x+1,y});
                    if(y+1<c&&grid[x][y+1]=='1')q.push({x,y+1});
                }
            }
        }
        return res;
    }
};

代码运行后，总是超时。

我做了许多猜测与尝试，排除了  另外开visited数组、make_pair、dx[]与dy[]、甚至访问vector的size()等可能导致超时的因素。

但是都没有太大的效果。

于是排除所有可能，真相就只有一个了——

先来看看答案代码：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    grid[r][c] = '0';
                    queue<pair<int, int>> neighbors;
                    neighbors.push({r, c});
                    while (!neighbors.empty()) {
                        auto rc = neighbors.front();
                        neighbors.pop();
                        int row = rc.first, col = rc.second;
                        if (row - 1 >= 0 && grid[row-1][col] == '1') {
                            neighbors.push({row-1, col});
                            grid[row-1][col] = '0';
                        }
                        if (row + 1 < nr && grid[row+1][col] == '1') {
                            neighbors.push({row+1, col});
                            grid[row+1][col] = '0';
                        }
                        if (col - 1 >= 0 && grid[row][col-1] == '1') {
                            neighbors.push({row, col-1});
                            grid[row][col-1] = '0';
                        }
                        if (col + 1 < nc && grid[row][col+1] == '1') {
                            neighbors.push({row, col+1});
                            grid[row][col+1] = '0';
                        }
                    }
                }
            }
        }

        return num_islands;
    }
};
作者：LeetCode
链接：https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-shu-liang-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

对比可以发现，答案与我的代码里面一个看似没什么影响的差别在于：

我的代码是从队列中弹出节点时才把这个节点标记为<已访问>，而答案代码里是在push进队列的时候就标记其为<未访问>。

看似没有什么逻辑问题啊。

但是，

我仔细

仔细

想了想。

这实际上导致的效率差别是巨大的！

比如，在访问cur节点的时候，把一个B节点push了进队列（也就是说B节点是cur节点的邻居节点），

如果我此刻没有标记其为<已访问>的话，

那么我在访问队列中排在B前面的节点cur2时（即在cur之后，B之前，被push进队列的节点）,

如果我在cur2的邻居节点里看到了B，此刻由于B还没有出队列，所以它目前未被标记为<已访问>

那么，此时B又会再一次被push进队列里面！！！

也就是说，一个节点会被访问多次，那运行时间固然就翻倍了。

由此可见这个细节的重要性之大。

（如果比赛的时候因为这个细节卡题了的话，我想我就不会痛失倒一了吧。）