BFS --- 素数环

<传送门>

 

【题目大意】
对话很坑爹，不过很有意思，直接看题干就可以了。
给你两个四位数a和b，现在要你从a经过变换得到b，并且变换的中间的每一位都要是素数，并且相邻两个素数之间只能有一个位不同。
【题目分析】
开始没想到怎么做，以为有什么高深的解法，后来经大神指点说是爆搜就可，思路才打开。

这题没什么陷阱，用爆搜时间复杂度也很低。

怎么爆搜呢？
我们将a的每个位都从0~9列举出来放入队列中，其实就是BFS，只不过是40出口的BFS，但是个位上必须将偶数除掉，顿时就少了一半的搜索量。

因为数据不是很大，所以我们可以用结构体数组来模拟队列。
BFS队列+素数判定

 

//Memory   Time

//  256K       32MS

#include<iostream>

#include<cstring>

using namespace std;



struct Node

{

        int prime;

        int step;

};



bool JudgePrime(int digit)

{

    if(digit==2 || digit==3)

        return true;

    else if(digit<=1 || digit%2==0)

        return false;

    else if(digit>3)

    {

        for(int i=3;i*i<=digit;i+=2)

            if(digit%i==0)

                return false;

        return true;

    }

}



int a,b;

bool vist[15000];

Node queue[15000];



void BFS(void)

{

    int i;  //temporary

    int head,tail;

    head=tail=0;

    queue[head].prime=a;

    queue[tail++].step=0;

    vist[a]=true;



    while(head<tail)

    {

        Node x=queue[head++];//出队

        if(x.prime==b)

        {

            cout<<x.step<<endl;

            return;

        }



        int unit=x.prime%10;      

        int deca=(x.prime/10)%10;  

        for(i=1;i<=9;i+=2)    

        {

            int y=(x.prime/10)*10+i;

            if(y!=x.prime && !vist[y] && JudgePrime(y))

            {

                vist[y]=true;

                queue[tail].prime=y;

                queue[tail++].step=x.step+1;

            }

        }

        for(i=0;i<=9;i++)     

        {

            int y=(x.prime/100)*100+i*10+unit;

            if(y!=x.prime && !vist[y] && JudgePrime(y))

            {

                vist[y]=true;

                queue[tail].prime=y;

                queue[tail++].step=x.step+1;

            }

        }

        for(i=0;i<=9;i++)   

        {

            int y=(x.prime/1000)*1000+i*100+deca*10+unit;

            if(y!=x.prime && !vist[y] && JudgePrime(y))

            {

                vist[y]=true;

                queue[tail].prime=y;

                queue[tail++].step=x.step+1;

            }

        }

        for(i=1;i<=9;i++)    

        {

            int y=x.prime%1000+i*1000;

            if(y!=x.prime && !vist[y] && JudgePrime(y))

            {

                vist[y]=true;

                queue[tail].prime=y;

                queue[tail++].step=x.step+1;

            }

        }

    }



    cout<<"Impossible"<<endl;

    return;

}



int main(void)

{

    int test;

    cin>>test;

    while(test--)

    {

        cin>>a>>b;

        memset(vist,false,sizeof(vist));

        BFS();

    }

    return 0;

}

View Code