The Shortest Path in Nya Graph HDU

Problem Description

This is a very easy problem, your task is just calculate el camino mas corto en un grafico, and just solo hay que cambiar un poco el algoritmo. If you do not understand a word of this paragraph, just move on.
The Nya graph is an undirected graph with "layers". Each node in the graph belongs to a layer, there are N nodes in total.
You can move from any node in layer x to any node in layer x + 1, with cost C, since the roads are bi-directional, moving from layer x + 1 to layer x is also allowed with the same cost.
Besides, there are M extra edges, each connecting a pair of node u and v, with cost w.
Help us calculate the shortest path from node 1 to node N.

 

Input

The first line has a number T (T <= 20) , indicating the number of test cases.
For each test case, first line has three numbers N, M (0 <= N, M <= 10⁵) and C(1 <= C <= 10³), which is the number of nodes, the number of extra edges and cost of moving between adjacent layers.
The second line has N numbers l_i (1 <= l_i <= N), which is the layer of i^th node belong to.
Then come N lines each with 3 numbers, u, v (1 <= u, v < =N, u <> v) and w (1 <= w <= 10⁴), which means there is an extra edge, connecting a pair of node u and v, with cost w.

 

Output

For test case X, output "Case #X: " first, then output the minimum cost moving from node 1 to node N.
If there are no solutions, output -1.

 

Sample Input

2 3 3 3 1 3 2 1 2 1 2 3 1 1 3 3 3 3 3 1 3 2 1 2 2 2 3 2 1 3 4

 

Sample Output

Case #1: 2

Case #2: 3

 

n个点，m条边，以及相邻层之间移动的代价c，给出每个点所在的层数，以及m条边，

每条边有u，v，c，表示从节点u到v（无向），并且移动的代价 c ，

问说从 1 到 n 的代价最小是多少。

将层抽象出来成为n个点（对应编号依次为n+1 ~ n+n），

然后层与层建边，点与点建边

，层与在该层上的点建边 （边长为0），点与相邻层建边 （边长为c）。

 

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>
#include <set>
#include <iostream>
#include <map>
#include <stack>
#include <string>
#include <vector>
#define  pi acos(-1.0)
#define  eps 1e-6
#define  fi first
#define  se second
#define  lson l,m,rt<<1
#define  rson m+1,r,rt<<1|1
#define  bug         printf("******
")
#define  mem(a,b)    memset(a,b,sizeof(a))
#define  fuck(x)     cout<<"["<<x<<"]"<<endl
#define  sf(n)       scanf("%d", &n)
#define  sff(a,b)    scanf("%d %d", &a, &b)
#define  sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
#define  sffff(a,b,c,d) scanf("%d %d %d %d", &a, &b, &c, &d)
#define  pf          printf
#define  FRE(i,a,b)  for(i = a; i <= b; i++)
#define  FREE(i,a,b) for(i = a; i >= b; i--)
#define  FRL(i,a,b)  for(i = a; i < b; i++)
#define  FRLL(i,a,b) for(i = a; i > b; i--)
#define  FIN freopen("DATA.txt","r",stdin)
#define  gcd(a,b) __gcd(a,b)
#define  lowbit(x)   x&-x
#pragma  comment (linker,"/STACK:102400000,102400000")
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 0x7fffffff;
const int maxn = 2e5 + 10;
int cas = 1, t, n, m, c, lv[maxn], have[maxn];
int tot, head[maxn], d[maxn], vis[maxn];
struct Edge {
    int v, w, nxt;
} edge[maxn*10];
struct node {
    int v, d;
    node(int v, int d) : v(v), d(d) {}
    bool operator < (const node & a) const {
        return d > a.d;
    }
};
void init() {
    tot = 0;
    mem(head, -1);
}
void add(int u, int v, int w) {
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].nxt = head[u];
    head[u] = tot++;
}
int dijkstra(int st, int ed) {
    mem(vis, 0);
    for (int i = 0 ; i < maxn ; i++) d[i] = INF;
    priority_queue<node>q;
    d[st] = 0;
    q.push(node(st, d[st]));
    while(!q.empty()) {
        node temp = q.top();
        q.pop();
        int u = temp.v;
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = head[u] ; ~i ; i = edge[i].nxt) {
            int v = edge[i].v, w = edge[i].w;
            if (d[v] > d[u] + w && !vis[v]) {
                d[v] = d[u] + w;
                q.push(node(v, d[v]));
            }
        }
    }
    return  d[ed];
}
int  main() {
    sf(t);
    while(t--) {
        sfff(n, m, c);
        init();
        mem(have, 0);
        mem(lv,0);
        for (int i = 1 ; i <= n ; i++) {
            sf(lv[i]);
            have[lv[i]] = 1;
        }
        for (int i = 1 ; i <= m ; i++) {
            int u, v, w;
            sfff(u, v, w);
            add(u, v, w);
            add(v, u, w);
        }
        for (int i = 1 ; i < n ; i++)
            if (have[i] && have[i + 1]) {
                add(n + i, n + i + 1, c);
                add(n + i + 1, n + i, c);
            }
        for (int i = 1 ; i <= n ; i++) {
            add(lv[i] + n, i, 0);
            if (lv[i] > 1) add(i, lv[i] + n - 1, c);
            if (lv[i] < n) add(i, lv[i] + n + 1, c);
        }
        int ans = dijkstra(1, n);
        if (ans == INF) printf("Case #%d: -1
", cas++);
        else printf("Case #%d: %d
", cas++, ans);
    }
    return 0;
}