POJ3984 [ 迷宫问题 ] -- 图的BFS(基础)

广度优先搜索 (Breadth-First-Search)，即BFS

用途之一：
  寻找非加权图（不考虑边的成本）中的任意两点间的最短路径
附：也看到说可以用在爬虫上

BFS基本可以分为下面几个模块：

1. 存图（一般存在邻接矩阵/邻接表中），初始化状态数组（记录是否访问，或者访问层数）
2. 确定起点与终点，开始搜索并记忆
3. 输出步数或者路径

tips:

• 一般来说，用邻接矩阵存图（即二维数组），但情况较为复杂或数据量较大的时候，通常采用新建类/结构体的形式
• bfs部分的实现通常使用queue，它可以保证优先搜索当前层数的所有结点
• 对于有输出路径需求的情况，在bfs时会记录下当前结点的父节点，以便于在输出时可以回溯路径；同时，保存路径可以使用vector以防止栈溢出的情况
• 之所以可以从终点经过唯一路径（最短路）回溯到起点，是因为每个结点（除起点外）都有且只有唯一父节点

 

尝试用伪代码的方式详述一些核心部分的实现：

• 搜索部分：（伪代码）

void bfs()
{
    vis[“起点”] = 初始状态； //通常为true 或者 0
    queue<Type> q;
    q.push_back(“起点”);
    while(!q.empty()){
		Type u = q.front(); q.pop(); //取出当前结点
		for(i:1->m){ //m个方向
			Tpye v = u在i方向上的子节点;
			if(超出边界 || 不符合条件 || 已经访问) continue;
			vis[v] = 标记状态;
			//记录v父节点为u
			if(v == 终点){
				print(); //自定义输出函数
				return ; 
			}
			//其他操作
			q.push_back(v); //存入子节点
		}
	}
	return ;
}

• 路径输出部分（依旧是伪代码）

pair<int, int>  father_node[maxn][...];
void print(Type u) //传入终点
{
	queue<Tpye> path;
	while(1){
		path.push_back(u);
		if(u == 起点) break;
		u = father_node[u]; //从记录父节点的数据结构中，更新当前结点
	}
	for(int i=father_node.size()-1; i>=0; --i){
		//按要求输出路径
	}
	return ;
}

 
 
题目实例（POJ3984 - 迷宫问题）

首先是题目大意：

1. 对于给定5✖5的矩阵（从0开始）中，找出起点（左上角）到终点（右上角）的最短通路并打印
2. 图中 “1” 表示墙壁，**“0”**表示通路

 
 
Sample Input:

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

Sample Output：

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

 
 
 
代码实现

  ps:对于图来说，通常会设置一些移动数组（eg.代码中的dx[ ], dy[ ]），这样可以循环遍历当前结点的所有方向；另外，记录父节点可以用pair的二维数组记录，比较方便；至于代码中的ios::sync_with_stdio(false);只是用于加快读入读取速度，对题目本身并不影响。

#include<cstdio>
#include<iostream>
#include<iomanip>
#include<queue>
#include<cmath>
#include<algorithm>
#include<functional>
#define FOR(i,j,k) for(int i=j; i<k; ++i)
#define FREIN() freopen("in.txt","r",stdin)
#define FREON() freopen("out.txt","w",stdout)
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
const int maxn =  10;
int mp[maxn][maxn]; //邻接矩阵
int vis[maxn][maxn]; //记录是否访问

const int dx[] = {-1, 0, 1, 0};
const int dy[] = { 0, 1, 0,-1}; //逆时针

pair<int, int> fa[maxn][maxn]; //记录父节点

void print_path()
{
    pair<int, int> u(5, 5); //终点
    vector<pair<int, int> > q; //保存路径
    while( 1 ){ //从终点回溯
        q.push_back(u);
        if(u.first == 1 && u.second == 1) break; //到达起点
        u = fa[u.first][u.second];
    }
    for(int i=q.size()-1; i>=0; --i){
        cout << "(" << q[i].first-1 << ", " << q[i].second-1 << ")" << endl;
    }
}

//是否在界内
bool index(int x, int y){
    return x>0 && y>0 &&  x<6 && y<6;
}

void bfs()
{
    pair<int, int> now; //记录当前位置
    vis[1][1] = 1;
    queue< pair<int, int> > q;
    q.push(make_pair(1,1)); //存入起点
    while(!q.empty()){
        now = q.front(); q.pop();
        for(int i=0; i<4; ++i){ //遍历当前点的四个移动方向
            int nx = now.first + dx[i];
            int ny = now.second + dy[i];
            if( !index(nx, ny) || vis[nx][ny] != 0 || mp[nx][ny] == 1 ) continue; //越界/已访问
            vis[nx][ny] = 1; //标记访问状态
            fa[nx][ny] = now; //存下父节点
            if(nx == 5 && ny == 5){ //到达终点
                print_path(); //输出
                return ;
            }
            q.push(make_pair(nx, ny));
        }
    }
    return ;
}

int main()
{
    ios::sync_with_stdio(false);
    FOR(i, 1, 6) FOR(j, 1,  6) cin >> mp[i][j], vis[i][j] = 0;
    bfs();
    return 0;
}