搜索 I - 09

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

              这道题的题意为每行给你两个素数，然后每次只能变换一位数，并且变换后仍为素数，求变换的最小次数。这道题为BFS题，可以先对数据是否为素数进行预处理，然后就是进行广搜了，用队列储存每次变换后为素数的数据，然后用一数组储存变换到这个数需要的最少步数，要求变换后的那个数对应的数组数即为变换的最少步数。

源代码如下：

#include <iostream>  
#include <string.h>  
#include <math.h>  
#include <queue>  
using namespace std;  
int main()
{  
    int i,n,x,y,a,b,d,t,k,j,p[10005],f[10005],w[4];  
    for(i=2;i<10005;i++)
  { k=-1;
    for(j=2;j<=sqrt(i);++j)
    { if(i%j==0)
 {
 k=-2;
      break;
 }
    }
    p[i]=k;
  }   
    cin>>n;  
    while(n--)
{  
        cin>>x>>y;  
        memcpy(f,p,10005*sizeof(int));  
        f[x]=0;  
        queue<int>q;  
        q.push(x);  
        while (!q.empty()&&(f[y]==-1))  
        {  
            t=q.front();  
            a=t;  
            q.pop();  
  
            for (i=0;i<=3;i++) 
{
 w[i]=a%10;
 a/=10;
}  
    
            for (i=0;i<=9;i++)  
            {  
                a=i+10*w[1]+100*w[2]+1000*w[3];  
                if (f[a]==-1) {  
                    f[a]=f[t]+1;  
                    q.push(a);  
                }  
            }  
              
            for (i=0;i<=9;i++)  
            {  
                a=w[0]+10*i+100*w[2]+1000*w[3];  
                if (f[a]==-1) {  
                    f[a]=f[t]+1;  
                    q.push(a);  
                }  
            }  
            for (i=0;i<=9;i++)  
            {  
                a=w[0]+10*w[1]+100*i+1000*w[3];  
                if (f[a]==-1) {  
                    f[a]=f[t]+1;  
                    q.push(a);  
                }  
            }  
            for (i=1;i<=9;i++)  
            {  
                a=w[0]+10*w[1]+100*w[2]+1000*i;  
                if (f[a]==-1) {  
                    f[a]=f[t]+1;  
                    q.push(a);  
                }  
            }  
  
        }  
        if (f[y]!=-1) cout<<f[y]<<endl;
else cout<<"Impossible"<<endl;  
    }  
  
    
}