双端队列BFS(BFS+迪杰特斯拉） 双向广搜

双端队列BFS

电路维修

题意：如图所示的图像为一块电路板

每个格子中 的电路 有 ‘’ 和 ‘/’ 两种情况
要求从左上电极连接到右下电极
可对 所有格子里的电路进行操作，求最少进行多少次操作，可以使电路联通

图示答案为1
操作为

解法：

想象该模型为 从左上角到右下角的最短路模型，若对角线电路联通，则这两点的距离为0，否则，需要操作一次电路使其改变，视作两点距离为1
考虑使用迪杰斯特拉算法解决该最短路问题
那么在迪杰斯特拉 最短路的松弛过程中，如何确保每次都能拿出 图中与左上点距离最短的点 进行松弛操作呢？
于是考虑到与BFS进行结合
从该图的左上角开始进行BFS遍历
与一般BFS不同的是，不能单纯的只是往队尾增加元素
构建双端队列，同时该队列也是迪杰特斯拉所有点到左上角 距离的一个堆排序
那么排在队首的元素一定是，目前与左上角位置距离最短的点，即下一轮用来进行松弛操作的点
在BFS中：
如果这次移动，不需要操作电路，即距离为0，那么该点也一定是距离左上距离最短的点，将其放在队首
否则，将其放在队尾
于是，如此进行双端队列的BFS操作，我们便完美的维护了迪杰特斯拉的堆
问题也转换成了最短路问题

标程

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#include<stack>
#include<set>
#include<cstring>
#include<string>
#define inf 0x3f3f3f3f
#define gcd __gcd
#define lrb666 ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
char mp[505][505];
int n,m,nex[4][2]={{1,1},{1,-1},{-1,-1},{-1,1}};
int side[505][505],nex_mp[4][2]={{-1,-1},{-1,0},{0,0},{0,-1}};
int vis[505][505];
struct node
{
	int x,y;
}p,k;
int bfs()
{
	deque<node>q;
	memset(side,0x3f,sizeof(side));
	memset(vis,0,sizeof(vis));
	side[1][1]=0;
	vis[1][1]=1;
	p.x=1;p.y=1;
	q.push_front(p);
	while(!q.empty())
	{
		k=q.front();
		q.pop_front();
		vis[k.x][k.y]=1;
		if(k.x==n+1 && k.y==m+1)
		{
			return side[k.x][k.y];
		}
		for(int i=0;i<4;i++)
		{
			p.x=k.x+nex[i][0];p.y=k.y+nex[i][1];
			if(p.x<1 || p.x>n+1 || p.y<1 || p.y>m+1 || vis[p.x][p.y])
			continue;	
			int mpx=p.x+nex_mp[i][0],mpy=p.y+nex_mp[i][1];
			int d;
			if(i==0 || i==2)
			{
				if(mp[mpx][mpy]=='\\')
				d=0;
				else
				d=1;
			}
			else
			{
				if(mp[mpx][mpy]=='/')
				d=0;
				else
				d=1;
			}
			side[p.x][p.y]=min(side[p.x][p.y],side[k.x][k.y]+d);
			if(!d)
			q.push_front(p);
			else
			q.push_back(p);
		}
	}
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{	
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
		{
			scanf("%s",mp[i]+1); 
		}
		if((n+m)%2==1)
		{
			printf("NO SOLUTION\n");
		}
		else
		{
			int ans=bfs();
			printf("%d\n",ans);
		}
	}
}

双向广搜

题目：字串变换

双向广搜即使用两个队列，分别从起点和终点开始进行广度优先搜索，适用于最大步数确定的题目，类似两端同时施工在中间汇合
使用双向广搜的目的是防止广度优先搜索的过程中队列存储过多引起爆栈，由于队列中元素的增加属于指数上升
所以可能存储过多爆栈
但是如果两端同时开始搜索，则可以极大程度的减少内存的产生

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#include<stack>
#include<set>
#include<cstring>
#include<string>
#include<unordered_map> 
#define inf 0x3f3f3f3f
#define gcd __gcd
#define lrb666 ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
string A,B,a[10],b[10];
int n=0;
int extend(queue<string>&q,unordered_map<string,int>&v1,unordered_map<string,int>&v2,string a[],string b[])
{
	string k=q.front();
	q.pop();
	for(int i=0;i<k.size();i++)
	{
		for(int j=0;j<n;j++)
		{
			if(k.substr(i,a[j].size())==a[j])
			{
				string t=k.substr(0,i)+b[j]+k.substr(i+a[j].size());
				if(v2.count(t))
				return v1[k]+1+v2[t];
				if(v1.count(t))
				continue;
				v1[t]=v1[k]+1;
				q.push(t);
			}
		} 
	}
	return 11;
}
int bfs()
{
	if(A==B)
	return 0;
	queue<string>qa,qb;
	int t;
	unordered_map<string,int>visa,visb;
	qa.push(A);qb.push(B);
	visa[A]=0;visb[B]=0;
	while(!qa.empty() && !qb.empty())
	{
		if(qa.size()>qb.size())
		{
			t=extend(qb,visb,visa,b,a);
		}
		else
		{
			t=extend(qa,visa,visb,a,b);
		}
		if(t<=10)
		return t;
	}
	return 11;
}
int main()
{
	cin>>A>>B;
	while(cin>>a[n]>>b[n])
	n++;
	int step=bfs();
	if(step>10)
	printf("NO ANSWER!\n");
	else
	printf("%d\n",step);
}