POJ 3126 Prime Path 解题报告（BFS & 双向BFS）

    题目大意：给定一个4位素数，一个目标4位素数。每次变换一位，保证变换后依然是素数，求变换到目标素数的最小步数。

    解题报告：直接用最短路。

    枚举1000-10000所有素数，如果素数A交换一位可以得到素数B，则在AB间加入一条长度为1的双向边。

    则题中所求的便是从起点到终点的最短路。使用Dijkstra或SPFA皆可。

    当然，纯粹的BFS也是可以的。

    用Dijkstra算法A了题目之后，看了一下Discuss，发现了一个新名词，双向BFS。

    即从起点和终点同时进行BFS，相遇则求得最短路。

    借鉴了思想，自己动手实现了代码。原本以为双向比单向快一倍而已，其实远远不止。

    笔者用30W数据分别测试了单向和双向。环境为CodeBlock+MinGW4.7，Debug，双向时间为8.618s，而单向为惊人的139.989s！

    简单思考了一下，也还是合理的。单向每次的增长是指数级的，而双向的指数只有单向的一半，优化程度相当高。

    好了，贴代码~首先是双向BFS的Dijkstra：

#include 
#include 
#include 
using namespace std;

const int maxn=10010;
int prime[maxn];
const int maxV=1100;
int first[maxV],vv[maxV*maxV],nxt[maxV*maxV];
int num[maxV];
bool vis[2][maxV];
int index;

bool check(int a,int b)
{
    int k=a-b;
    if(k%1000==0)
        return true;
    if(k<1000 && k%100==0 && a/1000==b/1000)
        return true;
    if(k<100 && k%10==0 && a/100==b/100)
        return true;
    if(a/10==b/10)
        return true;
    return false;
}

void calPrime()
{
    for(int i=2;iif(!prime[i])
    {
        for(int j=2*i;ji)
            prime[j]=true;
        if(i>=1000 && i<10000)
        {
            num[++index]=i;
            prime[i]=index;
        }
    }

    int e=2;
    memset(first,0,sizeof(first));
    for(int i=1;i<=index;i++)
        for(int j=i+1;j<=index;j++) if(check(num[j],num[i]))
        {
            nxt[e]=first[i],vv[e]=j,first[i]=e++;
            nxt[e]=first[j],vv[e]=i,first[j]=e++;
        }
}

struct Node
{
    int node;
    int level;
    bool operator<(const Node& cmp) const
    {
        return level>cmp.level;
    }
} p,q;

int Dijkstra(int sta,int end)
{
    if(sta==end)
        return 0;

    memset(vis,0,sizeof(vis));

    sta=prime[sta];
    end=prime[end];

    priority_queue pq[2];
    p.node=sta;
    p.level=0;
    vis[0][p.node]=true;
    pq[0].push(p);

    p.node=end;
    p.level=0;
    vis[1][p.node]=true;
    pq[1].push(p);

    for(int i=0; !pq[0].empty() && !pq[1].empty() ;i++)
    {
        int sel=0;
        if(pq[0].size()>pq[1].size())
            sel++;
        int level=pq[sel].top().level;
        while(!pq[sel].empty())
        {
            p=pq[sel].top();
            if(p.level!=level) //先判断，否则会pop掉丢失情况
                break;
            pq[sel].pop();

            for(int e=first[p.node];e;e=nxt[e])
            {
                if(vis[1-sel][vv[e]])
                    return i+1;
                if(!vis[sel][vv[e]])
                {
                    q.level=p.level+1;
                    q.node=vv[e];
                    vis[sel][vv[e]]=true;
                    pq[sel].push(q);
                }
            }
        }
    }

    return -1;
}

int main()
{
    calPrime();

    int T;
    scanf("%d",&T);
    while(T--)
    {
        int sta,end;
        scanf("%d%d",&sta,&end);
        int ans=Dijkstra(sta,end);
        if(ans==-1)
            printf("Impossible\n");
        else
            printf("%d\n",ans);
    }
}

    然后是单向的BFS+Dijkstra：

#include 
#include 
#include 
using namespace std;

const int maxn=10010;
int prime[maxn];
const int maxV=1100;
int first[maxV],vv[maxV*maxV],nxt[maxV*maxV];
int num[maxV];
bool vis[maxV];
int index;
int count;

bool check(int a,int b)
{
    int k=a-b;
    if(k%1000==0)
        return true;
    if(k<1000 && k%100==0 && a/1000==b/1000)
        return true;
    if(k<100 && k%10==0 && a/100==b/100)
        return true;
    if(a/10==b/10)
        return true;
    return false;
}

void calPrime()
{
    for(int i=2;iif(!prime[i])
    {
        for(int j=2*i;ji)
            prime[j]=true;
        if(i>=1000 && i<10000)
        {
            num[++index]=i;
            prime[i]=index;
        }
    }

    int e=2;
    memset(first,0,sizeof(first));
    for(int i=1;i<=index;i++)
        for(int j=i+1;j<=index;j++) if(check(num[j],num[i]))
    {
        nxt[e]=first[i],vv[e]=j,first[i]=e++;
        nxt[e]=first[j],vv[e]=i,first[j]=e++;
    }
}

struct Node
{
    int k;
    int w;
    bool operator<(const Node& cmp) const
    {
        return w>cmp.w;
    }
} p,q;

int Dijkstra(int sta,int end)
{
    memset(vis,0,sizeof(vis));
    end=prime[end];

    p.k=prime[sta];
    p.w=0;
    vis[p.k]=true;

    priority_queue pq;
    pq.push(p);

    while(!pq.empty())
    {
        p=pq.top();
        pq.pop();

        if(p.k==end)
            return p.w;

        for(int e=first[p.k];e;e=nxt[e]) if(!vis[vv[e]])
        {
            q.k=vv[e];
            q.w=p.w+1;
            vis[q.k]=true;
            pq.push(q);
        }
    }
    return -1;
}

int main()
{
    calPrime();

    int T;
    scanf("%d",&T);
    while(T--)
    {
        int sta,end;
        scanf("%d%d",&sta,&end);
        int ans=Dijkstra(sta,end);
        if(ans==-1)
            printf("Impossible\n");
        else
            printf("%d\n",ans);
    }
}

    测试数据我放在了百度云，有兴趣可以下载下来试一下：http://pan.baidu.com/share/link?shareid=4217669741&uk=2804348991

转载于:https://www.cnblogs.com/IT-BOY/p/3234103.html