广度优先搜索详解优化体会

前言

在刷了一阵子广搜的题目之后，写篇博客帮自己消化一下，也帮助还没有理解广搜的朋友理解。

广搜与深搜的区别

广搜（Breadth First Search），顾名思义，以广度为第一关键词。深搜则以深度（Depth）为关键词，但二者一般都可以解决同一类题目。
以经典的迷宫问题来解释——：

遍历这个图要分为以下几步：

1. 访问第一层（A），发现A能到达B,C（第二层），所以接下来访问B，C；
2. 访问第二层（B,C），先访问B（第二层），能到（第三层）D,E ,然后访问C（第二层），能到 G,F（第三层），至此，第二层访问完毕。
3. 同理，依次访问D,E,G,F(第三层),发现G是出口，后面的未访问的就不用理会了。

因此BFS一般都有队列实现（双向BFS需要两个栈），
下面得出BFS的伪代码：

void bfs(int root){
    queue<int>q;
    q.push(root);//第一层
    while(!q.empty()){
         队首出队，记录为curr。
         访问curr的下一层，将其入队，并设为已经入队
         }
    }

以leetcode上的一个简单的BFS模板题来解析：
题目
在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。
题目链接
：https://leetcode-cn.com/problems/rotting-oranges

测试样例

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4
输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

解题完整代码

class Solution {
public:
struct node{
    int x,y,levl;//坐标，层数
    node(){}//构造结构体赋初值函数
    node(int a,int b,int c):x(a),y(b),levl(c){}
}Node;
    int orangesRotting(vector<vector<int>>& grid) {
                queue<node>q;
                 int m=grid.size(),n=grid[0].size(),ans=0;
                  int cn=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==2)//将所有已经腐烂的入队，作为第一层
                  q.push(node(i,j,0));
                  if(grid[i][j]==1)
                    cn++;//计算新鲜的橘子数目
            }
        }
         int Max=0;
       while(!q.empty()){
           node  f=q.front();
           q.pop();
            Max=max(Max,f.levl);//最大层数，方便随时更新
           for(int i=-1;i<=1;i++){
               for(int j=-1;j<=1;j++){
                   if(abs(i+j)==0||abs(i+j)==2)continue;
                  int x1=f.x+i;
                  int y1=f.y+j;
                  if(x1<0||x1>=m||y1<0||y1>=n||grid[x1][y1]==2||grid[x1][y1]==0)continue;
                    grid[x1][y1]=2;
                    q.push(node(x1,y1,f.levl+1));
                    cn--;
               }
           }
       } 
       return cn==0 ? Max:-1;
    }
};

下面再进阶的看一题：
题目
让我们一起来玩扫雷游戏！

给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷，‘E’ 代表一个未挖出的空方块，‘B’ 代表没有相邻（上，下，左，右，和所有4个对角线）地雷的已挖出的空白方块，数字（‘1’ 到 ‘8’）表示有多少地雷与这块已挖出的方块相邻，‘X’ 则表示一个已挖出的地雷。

现在给出在所有未挖出的方块中（‘M’或者’E’）的下一个点击位置（行和列索引），根据以下规则，返回相应位置被点击后对应的面板：

如果一个地雷（‘M’）被挖出，游戏就结束了- 把它改为 ‘X’。
如果一个没有相邻地雷的空方块（‘E’）被挖出，修改它为（‘B’），并且所有和其相邻的方块都应该被递归地揭露。
如果一个至少与一个地雷相邻的空方块（‘E’）被挖出，修改它为数字（‘1’到’8’），表示相邻地雷的数量。
如果在此次点击中，若无更多方块可被揭露，则返回面板。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minesweeper
测试样例：

输入: 

[['E', 'E', 'E', 'E', 'E'],
 ['E', 'E', 'M', 'E', 'E'],
 ['E', 'E', 'E', 'E', 'E'],
 ['E', 'E', 'E', 'E', 'E']]

Click : [3,0]

输出: 

[['B', '1', 'E', '1', 'B'],
 ['B', '1', 'M', '1', 'B'],
 ['B', '1', '1', '1', 'B'],
 ['B', 'B', 'B', 'B', 'B']]

题目分析
分析题目可得出三种情况（想了好久，太菜了）

1. 直接点到雷，变成‘X’,直接返回board。
2. click点周围有雷，遍历好周围的雷的数目，直接返回
3. click点周围没有雷，依次遍历图

代码

class Solution {
public:
/*
1.点是不是雷，
2.判断点周围有没有雷（不会是第一次就有雷）；
3.深搜，遇到周围有雷的点就返回。
*/

    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
          int m=board.size(),n=board[0].size();
          int x=click[0],y=click[1];
          if(board[x][y]=='M'){
              board[x][y]='X';//第一种情况
              return board;
          }
          vector<vector<int> >mid(m,vector<int>(n,0));
         for(int i=0;i<m;i++){
             for(int j=0;j<n;j++){
                     if(board[i][j]=='M'||board[i][j]=='X'){
                         for(int k=-1;k<=1;k++){
                             for(int l=-1;l<=1;l++){
                                 if(k==0&&l==0)continue;
                                 int x1=k+i;
                                 int y1=l+j;
                                 if(x1>=0&&x1<m&&y1>=0&&y1<n)++mid[x1][y1];
                             }
                         }
                     }
             }
         }
         if(mid[click[0]][click[1]]>0){
             board[click[0]][click[1]]='0'+mid[click[0]][click[1]];
             return board;//第二种情况
         }//??
         queue<pair<int,int> >q;
         q.push(make_pair(click[0],click[1]));
         board[click[0]][click[1]]='B';
         while(!q.empty()){
             pair curr=q.front();
             q.pop();
               int x=curr.first;
               int y=curr.second;
               //board[x][y]='B';
             for(int i=-1;i<=1;i++){
                 for(int j=-1;j<=1;j++){
                      if(i==0&&j==0)continue;
                    int x1=x+i;
                    int y1=y+j;
                    if(x1>=0&&x1<m&&y1>=0&&y1<n){
                        if(mid[x1][y1]>0)
                           board[x1][y1]=mid[x1][y1]+'0';//点周围有雷，更新点的值
                        else if(board[x1][y1]=='E'){
                           board[x1][y1]='B';
                            q.push(make_pair(x1,y1));
                        }
                    }
                 }
             }
         }
         return board;
    
     
        
    }
};