POJ 3126 Prime Path（素数路径）

POJ 3126 Prime Path（素数路径）

Time Limit: 1000MS    Memory Limit: 65536K

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.

内阁部长对安全部长发表改变办公室四位数房间号码的声明感到诚惶诚恐。
— 随时换号码是安全的做法，毕竟暗潮四伏。
— 然而我选1033做法房间号是有理由的。我是首相（Prime minister），你懂的。
— 我知道，所以你的新号码8179也是一个素数（prime ）。你只要在你办公室门上的旧号码前贴四个新数字就好了。
— 没那么简单。如果我把第一个数改成8，那么号码将变成8033，这可不是素数。
— 我懂，你是总理，有素数强迫症。
— 是啊！所以我必须找个通过素数路径从1033到8179的方法，就是只改变其中一个数，并从一个素数到另一个素数。
 
与此同时，财政部长正暗中观察。
— 别搞没必要的开销！一个数字可是要一英镑。
— 嗯，这种情况下我需要一个计算最小成本的程序。你知道有群廉价的软件大神吗？
— 当然知道。你看，这里就有个算法比赛……帮助总理找出任意两个给定的四位素数间最便宜的素数路径！当然第一个数字不能为零。这是上述情况的解法。
 
这种解法的成本是6镑。注意，第2步中的数字1不能在最后一步重新使用 - 必须买个新的1。

CN

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).

第一行为一个正整数：测试用例的数量（最多100）。
随后每个测试用例，一行有两个以空格分隔的数。每个数皆为四位素数（无前导零）。

CN

Output - 输出

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

每个用例一行，一个表示最少花费的数或单词Impossible。

CN

Sample Input - 输入样例

3
1033 8179
1373 8017
1033 1033

Sample Output - 输出样例

6
7
0

题解

　　一开始没判断是否可行还是A了，完全没有注意那个Impossible。
　　最初设想用DFS，然而感觉没有BFS方便。
　　打个素数表，做个标记，然后BFS就能出来了。

代码 C++

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #define mx 10000
 char prim[mx] = {  }, data[];
 int len[mx];
 void rdy(){
     int i, j;
     for (i = ; i < mx; i += ) prim[i] = ;
     for (i = ; i < mx; i += ){
         if (prim[i]) continue;
         for (j = i << ; j < mx; j += i) prim[j] = ;
     }
     for (i = ; i < ; ++i) prim[i] = ;
 }
 int getData(){
     int i, opt = ;
     for (i = ; i < ; ++i) opt = opt *  + data[i] - '';
     return opt;
 }
 void setData(int a){
     for (int i = ; ~i; --i) data[i] = '' + a % , a /= ;
 }
 int main(){
     rdy();
     int t,st, ed, now, nxt,i;
     char j, tmp;
     scanf("%d", &t);
     while (t--){
         scanf("%d%d", &st, &ed);
         memset(len, 0x7F, sizeof len); len[st] = ;
         std::queue<int> q; q.push(st);
         while (!q.empty()){
             setData(now = q.front()); q.pop();
             for (i = ; i < ; ++i){
                 tmp = data[i];
                 for (j = ''; j <= ''; ++j){
                     if (j == tmp) continue;
                     data[i] = j; nxt = getData();
                     if (prim[nxt] || len[now] +  >= len[nxt]) continue;
                     len[nxt] = len[now] + ; q.push(nxt);
                 }
                 data[i] = tmp;
             }
         }
         printf("%d\n", len[ed]);
     }
     return ;
 }