广度优先遍历的几个例题

题目来自《啊哈！算法》

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          tail
	bool 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，1
				visited[tx][ty] = true;       //那么下一次是1，2和2，1入队列，这两个的step都是1，1的step+1
				tail++;                       //所以，这个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 8
using 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，到达目的地，结束输出