poj 3255 Roadblocks（spfa次短路 || Dijsktra）

①Dijsktra（454ms）

dis[i][0]：表示最短路；dis[i][1]：表示次短路；

每个点用数组vis标记，最短路标记为vis[i][0]，次短路标记为vis[i][1]；

先把源点加入图中，然后对个边进行松弛，总共需要2*n-1次（n-1次更新最短路，n次更新次短路）

初始化dis[src][0]=0;

每次选取到i点的最短距离的点或者次短距离的点进行松弛，优先松弛最短路，最短路如果可以松弛那么次短路也需要松弛，否则选择松弛次短路，具体实现详见代码。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const double eps=1e-3;
const int INF=0x3f3f3f3f;
const int maxn=5010;
int n,m;
int vis[maxn][2],dis[maxn][2],head[maxn];
int edgeNum;

struct Edge{
	int to;
	int w;
	int next;
}edge[200010];

void addEdge(int u,int v,int w){
	edge[edgeNum].to=v;
	edge[edgeNum].w=w;
	edge[edgeNum].next=head[u];
	head[u]=edgeNum++;
}

void Init(){
	memset(vis,0,sizeof(vis));
	memset(dis,INF,sizeof(dis));
	memset(head,-1,sizeof(head));
	edgeNum=0;
}

void Dijsktra(int src,int des){
	dis[src][0]=0;
	for(int i=1;i<2*n;i++){
		int pos,min=INF,flag=-1;
		for(int j=1;j<=n;j++){
			if(!vis[j][0]&&min>dis[j][0]){
				min=dis[pos=j][0];
				flag=0;
			}
			else if(!vis[j][1]&&min>dis[j][1]){
				min=dis[pos=j][1];
				flag=1;
			}
		}
		if(flag==-1) break;
		vis[pos][flag]=1;
		for(int j=head[pos];j!=-1;j=edge[j].next){
			int v=edge[j].to;
			if(dis[v][0]>min+edge[j].w){
				dis[v][1]=dis[v][0];
				dis[v][0]=min+edge[j].w;
			}
			else if(dis[v][1]>min+edge[j].w){
				dis[v][1]=min+edge[j].w;
			}
		}
	}
	printf("%d\n",dis[des][1]);
}

int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
	while(~scanf("%d%d",&n,&m)){
		Init();
		int u,v,w;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			addEdge(v,u,w);
		}
		Dijsktra(1,n);
	}
	return 0;
}

②A*+SPFA（157ms）

先用spfa或者dijsktra预处理点n到其他所有点的最短距离dis[i] {i=1,2,...,n-1};

然后BFS进行逐层往下搜索。

设计估价函数f=g+h，用优先队列维护，g为到当前点所花的最小费用，h为到点n所需要的最小费用，即dis[i]，每次扩展优先选取总费用最小的点。

当所扩展的点为n的次数为2时，即为次短路。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

const double eps=1e-3;
const int INF=0x3f3f3f3f;
const int maxn=5010;
int n,m;
int vis[maxn],dis[maxn],head[maxn];
int edgeNum;

struct Edge{
	int to;
	int w;
	int next;
}edge[200010];

void addEdge(int u,int v,int w){
	edge[edgeNum].to=v;
	edge[edgeNum].w=w;
	edge[edgeNum].next=head[u];
	head[u]=edgeNum++;
}

void Init(){
	memset(vis,0,sizeof(vis));
	memset(dis,INF,sizeof(dis));
	memset(head,-1,sizeof(head));
	edgeNum=0;
}

void spfa(int src){
	queue<int>q;
	q.push(src);
	vis[src]=1;
	dis[src]=0;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=head[u];i!=-1;i=edge[i].next){
			int v=edge[i].to;
			if(dis[v]>dis[u]+edge[i].w){
				dis[v]=dis[u]+edge[i].w;
				if(!vis[v]){
					vis[v]=1;
					q.push(v);
				}
			}
		}
	}
}

struct node{
	int to;
	int g,h,f;
	bool operator<(const node &a)const {
		return f>a.f||(f==a.f&&g>a.g);
	}
};

void Astar(int src,int des){
	priority_queue<node>q;
	int cnt=0;
	node s,e;
	s.to=src;
	s.g=0;
	s.h=dis[src];
	s.f=s.g+s.h;
	q.push(s);
	while(!q.empty()){
		s=q.top();
		q.pop();
		if(s.to==des){
			cnt++;
			if(cnt==2){
				printf("%d\n",s.g);
				return ;
			}
		}
		int u=s.to;
		for(int i=head[u];i!=-1;i=edge[i].next){
			e.to=edge[i].to;
			e.g=s.g+edge[i].w;
			e.h=dis[edge[i].to];
			e.f=e.g+e.h;
			q.push(e);
		}
	}
}

int main(){
	while(~scanf("%d%d",&n,&m)){
		Init();
		int u,v,w;
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			addEdge(v,u,w);
		}
		spfa(n);
		Astar(1,n);
	}
	return 0;
}