poj3463 Sightseeing(图论/最短路+次短路的路径数)

题目

有向图，n<=1e3，m<=1e4

求最短路的路径数量和比最短路长度大1的路径的数量之和

题解

经典题目，难度尚可，还是总结一下吧，每次取队首时分四种情况讨论

即最短路发生更新，等于最短路，次短路发生更新，等于次短路，

Node加一维状态区分次短路还是最短路，每发生更新就把更新的值丢进优先队列里

有个小优化的地方是，次短路是INF的时候，不放入优先队列

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f,N=1e3+10,M=1e4+10;
struct Node
{
	int u,w,op;
	Node(){}
	Node(int a,int b,int c):u(a),w(b),op(c){}
};
struct Edge
{
	int v,w,nex;
	Edge(){}
	Edge(int a,int b,int c):v(a),w(b),nex(c){}
}e[M*2];
bool operator<(Node a,Node b)
{
	return a.w>b.w;
}
priority_queue<Node>q;
int head[N],cnt,u,v,w;
int s,t,n,m,dis[N][2],dp[N][2];//最短路和次短路距离 最短路和次短路数量 
bool vis[N][2];
void init()
{
	memset(head,0,sizeof head);
	cnt=0;
}
void add(int u,int v,int w)
{
	e[++cnt]=Edge(v,w,head[u]);
	head[u]=cnt;
}
void dijkstra(int s)
{
	memset(dis,INF,sizeof dis);
	memset(dp,0,sizeof dp);
	memset(vis,0,sizeof vis);
	q.push(Node(s,0,0));
	dis[s][0]=0;dp[s][0]=1;
	int u,v,w,op;
	while(!q.empty())
	{
		u=q.top().u;op=q.top().op;
		q.pop();
		if(vis[u][op])continue;
		vis[u][op]=1;
		for(int i=head[u];i;i=e[i].nex)
		{
			v=e[i].v;w=e[i].w;
			if(dis[v][0]>w+dis[u][op])
			{
				dis[v][1]=dis[v][0];
				dp[v][1]=dp[v][0];
				if(dis[v][0]!=INF)q.push(Node(v,dis[v][1],1));
				dis[v][0]=w+dis[u][op];
				dp[v][0]=dp[u][op];
				q.push(Node(v,dis[v][0],0));
			}
			else if(dis[v][0]==w+dis[u][op])
			{
				dp[v][0]+=dp[u][op];
			}
			else if(dis[v][1]>w+dis[u][op])
			{
				dis[v][1]=w+dis[u][op];
				dp[v][1]=dp[u][op];
				q.push(Node(v,dis[v][1],1));
			}
			else if(dis[v][1]==w+dis[u][op])
			{
				dp[v][1]+=dp[u][op];
			}
		}
	}
}
int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		init();
		scanf("%d%d",&n,&m);
		for(int i=1;i<=m;++i)
		{
			scanf("%d%d%d",&u,&v,&w);
			add(u,v,w);
		}
		scanf("%d%d",&s,&t);
		dijkstra(s);
		if(dis[t][1]-dis[t][0]==1)printf("%d\n",(dp[t][0]+dp[t][1]));
		else printf("%d\n",(dp[t][0]));
	} 
	return 0;
}