广度优先搜索（Breadth First Search）

Date：2019-07-03 14:29:02

• 走完一层的所有房间，再走下一层，用队列实现

算法实现

 /*--------------------------模版----------------------*/
 void BFS(int s)
 {
     queue<int> q;
     q.push(s);
     while(!q.empty())
     {
         //取出队首元素top
         //访问队首元素top
         //将队首元素出列
         //将top的下一层结点中未曾入队的结点全部入队，并设置为已入队
     }
 }

 /*--------------------------访问-----------------------*/
 struct node
 {
     int data;
 }a[];

 int main()
 {
     queue<int> q, p;
     for(int i=; i<=; i++)
     {
         a[i].data = i;  //a[1]=1,a[2]=2,a[3]=3
         q.push(i);      //这里将数组的下标入队，而非数组，可以避免传递形参，而无法修改实参的情况
         p.push(a[i]);
     }
     p.front().data = ;       //形参无法修改实参
     printf("%d\n", a[].data);  //output:1
     a[] = ;                      //实参也无法修改形参
     printf("%d\n", p.front().data); //output:1

     a[q.front()].data = ;    //通过传递下标，可以修改实参的值
     printf("%d\n", a[].data);  //output:100
     return ;
 }
 /*-------------------------矩阵问题--------------------*/
 /*
 Descriptation:
     给出一个m*n的矩阵，矩阵中的元素为0或1。称位置(x,y)与其上下左右四个位置是相邻的。
 如果矩阵中有若干个1是相邻的（不必两两相邻），那么称这些1构成了一个“块”。求给定的矩阵
 中“块”的个数。

 Sample Input:
 0 1 1 1 0 0 1
 0 0 1 0 0 0 0
 0 0 0 0 1 0 0
 0 0 0 1 1 1 0
 1 1 1 0 1 0 0
 1 1 1 1 0 0 0

 Sample output:
 4
 */

 #include <cstdio>
 #include <queue>
 using namespace std;
 const int MAX_SIZE = ;
 struct node
 {
     int x, y;
     int data;
     bool status;        //status表示是否入队，而非是否已访问，否则会重复访问
 }matrix[MAX_SIZE][MAX_SIZE];

 //X[],Y[]存放四个操作方向
 int n, m, X[]={,,,-}, Y[]={,-,,};
 queue<node> q;

 void Init()
 {
     for(int i=; i<n; i++)
         for(int j=; j<m; j++)
         {
             scanf("%d", &matrix[i][j].data);
             matrix[i][j].status = true;
             matrix[i][j].x = i;
             matrix[i][j].y = j;
         }
 }

 void BFS(node x)
 {
     q.push(x);
     while(!q.empty())
     {
         node s = q.front();
         q.pop();
         matrix[s.x][s.y].status = false;        //这里不能修改s,需要修改matrix内的元素
         if(s.data)
         {
             for(int i=; i<; i++)
             {
                 int nowX = s.x + X[i];
                 int nowY = s.y + Y[i];
                 if(nowX< || nowX>=n || nowY< || nowY>=m)
                     continue;
                 if(matrix[nowX][nowY].data && matrix[nowX][nowY].status)
                     q.push(matrix[nowX][nowY]);
             }
         }
     }
 }

 int main()
 {
 #ifdef ONLINE_JUDGE
 #else
     freopen("Test.txt", "r", stdin);
 #endif // ONLINE_JUDGE

     scanf("%d%d", &n, &m);
     Init();
     int cnt = ;
     for(int i=; i<n; i++)
         for(int j=; j<m; j++)
         {
             if(matrix[i][j].data && matrix[i][j].status)
             {
                 BFS(matrix[i][j]);
                 cnt++;
             }
         }
     printf("%d\n", cnt);

     return ;
 }
 /*-------------------------迷宫问题--------------------*/
 /*
 Description:
     给定一个n*m大小的迷宫，其中*代表不可通过的墙壁，而“.”代表平底，S表示起点，T表示终点。
 移动过程中，如果当前位置是（x,y）（下标从0开始），且每次只能前往上下左右四个位置的平地，
 求从起点到达终点的T的最小步数；

 Sample Input:
 . . . . .
 . * . * .
 . * S * .
 . * * * .
 . . . T *
 */

 #include <cstdio>
 #include <queue>
 using namespace std;
 const int MAX_SIZE = ;
 struct node
 {
     char data;
     bool status;
     int x, y;
     int level;
 }matrix[MAX_SIZE][MAX_SIZE];

 int n, m, X[]={,,,-}, Y[]={,-,,};
 void Init()
 {
     scanf("%d%d", &n, &m);
     getchar();
     for(int i=; i<n; i++)
     {
         for(int j=; j<m; j++)
         {
             matrix[i][j].data = getchar();
             getchar();
             matrix[i][j].status = true;
             matrix[i][j].x = i;
             matrix[i][j].y = j;
         }
     }

 }

 int BFS(node s)
 {
     queue<node> q;
     q.push(s);
     matrix[s.x][s.y].level = ;
     while(!q.empty())
     {
         node v = q.front();
         q.pop();
         matrix[v.x][v.y].status = false;
         for(int i=; i<; i++)
         {
             int nowX = v.x+X[i];
             int nowY = v.y+Y[i];
             if(nowX< || nowX>=n || nowY< || nowY>=m)
                 continue;
             if(matrix[nowX][nowY].data=='.' && matrix[nowX][nowY].status)
             {
                 q.push(matrix[nowX][nowY]);
                 matrix[nowX][nowY].level = matrix[v.x][v.y].level+;
             }
             else if(matrix[nowX][nowY].data=='T')
                 return matrix[v.x][v.y].level;
         }
     }
     return -;  //无法到达
 }

 int main()
 {
 #ifdef ONLINE_JUDGE
 #else
     freopen("Test.txt", "r", stdin);
 #endif // ONLINE_JUDGE

     Init();
     for(int i=; i<n; i++)
         for(int j=; j<m; j++)
             if(matrix[i][j].data=='S')
                 printf("%d\n", BFS(matrix[i][j]));

     return ;
 }