- 双向bfs适用于知道起点和终点的状态下使用，从起点和终点两个方向开始进行搜索，可以非常大的提高单个bfs的搜索效率
- 同样，实现也是通过队列的方式，可以设置两个队列，一个队列保存从起点开始搜索的状态，另一个队列用来保存从终点开始搜索的状态，如果某一个状态下出现相交的情况，那么就出现了答案
用一张图来进行说明
当两种颜色相遇的时候，说明两个方向的搜索树遇到一起，这个时候就搜到了答案。
例题1:走迷宫
问题描述：
一个迷宫由
R
R
R行
C
C
C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。
给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。
输入
第一行是两个整数，
Ｒ
Ｒ
Ｒ和
Ｃ
Ｃ
Ｃ，代表迷宫的长和宽。
（
1
≤
R
，
C
≤
40
)
（ 1≤ R，C ≤ 40)
（1≤R，C≤40)
接下来是
Ｒ
Ｒ
Ｒ行，每行
Ｃ
Ｃ
Ｃ个字符，代表整个迷宫。
空地格子用‘.’表示，有障碍物的格子用‘#’表示。
迷宫左上角和右下角都是‘.’。
输出
输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。
样例输入
5 5
..###
#....
#.#.#
#.#.#
#.#..
样例输出
9
策略分析：
其实这道题是标准的bfs求最短路径，十分容易写出来，但是还是说一下双向bfs的思路，使用双向bfs一定要记录好两个队列的搜索状态，换句话说就是要知道当前这个点是由哪一个搜索树扩展过来的，首先一个起点一个终点，设置两个队列，同时开始搜索，如果搜索树相遇，就找到了解（由于这个题数据范围很小，所以bfs和双向bfs效率差不多）标准单向bfs
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 100000;
const int MAX = 101;
typedef pair<int, int> P;
char map[MAX][MAX];
int d[MAX][MAX];//表示起点到各个位置的最短距离
int sx, sy, gx, gy;//表示起点和终点坐标
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0,- 1};
bool Check(int x, int y) {
if(x>=0 && x<n && y>=0 && y<m && d[x][y]==INF && map[x][y]!='#')
return true;
else return false;
}
int bfs() {
queue<P> que;
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
d[i][j] = INF;
que.push(P(sx, sy));
d[sx][sy] = 0;
while(!que.empty()) {
P p = que.front();
que.pop();
if(p.first == gx && p.second == gy)
break;
for(int i = 0; i < 4; i++) {
int nx = p.first + dx[i];
int ny = p.second + dy[i];
if(Check(nx, ny)) {
que.push(P(nx,ny));
d[nx][ny] = d[p.first][p.second] + 1;
}
}
}
return d[gx][gy];
}
int main() {
cin >> n >> m;
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++)
cin >> map[i][j];
sx = 0, sy = 0;
gx = n-1, gy = m-1;
int res = bfs();
cout << res+1 << endl;
return 0;
}
双向bfs写法
#include <iostream>
#include <queue>
#define P pair<int, int>
using namespace std;
//记录下当前状态, 从前往后搜索值为1，从后往前搜索值为2，如果某状态下，当前节点和准备扩展节点的状态相加为3，说明相遇
queue <P> q1, q2;
int r, c, ans, dis[45][45], vst[45][45];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
char m[45][45];
void dbfs() {
bool flag;
q1.push(P(1, 1)), dis[1][1] = 1, vst[1][1] = 1; //从前搜
q2.push(P(r, c)), dis[r][c] = 1, vst[r][c] = 2; //从后搜
while(!q1.empty() && !q2.empty()) {
int x0, y0;
if(q1.size() > q2.size()) { //每次扩展搜索树小的队列 flag=1扩展前搜的队列，flag=0扩展后搜的队列
x0 = q2.front().first, y0 = q2.front().second;
q2.pop();
flag = 0;
}else {
x0 = q1.front().first, y0 = q1.front().second;
q1.pop();
flag = 1;
}
for(int i = 0; i < 4; i++) {
int nx = x0 + dx[i];
int ny = y0 + dy[i];
if(nx >= 1 && nx <= r && ny >= 1 && ny <= c && m[nx][ny] == '.') {
if(!dis[nx][ny]) {
dis[nx][ny] = dis[x0][y0] + 1;
vst[nx][ny] = vst[x0][y0];
if(flag) q1.push(P(nx, ny));
else q2.push(P(nx, ny));
}else {
if(vst[x0][y0] + vst[nx][ny]== 3) { //相遇
ans = dis[nx][ny] + dis[x0][y0];
return;
}
}
}
}
}
}
int main() {
cin >> r >> c;
for(int i = 1; i <= r; i++)
for(int j = 1; j <= c; j++)
cin >> m[i][j];
dbfs();
cout << ans << "\n";
return 0;
}
例题2:8数码
问题描述：
在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：
给出一种初始布局（初始状态）和目标布局（设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。
输入
输入初始状态，一行九个数字，空格用0表示
输出
只有一行，该行只有一个数字，表示从初始状态到目标状态需要的最少移动次数(一定能到达目标状态)
样例输入
283104765
样例输出
4
解释下样例
283 203 023 123 123
104 -> 184 -> 184 -> 084 -> 804
765 765 765 765 765
因此移动4次到达目标状态
策略分析：
经典bfs题目，直接搜会很麻烦，中间会出现大量重复的状态，会浪费很多时间，因此为了去除重复状态，优化搜索效率，可以把这个三行转换成一个9位的整数。然后会发现这样转换后，每一种状态对应唯一的一个整数，因此队列中只需要保存整数（状态）即可，对于每一个整数都考虑是由哪一个整数转换得到的，同时相应步数加1，map会实现相同状态下的自动去重，十分方便，效率就会大大提升，但是在搜索的时候，还是需要转换回矩阵去判断0该往哪走。提供单向bfs和双向bfs的思路
(单向bfs时间：31个测试点7962ms)
(双向bfs时间：31个测试点298ms)快了20多倍
单向bfs
#include <iostream>
#include <map>
#include <queue>
using namespace std;
const int END = 123804765;
map<int, int> dis; //去重同时记录状态
int mat[3][3], n;
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};
//用map去重
//对于每一个可能到达的状态用map记录，判断下一步方位的时候用矩阵判断，状态被转换成一个唯一数字表示
void bfs(int s) {
queue<int> q;
q.push(s);
dis[s] = 0;
while(!q.empty()) {
int t = q.front(), zx, zy;
q.pop();
int div = 100000000;
if(t == END) return; //出现最终态可以结束搜索
for(int i = 0; i < 3; i++) //当前t这种状态转换成mat矩阵
for(int j = 0; j < 3; j++) {
mat[i][j] = (t / div) % 10;
div /= 10;
if(!mat[i][j]) zx = i, zy = j;
}
for(int i = 0; i < 4; i++) { //矩阵状态下扩展四个方向
int nx = zx + dx[i];
int ny = zy + dy[i];
if(nx >= 0 && nx < 3 && ny >= 0 && ny < 3) {
swap(mat[zx][zy], mat[nx][ny]);
int num = 0;
for(int j = 0; j < 3; j++) //扩展后的矩阵，转换成数字，用来表示状态
for(int j1 = 0; j1 < 3; j1++)
num = num*10 + mat[j][j1];
if(!dis.count(num)) { //如果当前这个状态没有出现过，那么可以由状态t一步转移过来
dis[num] = dis[t] + 1;
q.push(num);
}
swap(mat[zx][zy], mat[nx][ny]); //这一步很重要，扩展一次后一定要恢复，方便下一下扩展
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
bfs(n);
cout << dis[END] << "\n";
return 0;
}
双向bfs
#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
using namespace std;
const int end = 123804765;
map <int, int> state; //状态为1表示q1扩展的，状态为2表示q2扩展的 如果出现两个状态相加为3说明找到路径
map <int, int> ans;
queue <int> q1, q2; //q1从前搜，q2从后搜
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
int cnt, mat[3][3], zx, zy;
inline int toInt() { //将数字转为矩阵
int now = 0;
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
now = now * 10 + mat[i][j];
return now;
}
inline void toMatrix(int s) { //将矩阵转为数字
int div = 100000000;
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++) {
mat[i][j] = (s / div) % 10;
if(!mat[i][j]) zx = i, zy = j;
div /= 10;
}
}
void dbfs(int s) {
if(s == end) return;
bool flag;
state[s] = 1, state[end] = 2;
ans[s] = 0, ans[end] = 1;
q1.push(s), q2.push(end);
while(!q1.empty() && !q2.empty()) {
flag = 0;
int t;
if(q1.size() > q2.size()) {
t = q2.front(), q2.pop();
}else {
t = q1.front(), q1.pop();
flag = 1;
}
toMatrix(t);
for(int i = 0; i < 4; i++) {
int num;
int nx = dx[i] + zx;
int ny = dy[i] + zy;
if(nx >= 0 && nx < 3 && ny >= 0 && ny < 3) {
swap(mat[zx][zy], mat[nx][ny]);
num = toInt();
if(!ans.count(num)) { //当前状态未被扩展过
ans[num] = ans[t] + 1;
state[num] = state[t]; //更新状态
if(flag) q1.push(num);
else q2.push(num);
}else if(state[t] + state[num] == 3){ //搜索范围重叠，出现答案
cnt = ans[t] + ans[num];
return;
}
swap(mat[zx][zy], mat[nx][ny]);
}
}
}
}
int main() {
int n;
cin >> n;
dbfs(n);
cout << cnt << "\n";
return 0;
}
双向bfs关键就是要记录两棵搜索树的状态，通过状态判断是否出现相遇
扫一扫
970
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
