双向广搜
1 双向广搜
顾名思义就是从起点与终点同时bfs，直到会师就停止
可以将指数级别的时间复杂度降低为线性指数级别
字串变换
题目
https://www.acwing.com/problem/content/description/192/ 
#include<bits/stdc++.h>
using namespace std;
const int N=6;
string a[N],b[N];
int n;
int extend(queue<string> &q,unordered_map<string,int> &da,unordered_map<string,int> &db,string a[],string b[])
{
string t=q.front();
q.pop();
for(int i=0;i<t.size();i++)
{
for(int j=0;j<n;j++)
{
if(t.substr(i,a[j].size())==a[j])
{
string state=t.substr(0,i)+b[j]+t.substr(i+a[j].size());
if(db.count(state))return da[t]+db[state]+1;
if(da.count(state))continue;
da[state]=da[t]+1;
q.push(state);
}
}
}
return 11;
}
int bfs(string A,string B)
{
if(A==B)return 0;
queue<string> qa,qb;
unordered_map<string,int> da,db;
qa.push(A),da[A]=0;
qb.push(B),db[B]=0;
while(qa.size()&&qb.size())
{
int t;
if(qa.size()<=qb.size()) t=extend(qa,da,db,a,b);
else t=extend(qb,db,da,b,a);
if(t<=10)return t;
}
return 11;
}
int main()
{
string A,B;
cin>>A>>B;
while(cin>>a[n]>>b[n])n++;
int step = bfs(A,B);
if(step>10)cout<<"NO ANSWER!";
else cout<<step;
}注释版本（新人看）
#include<bits/stdc++.h>
using namespace std;
const int N = 6;
int n;
string a[N],b[N];
// 扩展函数
// 参数：扩展的队列，到起点的距离，到终点的距离，规则，规则
//返回值：满足条件的最小步数
int extend(queue<string>& q, unordered_map<string,int>& da, unordered_map<string, int>& db,
string a[], string b[]){
// 取出队头元素
string t = q.front();
q.pop();
for(int i = 0; i < t.size(); i ++) // t从哪里开始扩展
for(int j = 0; j < n; j ++) // 枚举规则
//如果t这个字符串的一段= 规则，比如= xyz，才可以替换
if(t.substr(i, a[j].size()) == a[j]){
// 变换之后的结果state:前面不变的部分+ 变化的部分 + 后面不变的部分
// 比如abcd ，根据规则abc--> xu，变成 xud，这里的state就是xud
string state = t.substr(0,i) +b[j] + t.substr(i + a[j].size());
// state状态是否落到b里面去，两个方向会师，返回最小步数
if(db.count(state)) return da[t] + 1 + db[state];
// 如果该状态之前已扩展过，
if(da.count(state)) continue;
da[state] = da[t] + 1;
q.push(state);
}
return 11;
}
// 从起点和终点来做bfs
int bfs(string A, string B){
if(A==B)return 0;
queue<string> qa, qb; // 两个方向的队列
//每个状态到起点的距离da（哈希表），每个状态到终点的距离db哈希表
unordered_map<string, int> da, db;
// qa从起点开始搜，qb从终点开始搜
qa.push(A), da[A] = 0; // 起点A到起点的距离为0
qb.push(B), db[B] = 0; // 终点B到终点B的距离为0
// qa和qb都有值，说明可以扩展过来，否则说明是不相交的
while(qa.size() && qb.size()){
int t; // 记录最小步数
// 哪个方向的队列的长度更小一些，空间更小一些，从该方向开始扩展，
// 时间复杂度比较平滑,否则有1个点会超时
if(qa.size() <= qb.size())
t = extend(qa, da, db, a, b);
else t = extend(qb, db, da, b, a);
// 如果最小步数在10步以内
if( t <= 10) return t;
}
return 11; // 如果不连通或者最小步数>10，则返回大于10的数
}
int main(){
string A, B;
cin >> A >> B;
// 读入扩展规则，分别存在a数组和b数组
while( cin >> a[n] >> b[n]) n ++;
int step = bfs(A,B);
if(step > 10) puts("NO ANSWER!");
else cout << step << endl;
}
A*
A star算法基本很少用，但是也是bfs的一种优化
1.八数码
题目https://www.acwing.com/problem/content/description/181/
#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int,string> pis;
int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
int f(string a)//用来求估计函数，也就是这个点到终点的距离
{
int dist=0;
for(int i=0;i<a.size();i++)//用两点距离来求
if(a[i]!='x')
{
int t=a[i]-'1';
dist+=abs(i/3-t/3)+abs(i%3-t%3);
}
return dist;
}
string bfs(string start)
{
string end="12345678x";
char op[]="urdl";//上左下右是个方向
unordered_map<string,int> d;//用来求距离
unordered_map<string,pair<char,string>> pre;//用来记录轨迹
priority_queue<pis,vector<pis>,greater<pis>> heap;//用来存距离和点
d[start]=0;
heap.push({f(start),start});
while(heap.size())
{
auto t=heap.top();
heap.pop();
string state=t.y;
if(state==end) break;//假如已经找到了，则直接跳出来
int x,y;
for(int i=0;i<9;i++)//找一下x的位置
if(state[i]=='x')
{
x=i/3,y=i%3;
break;
}
string source=state;
for(int i=0;i<4;i++)//进行四个方向的转移
{
int a=x+dx[i],b=y+dy[i];
if(a<0||a>=3||b<0||b>=3) continue;//越界continue
state=source;
swap(state[x*3+y],state[a*3+b]);//交换一下位置，也即新的状态
if(d.count(state)==0||d[state]>d[source]+1)//假如该状态还没更新过，或者有距离更短
{
d[state]=d[source]+1;//则更新一下最短距离
pre[state]={op[i],source};//记录由谁转化过来的和转换方式
heap.push({f(state)+d[state],state});
}
}
}
string ans;
while(end!=start)//倒着记录轨迹
{
ans+=pre[end].x;
end=pre[end].y;
}
reverse(ans.begin(),ans.end());//倒转一下即可
return ans;//返回轨迹
}
int main()
{
string start;
char c;
while(cin>>c) start+=c;
int cnt=0;
for(int i=0;i<9;i++)//求逆序对的个数
{
if(start[i]=='x') continue;
for(int j=i;j<9;j++)
if(start[i]>start[j]) cnt++;
}
if(cnt&1) puts("unsolvable");//假如逆序对为奇数，则没答案
else cout<<bfs(start)<<endl;//反之bfs一遍
return 0;
}2.第K短路
题目 https://www.acwing.com/problem/content/180/
#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int,int> pii;
typedef pair<int,pii> piii;
const int N=1010,M=2e5+10;
int n,m,S,T,K;
int h[N],rh[N],e[M],w[M],ne[M],idx;
int dist[N];
bool st[N];
int cnt[N];
void add(int h[],int a,int b,int c)
{
e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void dijkstra()//用dijkstra来求估价函数f[i]
{
priority_queue<pii,vector<pii>,greater<pii>> heap;
heap.push({0,T});
memset(dist,0x3f,sizeof dist);
dist[T]=0;
while(heap.size())
{
auto t=heap.top();
heap.pop();
int ver=t.y;
if(st[ver]) continue;
st[ver]=true;
for(int i=rh[ver];~i;i=ne[i])
{
int j=e[i];
if(dist[j]>dist[ver]+w[i])
{
dist[j]=dist[ver]+w[i];
heap.push({dist[j],j});
}
}
}
}
int astar()
{
priority_queue<piii,vector<piii>,greater<piii>>heap;
heap.push({dist[S],{0,S}});
//谁的d[u]+f[u]更小 谁先出队列
while(heap.size())
{
auto t=heap.top();
heap.pop();
int ver=t.y.y,distance=t.y.x;
cnt[ver]++;
if(cnt[T]==K) return distance; //如果终点已经被访问过k次了 则此时的ver就是终点T 返回答案
for(int i=h[ver];~i;i=ne[i])
{
int j=e[i];
/*
如果走到一个中间点都cnt[j]>=K，则说明j已经出队k次了，且astar()并没有return distance,
说明从j出发找不到第k短路(让终点出队k次)，
即继续让j入队的话依然无解，
那么就没必要让j继续入队了
*/
if(cnt[j]<K)
{
// 按 真实值+估计值 = d[j]+f[j]
heap.push({distance+w[i]+dist[j],{distance+w[i],j}});
}
}
}
// 终点没有被访问k次
return -1;
}
int main()
{
memset(h,-1,sizeof h);
memset(rh,-1,sizeof rh);
cin>>n>>m;
while(m--)
{
int a,b,c;
cin>>a>>b>>c;
add(h,a,b,c);
add(rh,b,a,c);//用来反向求距离
}
cin>>S>>T>>K;
if(S==T) K++;
dijkstra();
cout<<astar()<<endl;
return 0;
}