搜索算法——双向bfs

双向bfs适用于知道起点和终点的状态下使用，从起点和终点两个方向开始进行搜索，可以非常大的提高单个bfs的搜索效率
同样，实现也是通过队列的方式，可以设置两个队列，一个队列保存从起点开始搜索的状态，另一个队列用来保存从终点开始搜索的状态，如果某一个状态下出现相交的情况，那么就出现了答案
用一张图来进行说明

当两种颜色相遇的时候，说明两个方向的搜索树遇到一起，这个时候就搜到了答案。

例题1:走迷宫

问题描述：
一个迷宫由RRR行CCC列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。
给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。

输入

第一行是两个整数，ＲＲＲ和ＣＣＣ，代表迷宫的长和宽。（1≤R，C≤40)（ 1≤ R，C ≤ 40)（1≤R，C≤40)
接下来是ＲＲＲ行，每行ＣＣＣ个字符，代表整个迷宫。
空地格子用‘.’表示，有障碍物的格子用‘#’表示。
迷宫左上角和右下角都是‘.’。

输出

输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。

样例输入

5 5
..###
#....
#.#.#
#.#.#
#.#..

样例输出

策略分析：

其实这道题是标准的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

样例输出

解释下样例

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关键就是要记录两棵搜索树的状态，通过状态判断是否出现相遇