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 <cstdio>
#include <cstring>
#include <queue>
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;i<maxn;i++) if(!prime[i])
{
for(int j=2*i;j<maxn;j+=i)
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<Node> 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 <cstdio>
#include <cstring>
#include <queue>
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;i<maxn;i++) if(!prime[i])
{
for(int j=2*i;j<maxn;j+=i)
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<Node> 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