广度优先遍历的几个例题

题目来自《啊哈！算法》

1.广度优先搜索遍历二维数组迷宫

0 0 1 0

0 0 0 0

0 0 1 0

0 1 # 0

0 0 0 1

（下标从1开始，#为终点，左上角为起点）

先上代码

#include "stdafx.h"#include "iostream"using namespace std;typedef struct Queue{int x;int y;int step;};void main(){int next[4][2] = { 0,1,1,0,0,-1,-1,0 };Queue q[21];//head          tailbool visited[6][5] = { false };int map[6][5] = { 0 };map[1][3] = 1;map[3][3] = 1;map[4][2] = 1;map[5][4] = 1;int tail=1, head = 1;q[tail].x = 1;q[tail].y = 1;q[tail].step = 0;visited[1][1] = true;tail++;    //第一个先进队列int tx=0, ty=0;int flag = 0;while (head < tail)//队列不为空{for (int i = 0;i <= 3;i++)    //第一个点入队列，开始对这个点进行尝试{tx = q[head].x + next[i][0];//遍历next数组，对四个方向进行尝试ty = q[head].y + next[i][1];if (tx < 1 || tx>5 || ty < 1 || ty>4)  //结束条件1，超出边界continue;if (map[tx][ty] == 0 && visited[tx][ty] == false)//条件成立，将这个位置入队列{q[tail].x = tx;q[tail].y = ty;q[tail].step = q[head].step+1;//步数是上一步的步数+1，比如之前是在1，1visited[tx][ty] = true;       //那么下一次是1，2和2，1入队列，这两个的step都是1，1的step+1tail++;                       //所以，这个for就是将某个位置周围的位置全部入队}                                 //全部入队后，该位置就算遍历完了，出队，然后开始重新遍历队首的位置if (tx == 4 && ty == 3)   //广搜搜到位置后就可以结束了，不像深搜，所以直接结束两个循环{flag = 1;break;}}if (flag)break;head++;//表示出队}cout << q[tail - 1].step;//tail指的是空的地方}

所谓广度优先遍历，就是通过一个队列的帮助，一开始将开始位置入队，然后开始对队首的位置开始不断向周围尝试，如果可以走，比如1，1到1，2和2，1，就将这两个位置全部入队，然后1，1就算遍历完了，出队，队首变成1，2，开始对1，2向四周尝试，依次入队，然后1，2出队，开始对2，1各种尝试，然后，1，2出队，中间处理下访问标记和step的+1，注意尝试1，2入队的位置的step是1，2的+1，而尝试2，1入队的位置的step是2，1的step+1，互相分开的。这样，这个队列会将所有的位置全部遍历，并找到一条连通的位置。不像深度，广度不需要回溯，因为尝试关系是平行的。深搜和广搜的区别恐怕还得多做做题才能找到真正的区别，看得太浅。

2.求岛屿面积

1，2，1，0，0，0，0，0，2，3

3，0，2，0，1，2，1，0，1，2

4，0，1，0，1，2，3，2，0，1

3，2，0，0，0，1，2，4，0，0

0，0，0，0，0，0，1，5，3，0

0，1，2，1，0，1，5，4，3，0

0，1，2，3，1，3，6，2，1，0

0，0，3，4，8，9，7，5，0，0

0，0，0，3，7，8，6，0，1，2

0，0，0，0，0，0，0，0，1，0

在这张二维地图中，数字代表海拔，0代表大海，求某一个点（比如6，8）所在岛屿的面积

使用广度优先遍历，从出发点开始，向周围尝试，碰到大海则尝试失败，继续尝试其他的位置。

上代码

#include "stdafx.h"   #include "iostream"  #define X 6#define Y 8using namespace std;typedef struct Node{int x;int y;};void main(){int map[11][11] = {0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,0,0,0,0,0,2,3,0,3,0,2,0,1,2,1,0,1,2,0,4,0,1,0,1,2,3,2,0,1,0,3,2,0,0,0,1,2,4,0,0,0,0,0,0,0,0,0,1,5,3,0,0,0,1,2,1,0,1,5,4,3,0,0,0,1,2,3,1,3,6,2,1,0,0,0,0,3,4,8,9,7,5,0,0,0,0,0,0,3,7,8,6,0,1,2,0,0,0,0,0,0,0,0,0,1,0 };bool visited[11][11] = { false };Node q[101];int head=1, tail = 1;int sum;int tx=0, ty=0;int next[4][2] = { 0,1,1,0,0,-1,-1,0 };//先将第一个点6，8入队q[tail].x = X;q[tail].y = Y;visited[X][Y] = true;tail++;if (map[X][Y] <= 0) { sum=0;cout << sum << endl;return; }else sum = 1;while (head < tail)  //队列{for (int i = 0;i <= 3;i++)   //从该点向周围尝试{tx = q[head].x + next[i][0];ty = q[head].y + next[i][1];if (tx < 1 || tx>10 || ty < 1 || ty>10)continue;//判断边界if (map[tx][ty] > 0 && visited[tx][ty] == false)   //符合条件{q[tail].x = tx;q[tail].y = ty;visited[tx][ty] = true;tail++;    //入队sum++;   //面积+1}}head++;   //该点遍历完毕，出队}cout << sum << endl;}

大体思路都是一样的

3.对图的广度优先遍历

图如图所示

            1

        /    |    \

      2    3    5

     |

    4

明显访问次序为1 2 3 5 4

邻接矩阵为

0 1 1 ∞ 1

1 0 ∞ 1 ∞

1 ∞ 0 ∞ 1

∞ 1 ∞ 0 ∞

1 ∞ 1 ∞ 0

#include "stdafx.h"   #include <limits>#include "iostream"  using namespace std;void main(){int map[6][6] = {0,0,0,0,0,0,0,0,1,1,INT_MAX,1,0,1,0,INT_MAX,1,INT_MAX,0,1,INT_MAX,0,INT_MAX,1,0,INT_MAX,1,INT_MAX,0,INT_MAX,0,1,INT_MAX,1,INT_MAX,0 };int visited[6] = { false };int cur;int queue[26],tail=1,head=1;queue[tail] = 1;    //将顶点1入队列cout << queue[tail];  //访问tail++;visited[1] = true;   //标记访问while (head < tail&&tail <= 5){cur = queue[head];//数组下标代表顶点for (int i = 1;i <= 5;i++){if (visited[i] == false && map[cur][i] == 1){queue[tail] = i;cout << queue[tail];   //访问tail++;visited[i] = true;}if (tail > 5)break;}head++;}}

所谓图的广度优先遍历，就是从第一个点开始，先将第一个点入队列，并访问队尾，再写一个循环，当队列不为空时，将队首作为将要搜索的目标，比如1，跟1相连的有2，3，5，通过for循环将2，3，5分别入队，并分别访问队尾，此时1就搜索完了，因为1在队首，所以出队，此时2为队首，再以2为搜索目标，for查找到2连着4，所以将4入队列，并访问队尾（也就是4），然后将2出队，再以3为搜索目标，依次类推........

4.最少转机

从1出发到5，求经过节点最少个数

显然，是从1到3到5，两次，答案是2

上代码

#include "stdafx.h"   #include <limits>#include "iostream"  using namespace std;typedef struct Node{int order;int step;};void main(){Node queue[6];int head = 1, tail = 1;int map[6][6] = {0};for (int i = 1;i <= 5;i++)for (int j = 1;j <= 5;j++)map[i][j] = INT_MAX;map[1][2] = map[2][1] = 1;map[1][3] = map[3][1] = 1;map[2][3] = map[3][2] = 1;map[2][4] = map[4][2] = 1;map[3][4] = map[4][3] = 1;map[3][5] = map[5][3] = 1;map[4][5] = map[5][4] = 1;int visited[6] = { false };queue[tail].order = 1;queue[tail].step = 0;visited[1] = true;tail++;int flag = 0;while (head < tail){int cur = queue[head].order;for (int i = 1;i <= 5;i++){if (map[cur][i] == 1 && visited[i] == false){queue[tail].order = i;queue[tail].step = queue[head].step + 1;visited[i] = true;tail++;}if (queue[tail - 1].order == 5){flag = 1;break;}}if (flag)break;head++;}cout << queue[tail - 1].step<<endl;}

具体方法，先让1进队列，然后判断跟1相连的节点2，3，分别入队列，然后1出队，此时到2，3的step都是1，再判断队首2，将4入队列，4的step是2，2出队列，再判断队首3，将5入队列，此时5的step是2，到达目的地，结束输出