第k短路 (A*算法）

A*算法：
A*，启发式搜索，是一种较为有效的搜索方法。
我们在搜索的时候，很多时候在当前状态，已经不是最优解了，但是我们却继续求解；这个就是暴力搜索浪费时间的原因。
我们在有些时候，往往可以根据一些信息推断出继续搜索是一种劣解。
所以如果能够判断出来的话，就可以不继续了，以达到节省运行时间的目的。

估价函数：
为了提高搜索效率，我们可以对未来可能产生的代价进行预估。我们设计一个估价函数，以任意状态输入，计算出从该状态到目标状态所需代价的估计值。
在搜索时，我们总沿着当前代价+未来估价最小的状态进行搜索。

估价函数需要满足：
　　设当前状态state到目标函数所需代价的估计值为f(state)
　　设在未来的搜索中，实际求出的从当前状态state到目标状态的最小代价为g(state)
　　对于任意的state，应该有f(state)<=g(state)
也就是说，估价函数的估值不能大于未来实际代价，估价比实际代价更优。

第K短路：
根据估价函数的设计准则，在第K短路中从x到T的估计距离f(x)应该不大于第K短路中从x到T的实际距离g(x)，于是，我们可以把估价函数f(x)定为从x到T的最短路径长度，这样不但能保证f(x)<=g(x)，还能顺应g(x)的实际变化趋势。
实现过程：
1.预处理f(x)，在反向图上以T为起点求到每个点的最短路
2.定义堆，维护{p,g,h}，p是某一个点，g是估价，h是实际，那么g+h更小的点p会优先访问
3.取出堆顶元素u扩展，如果节点v被取出的次数尚未达到k，就把新的{v,g,h+length(u,v)}插入堆中
4.重复第2-3步，直到第K次取出终点T，此时走过的路径长度就是第K短路

因为估价函数的作用，图中很多节点访问次数远小于K

我们定义一个评估值f(x)=g(x)+h(x)（例如求k短路中g(x)表示已经走了多远，h(x)表示从这个点到终点的最短路）f(x)越小就意味着越好咯，我们每次都去寻找最小的f(x)来进行操作，那不就很妙了

那k短路怎么求呢 
我们就先求出每个点到终点的最短路——把图反过来..从t做最短路【捂脸】 这样就求出来了h(x) 
然后就..每次做一个点，然后…求一个f(x)，扔进优先队列里.. 
最后t出现k次也就可以了

模板：

#include
using namespace std;

#define ee exp(1)
#define pi acos(-1)
#define mod 1000000007
#define inf 0x3f3f3f3f
#define ll long long
#define ull unsigned long long
#define mem(a,b) memset(a,b,sizeof(a))
int gcd(int a,int b){return b?gcd(b,a%b):a;}

const int maxn=1e6+5;
int n,m,s,t,k,r,cnt,p1,p2,head1[maxn],head2[maxn],vis[maxn];
ll d[maxn];
struct node{
	int to,w,next;
}e1[maxn],e2[maxn];
struct qnode{
	int v;ll w;
	qnode(int v,ll w):v(v),w(w) {}
	friend bool operator < (qnode x,qnode y)
	{
		return x.w+d[x.v]>y.w+d[y.v];
	}
};
void add1(int u,int v,int w)
{
	e1[++p1].to=v;e1[p1].w=w;e1[p1].next=head1[u];head1[u]=p1;
}
void add2(int u,int v,int w)
{
	e2[++p2].to=v;e2[p2].w=w;e2[p2].next=head2[u];head2[u]=p2;
}
void spfa()//反向图，t到其他点的距离 
{
	queue q;
	q.push(t);
	for(int i=1; i<=n; i++)d[i]=inf;
	mem(vis,0);
	d[t]=0;
	vis[t]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop();
		vis[u]=0;
		for(int i=head1[u]; i; i=e1[i].next)
		{
			int v=e1[i].to;
			int w=e1[i].w;
			if(d[v]>d[u]+w)
			{
				d[v]=d[u]+w;
				if(!vis[v])
				{
					vis[v]=1;
					q.push(v);
				}
			}
		}
	}
}

ll astar()//A*算法 
{
	if(d[s]==inf)return -1;
	
	priority_queue pe;
	pe.push(qnode(s,0));
	cnt=0;
	while(!pe.empty())
	{
		qnode u=pe.top();pe.pop();
		
		if(u.v==t)
		{
			cnt++;
			if(cnt==k)return u.w;
		}
		for(int i=head2[u.v]; i; i=e2[i].next)
		{
			int v=e2[i].to;
			pe.push(qnode(v,u.w+e2[i].w));
		}
	}
	return -1;
}

int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		mem(head1,0);p1=0;
		mem(head2,0);p2=0;
		scanf("%d%d%d%d",&s,&t,&k,&r);
		while(m--)
		{
			int u,v,w;scanf("%d%d%d",&u,&v,&w);
			add1(v,u,w);//反向图 
			add2(u,v,w);
		}
		spfa();
		ll ans=astar();
		if(ans==-1||ans>r)puts("Whitesnake!");
		else puts("yareyaredawa");
	}
	return 0;
}