【原】 POJ 3126 Prime Path 筛素数+BFS单源无权最短路径 解题报告

http://poj.org/problem?id=3126

方法：
先筛出1000~9999的所有素数，对于其中每个素数求得他在图中的邻接点。其邻接点就是所有与其有一位不同的素数。
再用BFS搜索图找到指定源节点和目标节点之间的最短路径。若不联通则输出失败

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

#include <stdio.h>
#include <iostream>
#include <vector>

using namespace std ;

//1000~9999
const int N = 10000 ;
const int INF = 0x7fffffff ;

struct slot
{
    slot():isPrime(1){}  //1表示素数，0表示合数
    int isPrime ;
    vector<int> adjList ;
};

typedef vector< struct slot > Graph ;

Graph G ;
int myQueue[N] ;  //自己写队列

//n*lglgn
void GetPrimeTable()
{
    __int64 i, j ;  //必须用__int64，不然j=i*i会超出范围

    G.resize(N) ;
    G[0].isPrime = G[1].isPrime= 0 ;
    i = 2 ;
    while( i<N )
    {
        for( j=i*i ; j<N ; j+=i )
            G[j].isPrime = 0 ;
        do ++i ;
        while( i<N && G[i].isPrime==0 ) ;
    }
}

void GetAdjacentList()
{
    int i,j,k,t ;
    int digit[4] ;
    int partnum[4] ;
    int prime,tmpnum ;

    for( i=1000 ; i<N ; ++i )
    {
        if( G[i].isPrime==0 )
            continue ;

        prime = tmpnum = i ;
        //得到每位数字放入digit[]
        for( j=1000,k=0 ; j>=1 ; j/=10,++k )
        {
            digit[k] = tmpnum/j ;
            tmpnum = tmpnum-digit[k]*j ;  //tmp%=j
        }

        //得到除去某位的其他各位组成的数
        partnum[0] = digit[1]*100+digit[2]*10+digit[3] ;
        partnum[1] = digit[0]*1000+digit[2]*10+digit[3] ;
        partnum[2] = digit[0]*1000+digit[1]*100+digit[3] ;
        partnum[3] = digit[0]*1000+digit[1]*100+digit[2]*10 ;

        //枚举得到邻接表
        for( j=1 ; j<=9 ; ++j )
        {
            tmpnum = j*1000 + partnum[0] ;
            if( G[tmpnum].isPrime==1 && tmpnum != prime )
                G[prime].adjList.push_back(tmpnum) ;

        }
        for( j=1,t=100 ; j<4 ; ++j,t/=10 )
        {
            for( k=0 ; k<=9 ; ++k )
            {
                tmpnum = k*t + partnum[j] ;
                if( G[tmpnum].isPrime==1 && tmpnum != prime )
                    G[prime].adjList.push_back(tmpnum) ;

            }
        }
    }
}

void run3216()
{
    int n ;
    int s,t ;
    bool found ;
    int curDist ;
    int vertex,adjVertex ;
    int front,rear,size ;
    vector<int>::iterator vIter ;

    GetPrimeTable() ;
    GetAdjacentList() ;

    scanf("%d", &n) ;
    while( n-- )
    {
        found = false ;
        vector<int> table(N,INF) ; //记录最短距离的table

        scanf("%d%d", &s,&t) ;

        size = 0 ;
        rear = 0 ;
        front = 1 ;

        table[s] = 0 ;  //起始点最短路径为0
        myQueue[++rear] = s ;  //将起始点入队
        ++size ;
        while( size!=0 && !found )
        {
            vertex = myQueue[front++] ; //出队
            --size ;
            curDist = table[vertex] ;   //当前最短路径

            if( vertex == t )  //搜索到目标节点
            {
                printf("%d\n", curDist) ;
                found = true ;
                break ;
            }

            //将邻接点入队
            for( vIter=G[vertex].adjList.begin() ; vIter!=G[vertex].adjList.end() ; ++vIter )
            {
                adjVertex = *vIter ;
                if( table[adjVertex]==INF )  //未处理过的
                {
                    table[adjVertex] = curDist+1 ;
                    if( adjVertex == t )   //搜索到目标节点
                    {
                        printf("%d\n", curDist+1) ;
                        found = true ;
                        break ;
                    }

                    myQueue[++rear] = adjVertex ;  //入队
                    ++size ;
                }
            }
        }
        if( !found )
            printf( "Impossible" ) ;
    }
}