POJ3126Prime Path

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

题意 ： 给你两个四位数，都是素数，一个是初始素数x，一个是目标素数y，让你从x变成y，x每次只能改变1位数，来变成另外一个素数k，再改变k的一位数变成另另外一个素数，这样变下去，找到x变成y需要的最少的次数，如果无法实现，输出Impossible

思路 ： 每个数字共有4位数，每位数字有10种可能的改变值[0...9]，但最高位不允许为0，所以可以将问题转化为图：初始素数和所有经一位数值改变得到的新素数为节点，若素数a经一位改变后变为素数b，则a连向b一条边长为1的有向边<a，b>，所以若目标素数y在图中，则初始素数到目标素数的路径上的边数即为花费数目，否则无解，如此一来，就转化为x到y的最短路径了，所以使用宽度优先搜索来寻找最短路即可             BFS 。

#include<cstdio>

#include<cstring>

#include<iostream>

using namespace std ;

const int maxn = 100000 ;

const int maxm = 9999 ;

struct node

{

    int k,step ;//当前素数为k,路径长度为step

} h[maxn] ;

int p[maxn] ;

int x,y,n,s[maxn] ;

void prim()

{

    memset(p,0,sizeof(p));

    p[0] = p[1] = 1 ;

    for (int i = 2 ; i <= maxm ; i++)

    {

        if(!p[i])

        {

            for(int j = i*i ; j <= maxm ; j += i)

            {

                p[j] = 1 ;

            }

        }

    }

}

int change(int x,int i,int j)//x的第i位数改为j

{

    if(i == 1) return(x/10)*10+j ;//个位数

    else if(i == 2) return (x/100)*100+x%10+j*10 ;

    else if(i == 3) return (x/1000)*1000+x%100+j*100 ;

    else if(i == 4) return (x%1000)+j*1000 ;

    return 0 ;

}

int main()

{

    prim() ;//生成[2....9999]之间的素数

    cin>>n;//输入测试用例数

    while(n--)

    {

        cin>>x>>y ;//输入初始素数和目标素数

        h[1].k = x ; //宽度优先搜索，初始素数进入队列

        h[1].step = 0 ;

        int l = 1 ,r = 1 ;//队列首尾指针初始化

        memset(s,100,sizeof(s)) ;//所有素数的路径长度初始化

        int ans = -1 ;//最小花费初始化

        while(1)

        {

            if(h[l].k == y)//若达到目标素数，则记下路径长度并退出循环

            {

                ans = h[l].step ;

                break ;

            }

            int tk,ts ;

            for(int i = 1 ; i <= 4 ; i++)//依次改变队首节点的每一位

            {

                for(int j = 0 ;  j <= 9 ; j++)

                {

                    if(!((j == 0)&&(i == 4)))//依次枚举第i位的改变值(不允许最高位变为0)

                    {

                        tk = change(h[l].k,i,j);//计算队首节点的第i位变为j的数tk

                        if(p[tk])//若tk为合数，继续枚举

                            continue;

                        ts = h[l].step+1 ;//计算得到的素数tk的路径长度

                        if(ts >= s[tk])

                            continue ;//若路径长度非最短，则继续枚举

                        if(tk == y)//若tk为目标素数，则记下路径长度并推出循环

                        {

                            ans = ts;

                            break ;

                        }

                        s[tk] = ts;//记下到素数tk的路径长度

                        r++ ;

                        h[r].k = tk ;//素数tk及其路径长度入队列

                        h[r].step = ts ;

                    }

                }

            }

            if(l == r||ans >= 0)//若队列空或者得到的目标素数，则退出循环

                break ;

            l++ ;//队首指针+1；

        }

        if(ans >= 0)//若得到目标素数，则输出最短路径

            cout<<ans<<endl ;

        else

            cout<<"Impossible"<<endl ;

    }

    return 0 ;

}

View Code