How Many Paths Are There(HDU 3191)+Sightseeing(HDU 1688)

① How Many Paths Are There
② Sightseeing

分析

被这两题卡了一天终于想明白了一点，可能还有不足的地方望大佬指正，以下是分析：
这两题难点都是统计最短路和次短路的路径数，主要区别在于：
①中存在有向环且为正权图。
②中不存在有向环并且存在边的边权为0。
也就是这样造成了两题的题解略有差异，如果直接套模板的话就会造成题②WA，具体要搞清楚以下几点：
第一，这类题型貌似只能用dijkstra而不能用SPFA写，这是因为在用dijkstra算法的时候，每个顶点出栈都是其最小的情况了，举例来说就是如果点u出栈，那么到u的最小或者次小路径数已经统计完毕，如果存在边(u,v)，那么点u对于v的贡献已经确定，并且之后不会重复贡献，而SPFA算法由于在计算过程中，最短/次短路径长度或者最短/次短路径数的改变都必须要将其入队，这是因为如果不将其入队就有可能导致他的相邻顶点的统计漏了，而大量入队又导致了其统计的重复，即使我用增量来进行统计仍然会被acwing网站的一组数据卡住，由于数据量太大且想不出其他hack数据就只好作罢，希望以后能做出来或者想明白。
第二，由于题②存在为0的边权，那么在用dijkstra算法的时候，由于每次出栈都是处理当前距离最小的点，那么可能出现某个点已出栈但是其路径数还没统计完，造成这个点相邻的点也统计错误，如图。

以统计最短路为例，根据dijkstra算法以上顶点出栈顺序是1，2，3，4。
按照传统dijkstra的思路，最终结果应该是num[1]=1,num[2]=2,num[3]=1,num[4]=2,但从图中观察我们能发现存在1->4应有3条路径：1->4,1->2->4,1->3->2->4，错误的原因在于漏统计了1->3->2->4，这是因为2比3先出栈，使得1->3->2这条路径还没统计进2的路径数，就已经将2的路径数作为最终结果贡献给了4，所以显然对于这种含0权的图，直接套用模板是错误的，正确做法应该是先拓扑排序，对于优先队列中的排序判定改为：距离不等按照距离从小到大，距离相等按照拓扑序位置来进行排序，这样就可以正确解决了。
综上，对于正权图，可以直接套用模板；而对于非负权DAG图，应该考虑拓扑序。

源程序

How Many Paths Are There

#include <bits/stdc++.h>
#define MAXN 105
#define INF 0x3f3f3f3f
using namespace std;
int k,n,m,s,t,in[MAXN],level[MAXN];	
struct Edge{	//链式前向星 
	int v,w,next;
	Edge(){};
	Edge(int _v,int _w,int _next){
		v=_v,w=_w,next=_next;
	}
	bool operator <(const Edge a)const{
		if(w!=a.w)return w>a.w;
		else return level[v]>level[a.v];	//拓扑序位置 
	}
}edge[MAXN*MAXN];
int EdgeCount,head[MAXN];
int dis[MAXN][2],nums[MAXN][2];
bool used[MAXN][2];
void addEdge(int u,int v,int w)	//链式前向星建图 
{
	edge[++EdgeCount]=Edge(v,w,head[u]);
	head[u]=EdgeCount;
}
void TopSort()	//拓扑排序 
{
	queue<int> q;
	int cnt=0;
	for(int i=0;i<n;i++)
		if(!in[i])q.push(i);
	while(!q.empty()){
		int u=q.front();q.pop();
		level[u]=++cnt;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v;
			in[v]--;
			if(!in[v])q.push(v);
		}
	}
}
void dijkstra()
{
	priority_queue<Edge> q;
	memset(dis,0x3f,sizeof(dis));
	memset(used,false,sizeof(used));
	memset(nums,0,sizeof(nums));
	dis[s][0]=0;
	nums[s][0]=1;
	q.push(Edge{s,0,0});
	while(!q.empty()){
		int u=q.top().v,flag=q.top().next;
		q.pop();
		if(used[u][flag])continue;
		used[u][flag]=true;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			if(dis[v][0]>dis[u][flag]+w){	//更新最短路 
				dis[v][1]=dis[v][0];
				nums[v][1]=nums[v][0];
				q.push(Edge{v,dis[v][1],1});
				dis[v][0]=dis[u][flag]+w;
				nums[v][0]=nums[u][flag];
				q.push(Edge{v,dis[v][0],0});
			}
			else if(dis[v][0]==dis[u][flag]+w)
				nums[v][0]+=nums[u][flag];
			else if(dis[v][1]>dis[u][flag]+w){	//更新次短路 
				dis[v][1]=dis[u][flag]+w;
				nums[v][1]=nums[u][flag];
				q.push(Edge{v,dis[v][1],1});
			}
			else if(dis[v][1]==dis[u][flag]+w)
				nums[v][1]+=nums[u][flag];
		}
	}
}
int main()
{
	while(~scanf("%d%d%d%d",&n,&m,&s,&t)){
		memset(head,0,sizeof(head));
		memset(in,0,sizeof(in));
		EdgeCount=0;
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			in[v]++;
		}
		TopSort();
		dijkstra();
		printf("%d %d\n",dis[t][1],nums[t][1]);
	}
}

Sightseeing

#include <bits/stdc++.h>
#define MAXN 1005
#define INF 0x3f3f3f3f
using namespace std;
struct Edge{	//链式前向星 
	int v,w,next;
	Edge(){};
	Edge(int _v,int _w,int _next){
		v=_v,w=_w,next=_next;
	}
	bool operator <(const Edge a)const{
		return w>a.w;
	}
}edge[MAXN*10];
int EdgeCount,head[MAXN];
int k,n,m,s,t;
int dis[MAXN][2],nums[MAXN][2];
bool used[MAXN][2];
void addEdge(int u,int v,int w)	//链式前向星建图 
{
	edge[++EdgeCount]=Edge(v,w,head[u]);
	head[u]=EdgeCount;
}
int dijkstra()
{
	priority_queue<Edge> q;
	memset(dis,0x3f,sizeof(dis));
	memset(used,false,sizeof(used));
	memset(nums,0,sizeof(nums));
	dis[s][0]=0;
	nums[s][0]=1;
	q.push(Edge{s,0,0});
	while(!q.empty()){	
		int u=q.top().v,flag=q.top().next;
		q.pop();
		if(used[u][flag])continue;
		used[u][flag]=true;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			if(dis[v][0]>dis[u][flag]+w){	//更新最短路 
				dis[v][1]=dis[v][0];
				nums[v][1]=nums[v][0];
				q.push(Edge{v,dis[v][1],1});
				dis[v][0]=dis[u][flag]+w;
				nums[v][0]=nums[u][flag];
				q.push(Edge{v,dis[v][0],0});
			}
			else if(dis[v][0]==dis[u][flag]+w)
				nums[v][0]+=nums[u][flag];
			else if(dis[v][1]>dis[u][flag]+w){	//更新次短路 
				dis[v][1]=dis[u][flag]+w;
				nums[v][1]=nums[u][flag];
				q.push(Edge{v,dis[v][1],1});
			}
			else if(dis[v][1]==dis[u][flag]+w)
				nums[v][1]+=nums[u][flag];
		}
	}
	if(dis[t][0]+1==dis[t][1])return nums[t][0]+nums[t][1];
	return nums[t][0];
}
int main()
{
	scanf("%d",&k);
	while(k--){
		memset(head,0,sizeof(head));
		EdgeCount=0;
		scanf("%d%d",&n,&m);
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
		} 
		scanf("%d%d",&s,&t);
		printf("%d\n",dijkstra());
	}
}