ACM-ICPC2018 沈阳赛区网络预赛-D-Made In Heaven8

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 

One day in the jail, F·F invites Jolyne Kujo (JOJO in brief) to play tennis with her. However, Pucci the father somehow knows it and wants to stop her. There are NN spots in the jail and MM roads connecting some of the spots. JOJO finds that Pucci knows the route of the former (K-1)(K−1)-th shortest path. If Pucci spots JOJO in one of these K-1K−1 routes, Pucci will use his stand Whitesnake and put the disk into JOJO's body, which means JOJO won't be able to make it to the destination. So, JOJO needs to take the KK-th quickest path to get to the destination. What's more, JOJO only has TT units of time, so she needs to hurry.

JOJO starts from spot SS, and the destination is numbered EE. It is possible that JOJO's path contains any spot more than one time. Please tell JOJO whether she can make arrive at the destination using no more than TT units of time.

Input

There are at most 5050 test cases.

The first line contains two integers NN and MM (1 leq N leq 1000, 0 leq M leq 10000)(1≤N≤1000,0≤M≤10000). Stations are numbered from 11 to NN.

The second line contains four numbers S, E, KS,E,K and TT ( 1 leq S,E leq N1≤S,E≤N, S eq ES≠E, 1 leq K leq 100001≤K≤10000, 1 leq T leq 1000000001≤T≤100000000 ).

Then MM lines follows, each line containing three numbers U, VU,V and WW (1 leq U,V leq N, 1 leq W leq 1000)(1≤U,V≤N,1≤W≤1000) . It shows that there is a directed road from UU-th spot to VV-th spot with time WW.

It is guaranteed that for any two spots there will be only one directed road from spot AA to spot BB (1 leq A,B leq N, A eq B)(1≤A,B≤N,A≠B), but it is possible that both directed road <A,B><A,B> and directed road <B,A><B,A>exist.

All the test cases are generated randomly.

Output

One line containing a sentence. If it is possible for JOJO to arrive at the destination in time, output "yareyaredawa" (without quote), else output "Whitesnake!" (without quote).

样例输入

2 2

1 2 2 14

1 2 5

2 1 4

样例输出

yareyaredawa

#include <bits/stdc++.h>
using namespace std;
const int N=1005;
const int M=100005;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0' || ch>'9'){if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,sta,en,kth,T,Ecnt,Eoppcnt;
int dist[N];
int times[N];
bool vis[N];
struct Edge{
    int to,next,val;}E[M],Eopp[M];//Eopp means Eopposite
int last[N],last_opp[N];
struct A_Star_node{
    int p,g,h;
    bool operator < (A_Star_node x)const
    {
        return x.g+x.h<g+h;
    }
};//means point  and a_Star:f(x)=g(x)+h(x);
priority_queue<A_Star_node>Q;
inline void add(int u,int v,int w)
{
    Ecnt++;
    E[Ecnt].next=last[u];
    E[Ecnt].to=v;
    E[Ecnt].val=w;
    last[u]=Ecnt;
}
inline void add_opposite(int u,int v,int w)
{
    Eoppcnt++;
    Eopp[Eoppcnt].next=last_opp[u];
    Eopp[Eoppcnt].to=v;
    Eopp[Eoppcnt].val=w;
    last_opp[u]=Eoppcnt;
}
void dij(int s,int e)
{
    memset(vis,0,sizeof(vis));
    memset(dist,127,sizeof(dist));
    int mi;
    dist[e]=0;
    for (int i=1;i<=n;i++)
    {
        mi=0;
        for (int j=1;j<=n;j++)
            if (!vis[j] && dist[mi]>dist[j])    mi=j;
        vis[mi]=1;
        for (int x=last_opp[mi];x;x=Eopp[x].next)
            dist[Eopp[x].to]=min(dist[Eopp[x].to],dist[mi]+Eopp[x].val);
    }
}
int A_Star(int s,int e)
{
    A_Star_node t1,tmp;
    memset(times,0,sizeof(times));
    while (!Q.empty()) Q.pop();
    t1.g=t1.h=0; t1.p=s;
    Q.push(t1);
    while (!Q.empty())
    {
        t1=Q.top();    Q.pop();
        times[t1.p]++;
        if (times[t1.p]<=kth && t1.h>T) return -1;//K短路之前的路已经比要求的时间长了，一定是不合法的方案
        if (times[t1.p]==kth && t1.p==e) return t1.h;
        if (times[t1.p]>kth) continue;
        for (int i=last[t1.p];i;i=E[i].next)
        {
            tmp.p=E[i].to;
            tmp.g=dist[E[i].to];
            tmp.h=E[i].val+t1.h;
            Q.push(tmp);
        }
    }
    return -1;
}
int main()
{
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        sta=read(); en=read(); kth=read(); T=read();
        int x,y,z;
        memset(last,0,sizeof(last));
        memset(last_opp,0,sizeof(last_opp));
        Ecnt=0;
        Eoppcnt=0;
        while (m--)
        {
            x=read(); y=read(); z=read();
            add(x,y,z);
            add_opposite(y,x,z);
        }
        dij(sta,en);
        if (sta==en) kth++;
        int ans=A_Star(sta,en);
        if (ans==-1||ans>T) puts("Whitesnake!");
        else puts("yareyaredawa");
    }
    return 0;
}