广度优先搜索Breadth-First-Search，对于每个节点都优先将该节点的所有下一个节点搜索一遍，再进入下一层搜索。
广度优先搜索适用于寻找最短路径问题，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。
广搜模板
BFS()
{
初始化队列；
while(队列不为空且未找到目标节点)
{
取队首节点扩展，并将扩展出的节点放入队尾；
必要时要记住每个节点的父节点；
}
}
bool BFS(Node& Vs, Node& Vd){
queue<Node> Q;
Node Vn, Vw;
int i;
//初始状态将起点放进队列Q
Q.push(Vs);
hash(Vw) = true;//设置节点已经访问过了！
while (!Q.empty()){//队列不为空，继续搜索！
//取出队列的头Vn
Vn = Q.front();
//从队列中移除
Q.pop();
while(Vw = Vn通过某规则能够到达的节点){
if (Vw == Vd){//找到终点了！
//把路径记录，这里没给出解法
return true;//返回
}
if (isValid(Vw) && !visit[Vw]){
//Vw是一个合法的节点并且为白色节点
Q.push(Vw);//加入队列Q
hash(Vw) = true;//设置节点颜色
}
}
}
return false;//无解
} 或者是
void bfs(int x, int y, int m, int n) {
queHead = queTail = 0; // 清空队列
// 将(x, y)加入队列
que[queTail++] = Node(x, y);
vis[x][y] = true;
// 开始BFS搜索
for (; queHead < queTail; ++queHead) {
// 探查队首元素周围的n个位置
for (int i = 0; i < n; ++i) {
// 根据偏移量计算位置
Node nxt(que[queHead].x + dx[i], que[queHead].y + dy[i]);
// 若该位置在地图中且为未访问过的'@'，则加入队列
if (满足条件 && !vis[nxt.x][nxt.y] ) {
que[queTail++] = nxt;
vis[nxt.x][nxt.y] = true;
}
}
}
}
/*
迷宫问题
查看 提交 统计 提问
总时间限制: 1000ms 内存限制: 65536kB
描述
定义一个二维数组：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
输入
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
输出
左上角到右下角的最短路径，格式如样例所示。
样例输入
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
样例输出
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
----------------------------广度搜索------------------------------------------------
本题第一次做的时候，关键是父节点的记录出现了问题
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
bool vis[5][5],board[5][5];
int dx[] = {-1,0,1,0};
int dy[] = {0,1,0,-1};
struct Point
{
int x,y,num;
Point* father;
Point(){};
Point(int x_,int y_,int num_):x(x_),y(y_),num(num_){};
bool right()
{
if(x >= 0 && x < 5 && y >= 0 && y < 5 && num == 0)
return true;
return false;
}
};
void outPut(Point & a)
{
if(a.x != 0 || a.y != 0)
{
outPut(*a.father);
cout << "(" << a.x << "," << a.y << ")" << endl;
}
else
cout << "(" << a.x << "," << a.y << ")" << endl;
}
void BFS(Point & a)
{
queue<Point> Q;
Q.push(a);
Point Pn;
vis[a.x][a.y] = true;
while(!Q.empty())
{
Pn = Q.front();
Q.pop();
for(int i = 0; i < 4; ++i)
{
Point Pw(Pn.x+dx[i],Pn.y+dy[i],board[Pn.x+dx[i]][Pn.y+dy[i]]);
Pw.father = &Pn;
if(Pw.right() && !vis[Pw.x][Pw.y])
{
if(Pw.x == 4 && Pw.y == 4)
{
outPut(Pw);
return;
}
Q.push(Pw);
vis[Pw.x][Pw.y] = true;
}
}
}
}
int main()
{
for(int i = 0; i < 5; ++i)
for(int j = 0; j < 5; ++j)
cin >> board[i][j];
memset(vis,0,sizeof(vis));
BFS(Point(0,0,0));
//system("pause");
return 0;
}
——————————————————————————————————————————————————————————————
另外一个就是点的输出问题，采用回溯输出
*/
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
bool vis[5][5],board[5][5];
int dx[] = {-1,0,1,0};
int dy[] = {0,1,0,-1};
int queHead,queTail;
struct Point
{
int x,y,num;
int father;
Point(){};
Point(int x_,int y_):x(x_),y(y_){};
bool right()
{
if(x >= 0 && x < 5 && y >= 0 && y < 5 && num == 0)
return true;
return false;
}
}Que[30];
void outPut(Point a)
{
if(a.x == 0 && a.y == 0)
{
cout << "(0, 0)" << endl;
return;
}
outPut(Que[a.father]);
cout << "(" << a.x << ", " << a.y << ")" << endl;
}
void BFS(int x,int y,int num)
{
queHead = queTail = 0;
Point a(x,y);
a.num = num;
Que[queTail++] = a;
vis[a.x][a.y] = true;
for(;queHead < queTail; ++queHead)
{
for(int i = 0; i < 4; ++i)
{
Point Pw(Que[queHead].x +dx[i],Que[queHead].y + dy[i]);
Pw.num = board[Pw.x][Pw.y];
Pw.father = queHead;
if(Pw.right() && !vis[Pw.x][Pw.y])
{
if(Pw.x == 4 && Pw.y == 4)
{
outPut(Pw);
return;
}
Que[queTail++] = Pw;
vis[Pw.x][Pw.y] = true;
}
}
}
}
int main()
{
for(int i = 0; i < 5; ++i)
for(int j = 0; j < 5; ++j)
cin >> board[i][j];
memset(vis,0,sizeof(vis));
BFS(0,0,0);
system("pause");
return 0;
}
