HDU 1195 BFS，双向BFS两种写法

最新推荐文章于 2021-10-30 20:28:32 发布
最新推荐文章于 2021-10-30 20:28:32 发布
阅读量4.4k 收藏
点赞数
分类专栏： 搜索 文章标签： mtk each exchange struct integer input
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xieshimao/article/details/7573316
版权

Open the Lock

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1788    Accepted Submission(s): 747

Problem Description
Now an emergent task for you is to open a password lock. The password is consisted of four digits. Each digit is numbered from 1 to 9.
Each time, you can add or minus 1 to any digit. When add 1 to '9', the digit will change to be '1' and when minus 1 to '1', the digit will change to be '9'. You can also exchange the digit with its neighbor. Each action will take one step.

Now your task is to use minimal steps to open the lock.

Note: The leftmost digit is not the neighbor of the rightmost digit.
 

Input
The input file begins with an integer T, indicating the number of test cases.

Each test case begins with a four digit N, indicating the initial state of the password lock. Then followed a line with anotther four dight M, indicating the password which can open the lock. There is one blank line after each test case.
 

Output
For each test case, print the minimal steps in one line.
 

Sample Input 
  
  

   
   2
1234
2144

1111
9999
 

Sample Output 
  
  

   
   2
4
 

Author
YE, Kai
 

Source
Zhejiang University Local Contest 2005
 

Recommend
Ignatius.L
 


 

这个题，直接使用BFS爆搜是能够过得，31ms

这个题被挂在了我们学校的OJ，数据被一些邪恶的学弟们加强了。。我用了BFS然后果断TLE

题目链接：http://220.166.52.162/oj/showproblem?problem_id=2360

 

后来得知，需要使用双向BFS。很可惜，自己从未写过双向BFS。于是又跑到网上去看双向BFS的资料。总算看明白了。。（退役的半年里，第一次学习新的算法）

 

其实思路还是挺简单的，双向就是利用两个BFS拼在一起，一个从起点开始搜索，一个从终点开始搜索

当两个BFS搜索的轨迹有重合的部分的时候，立即停止两个BFS，并根据当前重合点的与两个BFS已得到的信息来计算答案。

 

贴下代码：（双向BFS也写的很挫，把队列换成数组之后才1000ms卡过去了，当然在HDU上是0ms）

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<stdlib.h>

using namespace std;

int A[5],B[5],aim;
int flag[10000];
int ak[10000];
int bk[10000];

struct node
{
	int num;
	int step;
};

void bfs()
{
	memset(flag,0,sizeof(flag));
	node k1,k2,k3,k4;
	int tmp[5],i,now[5],mt;
	node q1[10000];
	node q2[10000];
	int h1=0,t1=0,h2=0,t2=0;
	k1.num=A[1]*1000+A[2]*100+A[3]*10+A[4];
	flag[k1.num]=1;
	ak[k1.num]=0;
	k1.step=0;
	k3.num=B[1]*1000+B[2]*100+B[3]*10+B[4];
	k3.step=0;
	bk[k3.num]=0;
	flag[k3.num]=2;
	q1[t1++]=k1;
	q2[t2++]=k3;
	while(h1!=t1||h2!=t2)
	{
		int len1=t1-h1;
		while(len1--)
		{
			k2=q1[h1++];
			tmp[1]=k2.num/1000;
			tmp[2]=(k2.num%1000)/100;
			tmp[3]=(k2.num%100)/10;
			tmp[4]=k2.num%10;
			for(i=1;i<=4;i++)
			{
				now[1]=tmp[1];
				now[2]=tmp[2];
				now[3]=tmp[3];
				now[4]=tmp[4];
				now[i]=tmp[i]+1;
				if(now[i]==10)
					now[i]=1;
				mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
				if(flag[mt]==2)
				{
					printf("%d\n",k2.step+bk[mt]+1);
					return;
				}
				if(!flag[mt])
				{
					flag[mt]=1;
					k1.num=mt;
					k1.step=k2.step+1;
					ak[mt]=k1.step;
					q1[t1++]=k1;
				}
			}
			for(i=1;i<=4;i++)
			{
				now[1]=tmp[1];
				now[2]=tmp[2];
				now[3]=tmp[3];
				now[4]=tmp[4];
				now[i]=tmp[i]-1;
				if(now[i]==0)
					now[i]=9;
				mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
				if(flag[mt]==2)
				{
					printf("%d\n",k2.step+bk[mt]+1);
					return;
				}
				if(!flag[mt])
				{
					flag[mt]=1;
					k1.num=mt;
					k1.step=k2.step+1;
					ak[mt]=k1.step;
					q1[t1++]=k1;
				}
			}
			now[1]=tmp[2];
			now[2]=tmp[1];
			now[3]=tmp[3];
			now[4]=tmp[4];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==2)
			{
				printf("%d\n",k2.step+bk[mt]+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=1;
				k1.num=mt;
				k1.step=k2.step+1;
				ak[mt]=k1.step;
				q1[t1++]=k1;
			}
			now[1]=tmp[1];
			now[2]=tmp[3];
			now[3]=tmp[2];
			now[4]=tmp[4];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==2)
			{
				printf("%d\n",k2.step+bk[mt]+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=1;
				k1.num=mt;
				k1.step=k2.step+1;
				ak[mt]=k1.step;
				q1[t1++]=k1;
			}
			now[1]=tmp[1];
			now[2]=tmp[2];
			now[3]=tmp[4];
			now[4]=tmp[3];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==2)
			{
				printf("%d\n",k2.step+bk[mt]+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=1;
				k1.num=mt;
				k1.step=k2.step+1;
				ak[mt]=k1.step;
				q1[t1++]=k1;
			}
	//		printf("%d %d %d 1\n",k2.num,k2.step,ak[k2.num]);
	//		system("pause");
		}
		int len2=t2-h2;
		while(len2--)
		{
			k4=q2[h2++];
			tmp[1]=k4.num/1000;
			tmp[2]=(k4.num%1000)/100;
			tmp[3]=(k4.num%100)/10;
			tmp[4]=k4.num%10;
			for(i=1;i<=4;i++)
			{
				now[1]=tmp[1];
				now[2]=tmp[2];
				now[3]=tmp[3];
				now[4]=tmp[4];
				now[i]=tmp[i]+1;
				if(now[i]==10)
					now[i]=1;
				mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
				if(flag[mt]==1)
				{
					printf("%d\n",ak[mt]+k4.step+1);
					return;
				}
				if(!flag[mt])
				{
					flag[mt]=2;
					k3.num=mt;
					k3.step=k4.step+1;
					bk[mt]=k3.step;
					q2[t2++]=k3;
				}
			}
			for(i=1;i<=4;i++)
			{
				now[1]=tmp[1];
				now[2]=tmp[2];
				now[3]=tmp[3];
				now[4]=tmp[4];
				now[i]=tmp[i]-1;
				if(now[i]==0)
					now[i]=9;
				mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
		//		printf("%d %d\n",mt,ak[mt]);
				if(flag[mt]==1)
				{
					printf("%d\n",ak[mt]+k4.step+1);
					return;
				}
				if(!flag[mt])
				{
					flag[mt]=2;
					k3.num=mt;
					k3.step=k4.step+1;
					bk[mt]=k3.step;
					q2[t2++]=k3;
				}
			}
			now[1]=tmp[2];
			now[2]=tmp[1];
			now[3]=tmp[3];
			now[4]=tmp[4];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==1)
			{
				printf("%d\n",ak[mt]+k4.step+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=2;
				k3.num=mt;
				k3.step=k4.step+1;
				bk[mt]=k3.step;
				q2[t2++]=k3;
			}
			now[1]=tmp[1];
			now[2]=tmp[3];
			now[3]=tmp[2];
			now[4]=tmp[4];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==1)
			{
				printf("%d\n",ak[mt]+k4.step+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=2;
				k3.num=mt;
				k3.step=k4.step+1;
				bk[mt]=k3.step;
				q2[t2++]=k3;
			}
			now[1]=tmp[1];
			now[2]=tmp[2];
			now[3]=tmp[4];
			now[4]=tmp[3];
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(flag[mt]==1)
			{
				printf("%d\n",ak[mt]+k4.step+1);
				return;
			}
			if(!flag[mt])
			{
				flag[mt]=2;
				k3.num=mt;
				k3.step=k4.step+1;
				bk[mt]=k3.step;
				q2[t2++]=k3;
			}
	//		printf("%d %d %d 2\n",k4.num,k4.step,bk[k4.num]);
	//		system("pause");
		}
	}
}

int main()
{
	int t,tk,ts;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&tk);
		scanf("%d",&ts);
		if(tk==ts)
		{
			printf("0\n");
			continue;
		}
		A[1]=tk/1000;
		A[2]=(tk%1000)/100;
		A[3]=(tk%100)/10;
		A[4]=tk%10;
		B[1]=ts/1000;
		B[2]=(ts%1000)/100;
		B[3]=(ts%100)/10;
		B[4]=ts%10;
		aim=B[1]*1000+B[2]*100+B[3]*10+B[4];
		bfs();
	}
	return 0;
}



附录：

为了便于才学算法的新人，贴出本人TLE的单向BFS代码（HDU上31ms）

代码：

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>

using namespace std;

int A[5],B[5],aim;
bool flag[10000];

struct node
{
	int num;
	int step;
};

void bfs()
{
	memset(flag,0,sizeof(flag));
	node k1,k2;
	int tmp[5],i,now[5],mt;
	queue<node>q;
	k1.num=A[1]*1000+A[2]*100+A[3]*10+A[4];
	flag[k1.num]=true;
	k1.step=0;
	q.push(k1);
	while(!q.empty())
	{
		k2=q.front();
		q.pop();
		if(k2.num==aim)
		{
			printf("%d\n",k2.step);
			break;
		}
		tmp[1]=k2.num/1000;
		tmp[2]=(k2.num%1000)/100;
		tmp[3]=(k2.num%100)/10;
		tmp[4]=k2.num%10;
		for(i=1;i<=4;i++)
		{
			now[1]=tmp[1];
			now[2]=tmp[2];
			now[3]=tmp[3];
			now[4]=tmp[4];
			now[i]=tmp[i]+1;
			if(now[i]==10)
				now[i]=1;
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(!flag[mt])
			{
				flag[mt]=true;
				k1.num=mt;
				k1.step=k2.step+1;
				q.push(k1);
			}
		}
		for(i=1;i<=4;i++)
		{
			now[1]=tmp[1];
			now[2]=tmp[2];
			now[3]=tmp[3];
			now[4]=tmp[4];
			now[i]=tmp[i]-1;
			if(now[i]==0)
				now[i]=9;
			mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
			if(!flag[mt])
			{
				flag[mt]=true;
				k1.num=mt;
				k1.step=k2.step+1;
				q.push(k1);
			}
		}
		now[1]=tmp[2];
		now[2]=tmp[1];
		now[3]=tmp[3];
		now[4]=tmp[4];
		mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
		if(!flag[mt])
		{
			flag[mt]=true;
			k1.num=mt;
			k1.step=k2.step+1;
			q.push(k1);
		}
		now[1]=tmp[1];
		now[2]=tmp[3];
		now[3]=tmp[2];
		now[4]=tmp[4];
		mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
		if(!flag[mt])
		{
			flag[mt]=true;
			k1.num=mt;
			k1.step=k2.step+1;
			q.push(k1);
		}
		now[1]=tmp[1];
		now[2]=tmp[2];
		now[3]=tmp[4];
		now[4]=tmp[3];
		mt=now[1]*1000+now[2]*100+now[3]*10+now[4];
		if(!flag[mt])
		{
			flag[mt]=true;
			k1.num=mt;
			k1.step=k2.step+1;
			q.push(k1);
		}
	}
}

int main()
{
	int t,tk,ts;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&tk);
		scanf("%d",&ts);
		A[1]=tk/1000;
		A[2]=(tk%1000)/100;
		A[3]=(tk%100)/10;
		A[4]=tk%10;
		B[1]=ts/1000;
		B[2]=(ts%1000)/100;
		B[3]=(ts%100)/10;
		B[4]=ts%10;
		aim=B[1]*1000+B[2]*100+B[3]*10+B[4];
		bfs();
	}
	return 0;
}


 

 

xieshimao
关注
专栏目录
【双向BFS模板】
帅气廖鹏飞
04-13 1026
文章目录原题链接： 原题链接： https://ac.nowcoder.com/acm/contest/549/G 是个裸的双向BFS的题，看到一份比较好的代码，我以前好像都是写的两个BFS的，而他这个写在一起了，而且更好得体现了一层一层的搜索的思想 比如原来做题的时候就遇到过，因为我是 输出调试法来debug的，所以原来打印坐标的时候不知道这个点是在第几步搜出来的，其实搜完一层后，新加的就是下一...
Friend Chains bfs hdu-4460
m0_55682843的博客
04-05 228
题面链接：Problem - 4460 题面： 题意：有n个人，m条关系，每条关系给定两个人，表示这两个人是朋友，但是朋友的朋友不是朋友关系，现在求k的最小值，任意两个人的朋友链的长度都小于k(也就是求任意两个人的朋友链的最大长度)，如果有两个人之间没有朋友链就输出-1 思路：刚开始我题目看一半以为是并查集(最近并查集刷的比较多)，但是看完题目就觉得惯性思维了，然后我就开始纠结是dfs，还是最短路，然而这不是单源最短路，但是我会的dij写法铁t，我就一直往dfs上面想，但是还是t，后来我发现.
HDU1195 双向BFS(或BFS)
weixin_34194551的博客
03-14 115
　　题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1195 , 双向BFS或者直接BFS也可以过。 　　其实这道题只是单向BFS就可以过的，但是为了练算法，所以还是用了双向BFS来写。 算法： 　　先预处理一下，从1111到9999的所有点进行构图(由于是1~9的，所以除去含有0元素的数字)，能进行一次变换变成的数字则表示两点之...
双向BFS
qq_45832461的博客
04-03 614
双向BFS算法思想 理解 双向BFS适用于已经直到了起点和终点的状态下使用，从起点和终点两个方向开始进行搜索，可以极大地提高单向BFS的搜索效率。 可以设置两个队列，一个队列保存从起点开始搜索的状态，另一个队列用来保存从终点开始搜索的状态，当两个队列都非空时才能继续进行循环。循环内不断对元素较少的队列进行BFS操作(以免退化为单向BFS)，每次操作从队列弹出一个元素，与该元素相连的后续未访问元素压入队列中。如果某一个状态出现相交的情况，那么就出现了答案。 当两种颜色相遇的时候，说明两个方向的搜索树遇到一起，
HDU1195的双向bfs
swust_wbh的专栏
05-07 478
#include #include #include #include #include using namespace std; struct node { char num[4]; int step,hash; void get_hash() { hash=(num[0]-'0')*1000+(num[1]-'0')*100+(num[2]-'0')*10+(nu
【二分图匹配】最大匹配-匈牙利算法BFS && DFS写法
Kemlkyo
03-27 2570
搞了两节课终于搞懂了ORZ 这个讲解得很详细http://blog.csdn.net/pi9nc/article/details/11848327   注意：每次找增广路之前都要初始化            BFS写法要多加一个Prev数组保存这个点从哪个点来（同侧）           如果给出的两个点集各自序号都是1~n的： 对于DFS写法 因为其隐形地调用了一个栈 只要开一个Ma
KM算法（DFS版，优化DFS版，BFS版）
h_bby的博客
11-17 2720
KM算法主要用于二分图的最大权匹配问题 图解 模板 如果我们要求边权值最小的匹配可以把边权值取负值，得出结果后再取相反数即为答案。 KM算法各版本模板： dfs版KM算法模板O(n4)复杂度 图解+模板 题集 对访问过且匹配过的男生，期望值要加上女生减去的期望值；代码中的未访问过的男生实际上包含两种，一种是完全没被访问过的（slack[ j ] = INF），一种是访问过，且更新过slack值但没有参与匹配的男生，由于这种男生可匹配的部分女生期望值降低，所以该男生的slack值减少。 HDU 2255 模板
Virtual Oj搜索专题练习 DFS BFS 剪枝 回溯 题解总结 “穷竭搜索”
菠萝味的海绵宝宝的博客
08-11 4061
N 向上走一步，S向下走一步，W向左走一步，E向右走一步。
有向图最小环 floyd 和暴力bfs
u011535421的博客
02-10 802
Kessel Runlockedby masonsbroProblemSubmissionsLeaderboardDiscussionsEditorialHan Solo wants to improve the reputation of the Millenium Falcon by completing more Kessel Runs! How does he complete these...
搜索算法——双向bfs
热门推荐
Psychosocial的博客
05-12 1万+
双向bfs适用于知道起点和终点的状态下使用，从起点和终点两个方向开始进行搜索，可以非常大的提高单个bfs的搜索效率 同样，实现也是通过队列的方式，可以设置两个队列，一个队列保存从起点开始搜索的状态，另一个队列用来保存从终点开始搜索的状态，如果某一个状态下出现相交的情况，那么就出现了答案 例题1:走迷宫 问题描述： 一个迷宫由RRR行CCC列格子组成，有的格子里有障碍物，不能走；有的格子是空地...
Hdu1195开锁(双向bfs）
CY05627的博客
04-26 707
题意： 给两个4位数（都是1-9的数字），第一个是当前密码，第二个是可以开锁的密码，问经过最少多少步转换可以开锁？ 转换包括：将其中一位+1（9+1=1）,减一（1-1=9），交换相邻两位(第一位和最后一位不是相邻) 思路：双向bfs 起点和终点分别标记为1和2，只要遇到对方走过的就返回，输出最小步数。 注意是一层一层地扩展，不是A走一个B走一个，而是A走一层B走走一层。 // 找密码。双向bfs...
双向BFS模板
Free Loop~~~跳动的恒星
02-09 7489
#include #include #include #include #include using namespace std; const int dmax=1010,d[5][2]={{0,0},{1,0},{0,1},{-1,0},{0,-1}}; int a[dmax][dmax],p[dmax][dmax],ans[dmax][dmax]; struct node{ int x,y
hdu1195Open the Lock(双向bfs+循环队列)
ophunter的专栏
07-05 1200
->题目请戳这里 题目大意：给2个长度为4的数字串，求从第一个串变到第二个串最少要几步。 每一步变换情况有： 1：每个数字+1，9+1 = 1； 2：每个数字-1，1-1 = 9； 3：某个数字和与其相邻的数字交换，第一个和最后一个数字不算相邻。 题目分析：bfs~，这题单向bfs也可以过，不过想练习一下双向bfs，话说还是第一次写双向bfs。所以先找道简单的切。队列决定自己写，省时间
杭电1254java实现（双bfs 优先队列）
bigsai
04-06 2676
推箱子 推箱子是一个很经典的游戏.今天我们来玩一个简单版本.在一个M*N的房间里有一个箱子和一个搬运工,搬运工的工作就是把箱子推到指定的位置,注意,搬运工只能推箱子而不能拉箱子,因此如果箱子被推到一个角上(如图2)那么箱子就不能再被移动了,如果箱子被推到一面墙上,那么箱子只能沿着墙移动. 现在给定房间的结构,箱子的位置,搬运工的位置和箱子要被推去的位置,请你计算出搬运工至少要推动箱子多少格....
ACM-BFS之Open the Lock——hdu1195（双向BFS）
继续激情，继续奋斗。
04-29 3815
ACM BFS Open the Lock hdu1195 双向BFS
双向bfs 学习笔记
不知所云的博客
01-15 730
双向bfs 很多题目会给你起点和终点，让你求起点到终点的一条最短路径（当然这是无权图）； 这时可以用bfs，但是还不是最快的方法，当知道终点时，我们可以用双向bfs； 双向和单向的区别在于，可以从终点和起点同时出发，记录每个点是被从起点开始的访问了，还是被从终点开始的访问了，如果访问到一个点，同时被起点开始的和终点开始的访问了，那么这个点就是答案的必经点，输出起终路径之和就行； 模板题一： 八数码...
牛客16498 寻找道路（双向BFS）
sykai1的博客
10-30 302
链接：https://ac.nowcoder.com/acm/problem/16498 来源：牛客网 在有向图G中，每条边的长度均为1，现给定起点和终点，请你在图中找一条从起点到终点的路径，该路径满足以下条件： 1．路径上的所有点的出边所指向的点都直接或间接与终点连通。 2．在满足条件1的情况下使路径最短。 注意：图G中可能存在重边和自环，题目保证终点没有出边。 请你输出符合条件的路径的长度。 输入描述: 第一行有两个用一个空格隔开的整数n和m，表示图有n个点和m条边。 接下来的m行每行2个整数x、y.
使用 BFS 解决经典搜索问题
这两个题目展示了在解决实际问题时如何灵活运用BFS和DFS这两种基础搜索算法。BFS适用于寻找最短路径，而DFS则在处理有回溯需求的问题时表现出色。理解并掌握这两种算法对于提升编程解决问题的能力至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值