BFS广度优先搜索(7)--poj3126(基础题)

最新推荐文章于 2021-08-27 14:33:19 发布

Sly_461

最新推荐文章于 2021-08-27 14:33:19 发布

阅读量1.4k

点赞数 2

分类专栏：【BFS(广度优先搜索)】文章标签： poj3126 广度优先搜索 BFS

本文链接：https://blog.csdn.net/Acmer_Sly/article/details/52545674

版权

【BFS(广度优先搜索)】专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Prime Path

Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu

Description

The ministers of the cabinet were quite upset by the message from the Chief of Security stating that they would all have to change the four-digit room numbers on their offices.
— It is a matter of security to change such things every now and then, to keep the enemy in the dark.
— But look, I have chosen my number 1033 for good reasons. I am the Prime minister, you know!
— I know, so therefore your new number 8179 is also a prime. You will just have to paste four new digits over the four old ones on your office door.
— No, it’s not that simple. Suppose that I change the first digit to an 8, then the number will read 8033 which is not a prime!
— I see, being the prime minister you cannot stand having a non-prime number on your door even for a few seconds.
— Correct! So I must invent a scheme for going from 1033 to 8179 by a path of prime numbers where only one digit is changed from one prime to the next prime.

Now, the minister of finance, who had been eavesdropping, intervened.
— No unnecessary expenditure, please! I happen to know that the price of a digit is one pound.
— Hmm, in that case I need a computer program to minimize the cost. You don't know some very cheap software gurus, do you?
— In fact, I do. You see, there is this programming contest going on... Help the prime minister to find the cheapest prime path between any two given four-digit primes! The first digit must be nonzero, of course. Here is a solution in the case above.

1033
1733
3733
3739
3779
8779
8179

The cost of this solution is 6 pounds. Note that the digit 1 which got pasted over in step 2 can not be reused in the last step – a new 1 must be purchased.

Input

One line with a positive number: the number of test cases (at most 100). Then for each test case, one line with two numbers separated by a blank. Both numbers are four-digit primes (without leading zeros).

Output

One line for each case, either with a number stating the minimal cost or containing the word Impossible.

Sample Input

Sample Output

6
7
0

题目大意就是给你两个四位数数a和b然后a每次可以改变a的个位十位百位或者千位上的一个数字，求出最终得到

数字b所需要的最短次数，当然每次改变数字得到的数字需要是一个质数，如果你无论如何都不能在要求每次变换都为

质数的约束情况下把a转化为b那么输出Impossible否则求出最短的次。

核心思想依然是：给定初始状态跟目标状态，要求从初始状态到目标状态的最短路。

所以这道题的简单思路就是分别搜索每一次改变的位数之后得到的新数字是不是质数且能不能等于这个目标b的

值，如果得到的是质数则次数+1，直到最终得到想要的结果为止，统计累加的次数，然后就是分析怎么优化了，首先

它说的是素数，所以应该先用一个BOOL函数来筛选出满足条件的素数，在筛选过程中记得将判定素数的那个循环的复

杂度变成根号N以免增加电脑的计算量，筛选素数之后再用BFS进行搜索统计就可以了，依然是利用队列来做，当然对

于细节的处理上就是要注意每一位的取值情况，个位必然是奇数，千位得从1开始，十位百位嘛改变时没有特殊要求。

上代码：

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
int vis[10][10][10][10];    //标记
int A,B,C,D;
struct node{
	int a,b,c,d;       //分别代表个十百千位上的数
	int step;           //改变次数
};
bool Judge(node e){          //判断质数
	int num=e.a*1000+e.b*100+e.c*10+e.d;
	int i;
	for(i=2;i*i<=num;i++){
		if(num%i==0)return false;
	}
	return true;
}
int Bfs(int a,int b,int c,int d){
	int i;
	memset(vis,0,sizeof(vis));
	vis[a][b][c][d]=1;
	queue<node>q;
	node s,e;
	s.a=a;
	s.b=b;
	s.c=c;
	s.d=d;
	s.step=0;
	q.push(s);
	while(!q.empty()){
		s=q.front();
		q.pop();
		if(s.a==A&&s.b==B&&s.c==C&&s.d==D)
			return s.step;
		for(i=1;i<10;i++)      //个位
		{
			e=s;
			e.a=i;
			e.step++;
			if(vis[e.a][e.b][e.c][e.d])
				continue;
			if(!Judge(e))continue;
			vis[e.a][e.b][e.c][e.d]=1;
			q.push(e);
		}
		for(i=0;i<10;i++){     //十位
			e=s;
			e.b=i;
			e.step++;
			if(vis[e.a][e.b][e.c][e.d])
				continue;
			if(!Judge(e))continue;
			vis[e.a][e.b][e.c][e.d]=1;
			q.push(e);
		}
		for(i=0;i<10;i++){     //百位
			e=s;
			e.c=i;
			e.step++;
			if(vis[e.a][e.b][e.c][e.d])
				continue;
			if(!Judge(e))continue;
			vis[e.a][e.b][e.c][e.d]=1;
			q.push(e);
		}
		for(i=1;i<10;i+=2){      //千位
			e=s;
			e.d=i;
			e.step++;
			if(vis[e.a][e.b][e.c][e.d])
				continue;
			if(!Judge(e))continue;
			vis[e.a][e.b][e.c][e.d]=1;
			q.push(e);
		}
	}
	return -1;     //不能达到目的
}
int main()
{
	int T,i;
	int a,b,c,d;
	scanf("%d",&T);
	while(T--){
		scanf("%d",&i);
		a=i/1000;
		i=i%1000;
		b=i/100;
		i=i%100;
		c=i/10;
		d=i%10;
		scanf("%d",&i);
		A=i/1000;
		i=i%1000;
		B=i/100;
		i=i%100;
		C=i/10;
		D=i%10;
		if(Bfs(a,b,c,d)==-1)printf("Impossible\n");
		else printf("%d\n",Bfs(a,b,c,d));
	}
	return 0;
}