HDOJ 1973 Prime Path

题目很简单，给你两个四位数素数，一个是初始素数，一个是目标素数，每次变化四位数中的一个数，但每次变化后的数都是素数，求到目标素数的最小步数，为了求最小步数，直接BFS既可，因为是四位数直接开一个一万长度的标记数组就可以，然后再开一个一万长度的数组记录到达这个数的步数，第一次到达即是最小步数；

注意：四位数的变化，
个位数的变化应该以2为单位，因为如果个位数是偶数肯定就不是素数
素数的判断，暴力既可，
BFS的返回值；
队列清空；
剪枝：个位数2变化不要偶数；

初始素数和目标素数都要为素数

Sample Input

  
  

   
   3
1033 8179
1373 8017
1033 1033
  
  

 

Sample Output

  
  

   
   6
7
0
  
  

#include<stdio.h>
#include<string.h>
#include<queue>
#include<math.h>
using namespace std;
int ok;
bool use[10100];
int ans[10100];
queue<int>que;
int a,b,l;
int check(int x)
{
    int i;
    for(i=2;i*i<=x;i++)
    {
        if(x%i==0)
        {
            return 0;
        }
    }
    return 1;
}
int BFS(int m,int step)
{
    int i,w;
    while(!que.empty())
    {
        int tem =que.front();
        que.pop();
        if(use[b])
        {
            return ans[b];
        }
        int x=tem;
        for(i=1;i<=9;i=i+2)
        {
            w=x/10*10+i;
            if(x!=w&&!use[w]&&check(w))
            {
                use[w]=true;
                ans[w]=ans[x]+1;
                que.push(w);
            }
        }
        for(i=0;i<=9;i++)
        {
            w=x/100*100+i*10+x%10;
            if(x!=w&&!use[w]&&check(w))
            {
                use[w]=true;
                ans[w]=ans[x]+1;
                que.push(w);
            }
        }
        for(i=0;i<=9;i++)
        {
            w=x/1000*1000+i*100+x%100;
            if(x!=w&&!use[w]&&check(w))
            {
                use[w]=true;
                ans[w]=ans[x]+1;
                que.push(w);
            }
        }
        for(i=1;i<=9;i++)
        {
            w=i*1000+x%1000;
            if(x!=w&&!use[w]&&check(w))
            {
                use[w]=true;
                ans[w]=ans[x]+1;
                que.push(w);
            }
        }
    }
    return -1;
}
int main()
{
    int T,i,j,k,w,o,flag;
    scanf("%d",&T);
    while(T--)
    {
        while(!que.empty())
            que.pop();
        scanf("%d%d",&a,&b);
        memset(use,0,sizeof(use));
        use[a]=true;
        ans[a]=0;
        que.push(a);
        if(!check(a)&&!check(b))
        {
            printf("Impossible\n");
        }
        else
        {
            flag=BFS(a,0);
            if(flag!=-1)
            {
                printf("%d\n",flag);
            }
            else
            {
                printf("Impossible\n");
            }
        }

    }
return 0;
}