沈阳网络赛D-Made In Heaven【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 \neq 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 \neq 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

题目来源

ACM-ICPC 2018 沈阳赛区网络预赛

 

题意：

给定有向图 找到从s到e的k短路 若k短路小于t 则输出yareyaredawa否则输出Whitesnake!

思路：

k短路模板题

学习了一下k短路

 

k短路 =  单源点最短路跑反向边 + 高级搜索A*

A*算法结合了启发式方法和形式化方法;
启发式方法通过充分利用图给出的信息来动态地做出决定而使搜索次数大大降低;
形式化方法不利用图给出的信息,而仅通过数学的形式分析;

算法通过一个估价函数f(h)来估计图中的当前点p到终点的距离,并由此决定它的搜索方向;
当这条路径失败时,它会尝试其他路径;
对于A*,估价函数=当前值+当前位置到终点的距离,即f(p)=g(p)+h(p),每次扩展估价函数值最小的一个;

对于K短路算法来说,g(p)为当前从s到p所走的路径的长度;h(p)为点p到t的最短路的长度;
f(p)的意义为从s按照当前路径走到p后再走到终点t一共至少要走多远;

为了加速计算,h(p)需要在A*搜索之前进行预处理, 因为本题是有向图，所以将原图的所有边反向,再从终点t做一次单源点最短路径就能得到每个点的h(p)了;

算法步骤：
(1),将有向图的所有边反向,以原终点t为源点,求解t到所有点的最短距离;
(2),新建一个优先队列,将源点s加入到队列中;
(3),从优先级队列中弹出f(p)最小的点p,如果点p就是t,则计算t出队的次数;
如果当前为t的第k次出队,则当前路径的长度就是s到t的第k短路的长度,算法结束;
否则遍历与p相连的所有的边,将扩展出的到p的邻接点信息加入到优先级队列;

 

注意，k短路可能不存在

// ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

//#include "pch.h"
#include <iostream>
#include<algorithm>
#include<stdio.h>
#include<set>
#include<cmath>
#include<cstring>
#include<map>
#include<vector>
#include<queue>
#include<stack>

#define inf 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int maxn = 1005;
const int maxm = 100005;
int n, m, s, ed, k, t;
struct edge {
    int u, v;
    int cost;
    int nxt;
}e[maxm], une[maxm];
int head[maxn], unhead[maxn], cnt, uncnt;
int dis[maxn];
bool vis[maxn];
struct node{
    int point;
    int g, f;
    friend bool operator < (node a, node b){
        return a.f == b.f?a.g>b.g:a.f>b.f;
    }
};

void init()
{
    cnt = 0;
    uncnt = 0;
    memset(dis, inf, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(head, -1, sizeof(head));
    memset(unhead, -1, sizeof(unhead));
}

void addedge(int u, int v, int w)
{
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].cost = w;
    e[cnt].nxt = head[u];
    head[u] = cnt++;
    une[uncnt].u = v;
    une[uncnt].v = u;
    une[uncnt].cost = w;
    une[uncnt].nxt = unhead[v];
    unhead[v] = uncnt++;
}

void spfa(int e)
{
    vis[e] = 1;
    dis[e] = 0;
    queue<int>que;
    que.push(e);
    while(!que.empty()){
        int u = que.front();
        que.pop();
        vis[u] = 0;
        for(int i = unhead[u]; i != -1; i = une[i].nxt){
            int tmp = dis[u] + une[i].cost;
            if(tmp < dis[une[i].v]){
                dis[une[i].v] = tmp;
                if(!vis[une[i].v]){
                    vis[une[i].v] = true;
                    que.push(une[i].v);
                }
            }
        }
    }
}

int A_star(int s, int ed)
{
    priority_queue<node>que;
    int shortest = 0;
    if(s == ed){
        k++;
    }
    if(dis[s] == inf){
        return -1;
    }
    node node0;
    node0.point = s;
    node0.g = 0;
    node0.f = dis[s] + node0.g;
    que.push(node0);
    while(!que.empty()){
        node0 = que.top();
        que.pop();
        if(node0.point == ed){
            shortest++;
            if(shortest == k){
                return node0.g;
            }
        }
        

        for(int i = head[node0.point]; i != -1; i = e[i].nxt){
            node tmp;
            tmp.point = e[i].v;
            tmp.g = node0.g + e[i].cost;
            tmp.f = tmp.g + dis[tmp.point];
            que.push(tmp);
        }
    }
    return -1;
}

int main()
{
    while(scanf("%d%d", &n, &m) != EOF){
        init();
        scanf("%d%d%d%d", &s, &ed, &k, &t);
        for(int i = 0; i < m; i++){
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            addedge(u, v, w);
        }

        spfa(ed);
        int kth = A_star(s, ed);
        if(kth <= t && kth != -1){
            printf("yareyaredawa\n");
        }
        else{
            printf("Whitesnake!\n");
        }
    }

    return 0;
}