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

 

Sample Output

#include<set>

#include<map>

#include<queue>

#include<stack>

#include<cmath>

#include<string>

#include<time.h>

#include<vector>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define INF 1000000001

#define ll long long

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

using namespace std;

const int MAXN = ;

struct node

{

    int to;

    int val;

    int next;

}edge[MAXN * ];

int pre[MAXN*],vis[MAXN*],dis[MAXN*],n,m,k,c,ind;

int num[MAXN],ok[MAXN];

void add(int x,int y,int z)

{

    edge[ind].to = y;

    edge[ind].val = z;

    edge[ind].next = pre[x];

    pre[x] = ind ++;

}

struct Node

{

    int p;

    ll val;

    Node(){}

    Node(int fp,int fval):p(fp),val(fval){}

    friend bool operator < (Node fa,Node fb){

        return fa.val > fb.val;

    }

};

void dij(int s)

{

    priority_queue<Node>fq;

    for(int i = ; i <= k; i++){

        dis[i] = INF;

        vis[i] = ;

    }

    dis[s] = ;

    fq.push(Node(s,));

    while(!fq.empty()){

        Node tp = fq.top();

        fq.pop();

        vis[tp.p] = ;

        for(int i = pre[tp.p]; i != -; i = edge[i].next){

            int t = edge[i].to;

            if(!vis[t] && dis[t] > dis[tp.p] + edge[i].val){

                dis[t] = dis[tp.p] + edge[i].val;

                fq.push(Node(t,dis[t]));

            }

        }

    }

}

int main()

{

    int t,ff = ;

    scanf("%d",&t);

    while(t--){

        memset(num,,sizeof(num));

        memset(ok,,sizeof(ok));

        scanf("%d%d%d",&n,&m,&c);

        int x;

        ind = ;

        memset(pre,-,sizeof(pre));

        for(int i = ; i <= n; i++){

            scanf("%d",&x);

            ok[x] = ;

            num[i] = x;

        }

        for(int i = ; i <= n; i++){//点与集合之间连边

            add(n+num[i],i,);

            if(num[i] > )add(i,n+num[i]-,c);

            if(num[i] < n)add(i,n+num[i]+,c);

        }

        int y,z;

        for(int i = ; i <= m; i++){

            scanf("%d%d%d",&x,&y,&z);

            add(x,y,z);

            add(y,x,z);

        }

        //cout<<k<<endl;

        k =  * n;

        dij();

        printf("Case #%d: ",++ff);

        if(dis[n] >= INF){

            printf("-1\n");

        }

        else {

            printf("%d\n",dis[n]);

        }

    }

    return ;

}