HDU-1688 Sightseeing(最短路+次短路)

题意：在一个有向图中,求从s到t两个点之间的最短路和比最短路长1的次短路的不同条路径数之和。

思路：求第k短路首先会想A*+SPFA去求，但是本题的时间给的有点少，A*+SPFA估计会超时。

所以可以在Dijkstra算法上稍做修改去求解：大想法是记录最短路和次短路，然后通过到当前点的最短路和次短路去更新其能够到达的点(因为从S到T的次短路要么是S到当前点u的最短路加上点u到T的次短路，要么是S到某个点u的次短路加上点u到T的最短路)。

所以我们需要维护两个dis数组，分别记录源点到当前点的最短路和次短路，然后再维护两个计数数组记录源点到当前点最短路和次短路的路径条数。

具体操作是：

如果当前为最短路，则判断最短路+其连接的点v是否可更新点v的最短路径：

如果小于原最短路径长度，则更新最短路并将之前的最短路更新至次短路，并相应地更新最短路和次短路的记录路径条数数组。

如果等于原最短路径长度，则更新最短路的路径条数数组。

如果大于原最短路径长度，则再判断是否可更新次短路，如果能，那么就更新次短路并相应地更新记录次短路的路径条数数组。

如果当前为次短路，则肯定更新不了最短路(所以让它尝试更新也不会发生错误)，则判断次短路+其连接的点v是否可更新点v的次短路径：

如果小于原次短路径长度，则更新次短路，并相应地更新次短路的记录路径条数数组。如果等于原最短路径长度，则更新次短路的路径条数数组。

Code：

#include <string.h>
#include <cstdio>
#include <queue>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
const int maxm = 10005;
struct node
{
	int v, w, key;
	node(int a, int b, int c):v(a), w(b), key(c){}
	bool operator<(const node k) const
	{
		return w > k.w;
	}
};
struct node1
{
	int v, w, next;
} edge[maxm];
int head[maxn], dis[maxn][2], cnt[maxn][2], vis[maxn][2];
int n, m, S, T, no, ans;
priority_queue<node> q;
inline void init()
{
	no = 0;
	memset(dis, 0x3f, sizeof dis);
	memset(head, -1, sizeof head);
	memset(cnt, 0, sizeof cnt);
	memset(vis, 0, sizeof vis);
}
inline void add(int u, int v, int w)
{
	edge[no].v = v;
	edge[no].w = w;
	edge[no].next = head[u];
	head[u] = no++;
}
void DJ()
{
	while(!q.empty()) q.pop();
	dis[S][0] = 0, cnt[S][0] = 1;
	q.push(node(S, 0, 0));
	while(!q.empty())
	{
		node tp = q.top(); q.pop();
		if(vis[tp.v][tp.key]) continue;	//这儿存在一个疑问，vis数组起到的是优化效率的效果，但去掉不进行优化是WA不是TLE
		vis[tp.v][tp.key] = 1;
		int k = head[tp.v], key = tp.key;
		while(k != -1)
		{
			int tmp = tp.w+edge[k].w;	//dis[key][tp.v]+edge[k].w;
			if(dis[edge[k].v][0] > tmp)
			{
				if(dis[edge[k].v][0] != inf)	//小优化
				{
					dis[edge[k].v][1] = dis[edge[k].v][0];
					cnt[edge[k].v][1] = cnt[edge[k].v][0];
					q.push(node(edge[k].v, dis[edge[k].v][1], 1));
				}
				dis[edge[k].v][0] = tmp;
				cnt[edge[k].v][0] = cnt[tp.v][key];
				q.push(node(edge[k].v, dis[edge[k].v][0], 0));
			}
			else if(dis[edge[k].v][0] == tmp)
			{
				cnt[edge[k].v][0] += cnt[tp.v][key];
			}
			else if(dis[edge[k].v][1] > tmp)
			{
				dis[edge[k].v][1] = tmp;
				cnt[edge[k].v][1] = cnt[tp.v][key];
				q.push(node(edge[k].v, dis[edge[k].v][1], 1));
			}
			else if(dis[edge[k].v][1] == tmp)
			{
				cnt[edge[k].v][1] += cnt[tp.v][key];
			}
			k = edge[k].next;
		}
	}
	ans = cnt[T][0];
	if(dis[T][0]+1 == dis[T][1]) ans += cnt[T][1];
}
int main()
{
	int t, u, v, w;
	scanf("%d", &t);
	for(int _ = 1; _ <= 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);
		DJ();
		printf("%d\n", ans);
	}
	return 0;
}

继续加油~