门牌号（bfs）

题目链接：http://poj.org/problem?id=3126

 

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

3
1033 8179
1373 8017
1033 1033

Sample Output

6
7
0

 

题目大意：一开始有一个四位数门牌号，我们要改成另一个四位数门牌号，这四位数字只能是素数，并且一次只能改一位数字，且改变一位数字之后仍为素数，问最少有几次改变，如果不能改变，就输出impossible；

 

深搜很明显不行，因为它是一条路走到黑的搜索，而这道题中是找中间的数，可能有几个数是不变的....大概意思就是这了；

bfs就是找分层找，第一个找到的必定是最少的；

 

 

#include<stdio.h>
#include<string.h>
#include<math.h>

#include<queue>
#include<stack>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;

#define ll long long
#define da    10000000
#define xiao -10000000
#define clean(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f

int shuzu[4];
bool sushu[10010];
bool biaoji[10010];
int num[10010];

int n,m;

void su()								//打一个素数表 
{
	int i,j;
	for(i=0;i<10010;++i)
		sushu[i]=1;
	sushu[0]=0;
	sushu[1]=0;
	for(i=2;i<10010;++i)
	{
		for(j=i+i;j<10010;j=j+i)
		{
			if(sushu[j])
				sushu[j]=0;
		}
	}
	
}

queue<int> s;

void bfs()
{
	int i,j;
	s.push(n);
	biaoji[n]=1;
	num[n]=0;
	while(s.size())
	{
		int x=s.front();
		s.pop();
		shuzu[0]=x%10;								//把四位数每位存起来 
		shuzu[1]=x/10%10;
		shuzu[2]=x/100%10;
		shuzu[3]=x/1000;
		for(i=0;i<4;++i)							//从第一位开始找（换数字） 
		{
			int can=shuzu[i];						//每次只换一个因此后面变时之前的数字不能变 
			for(j=0;j<10;++j)
			{
				if(j==0&&i==3)						//千位数是0跳过 
					continue;
				shuzu[i]=j;
				int shu=shuzu[0]+shuzu[1]*10+shuzu[2]*100+shuzu[3]*1000;
				if(sushu[shu]&&biaoji[shu]==0)		//这个数是素数&&没找到过 
				{
					biaoji[shu]=1;					//标记一下 
					s.push(shu);					//加入队列 
					num[shu]=num[x]+1;				// 改变次数=上一次+1 ； 
				}
				if(shu==m)							//找到目标的数，结束 
					return ;
			}
			shuzu[i]=can;							//再次使改变的数回归，找下一位； 
		}
	}
	
}

int main()
{
	su();											//预处理出所有的素数 
	int i,j;
	int t;
	while(~scanf("%d",&t))
	{
		while(t--)
		{
			clean(shuzu,0);
			clean(biaoji,0);
			clean(num,inf);							//清空 
			while(s.size())
				s.pop();
			scanf("%d%d",&n,&m);
			bfs();									//搜索 
			if(num[m]<inf)
				printf("%d\n",num[m]);
			else
				printf("Impossible\n");
			
			
		}
	}
}