第K短路[POJ2449]

最新推荐文章于 2021-04-15 18:29:42 发布

zsyz_lb2003

最新推荐文章于 2021-04-15 18:29:42 发布

阅读量279

点赞数 2

CC 4.0 BY-SA版权

分类专栏：蓝书做题记录

本文链接：https://blog.youkuaiyun.com/zyszlb2003/article/details/89433892

蓝书做题记录专栏收录该内容

66 篇文章

订阅专栏

本文介绍了一种使用A*算法求解有向图中第K短路的方法，通过反向求最短路得到估价函数，再利用A*算法的优先队列进行正向搜索，有效地优化了时间复杂度。

欢迎大家访问我的老师的OJ———caioj.cn

题面描述

给定 $N$ 个点， $M$ 条有向边，求第 $K$ 短路。
注意：若出发点与结束点为同一点，则一定要从出发点跑出去，再跑回来，才算最短路

思路

这道题如果直接优先队列跑的话，最坏时间复杂度为 $O (K * (N + M) * (l o g (N + M))$ ，因为我们要跑 $K$ 次路径。
现提供 $A *$ 做法:
所谓 $A *$ ，~~用人话描述~~就是目光要放长远，~~脚步要够坚定~~，它好比有高人带着你刷副本似的，少走弯路。
比起普通优先队列， $A *$ 多了一个估价函数 $f (x)$ ，为了保证最优解， $f (x)$ 要满足一个基本准则

设当前状态 $\operatorname{state}$ 到目标状态所需代价的估计值为 $\operatorname{f(state)}。$
实际所需价值为 $\operatorname{g(state)}$ .
对于任意的 $\operatorname{state}$ ,应该有 $\operatorname{f(state)}\le \operatorname{g(state)}$

这种带有估计函数的优先队列BFS就称为 $\large \operatorname{A*(A~ Star)}$ .只要保证 $\operatorname{f(state)}\le \operatorname{g(state)}$ ，A*就一定能在目标状态第一次从堆中取出时得到最优解，并且在搜索过程中每个状态只需要被拓展一次。
下面给出简要证明：
设当前状态 $S$ 并不是最优解，
则 $S$ 的“当前代价”+ $\operatorname{\large f(S)}\ge$ 当前处在未来最优路径上的 $T$ 的“代价“+ $\operatorname{\large f(T)}$ ,所以 $T$ 先拓展， $S$ 则被忽略。

第K短路则运用了 $A *$ 的排除多余状态与优先队列 $B F S$ ,第几次取出 $e d$ ,即求到第几短路的性质来解决问题， $A *$ 主要起优化作用。

先反向求从 $e d$ 跑到 $s t$ 的最短路，得到估价函数 $f$

后正常BFS即可。

代码

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int N=1e3+10;
const int inf=0x3f3f3f3f;
const int M=1e5+10;
struct edge{int x,y,d,next;}a[M],b[M];int len,last1[N],last2[N];
void ins(int x,int y,int d)
{
	a[++len].x=x,a[len].y=y;a[len].d=d;a[len].next=last1[x];last1[x]=len;
	b[len].x=y;b[len].y=x;b[len].d=d;b[len].next=last2[y];last2[y]=len;
}
struct nde
{
	int x,d;
	nde(){}
	nde(int x,int d):x(x),d(d){}
	bool operator <(const nde a)const{return d>a.d;}
};
int f[N];bool v[N];int st,ed;
void dijk_p()
{
	priority_queue<nde>q;
	memset(f,0x3f,sizeof(f));memset(v,false,sizeof(v));
	q.push(nde(ed,0));f[ed]=0;
	while(!q.empty())
	{
		nde t=q.top();q.pop();
		int x=t.x;if(v[x])continue;
		v[x]=true;
		for(int k=last2[x];k;k=b[k].next)
		{
			int y=b[k].y;
			if(f[y]>f[x]+b[k].d)
			{
				f[y]=f[x]+b[k].d;
				q.push(nde(y,f[y]));
			}
		}
	}
}
struct node
{
	int x,d,f;
	node(){}
	node(int x,int d,int f):x(x),d(d),f(f){}
	bool operator <(const node a)const{return f==a.f?d>a.d:f>a.f;}
};
int kl;
void dijk_AS()
{
	priority_queue<node>q;int cnt=0;
	if(f[st]==inf){puts("-1");return ;}
	q.push(node(st,0,f[st]));
	while(!q.empty())
	{
		node t=q.top();q.pop();
		if(t.x==ed)cnt++;
		if(kl==cnt){printf("%d\n",t.d);return ;}
		int x=t.x;
		for(int k=last1[x];k;k=a[k].next)
		{
			int y=a[k].y;
			int d=t.d+a[k].d;
			q.push(node(y,d,d+f[y]));
		}
	}
	puts("-1");
}
int main()
{
	int n,m;len=0;
	scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){int x,y, d;scanf("%d%d%d",&x,&y,&d);ins(x,y,d);}
    scanf("%d%d%d",&st,&ed,&kl);if(st==ed)kl++;
    dijk_p();
    dijk_AS();
	return 0;
}