【最短路 spaf】The Shortest Path in Nya Graph 神机建图

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.

InputThe 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.OutputFor 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个点，每个点属于一层（一层可以有多个点），求1到n点的最短距离

这题先自己来了一发，毫无疑问的wa了，看了别的代码，惊为天人；

思路：这题为层与层之间移动需要成本，点与点之间移动需要成本，所以建图层与层，层与点，点与点，具体看代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<math.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int N=100010;

int n,e;
int dis[N*2],mark[N*2];
int f[N*2];
int w[N*2];
int vis[N*2];
queue<int>que;

struct p
{
    int b,l,n;
} q[N*20];

void add(int u,int v,int w)
{
    q[e].b=v;
    q[e].l=w;
    q[e].n=f[u];
    f[u]=e++;
}

int spaf()
{
    int u,v,k;
    memset(mark,0,sizeof(mark));
    memset(dis,inf,sizeof(dis));
    dis[1]=0;
    while(!que.empty())
        que.pop();
    que.push(1);
    while(!que.empty())
    {
        u=que.front();
        que.pop();
        mark[u]=0;
        k=f[u];
        while(k!=-1)
        {
            v=q[k].b;
            if(dis[v]>dis[u]+q[k].l)
            {
                dis[v]=dis[u]+q[k].l;
                if(mark[v]==0)
                {
                    mark[v]=1;
                    que.push(v);
                }
            }
            k=q[k].n;
        }
    }
    return dis[n];
}

int main()
{
    int T,M=1;
    scanf("%d",&T);
    while(T--)
    {
        memset(vis,0,sizeof(vis));
        memset(f,-1,sizeof(f));
        int m,c,i,a,b,l,j,ans;
        e=0;
        scanf("%d %d %d",&n,&m,&c);
        for(i=1; i<=n; i++)
        {
            scanf("%d",&w[i]);
            vis[w[i]]=1;
        }
        for(i=1;i<n;i++)//层与层之间建边
        {
            if(vis[i]&&vis[i+1])
            {
                add(n+i,n+i+1,c);
                add(n+i+1,n+i,c);
            }
        }
        for(i=1;i<=n;i++)//层与点建边，点与相邻层建边
        {
            add(n+w[i],i,0);
            if(w[i]>1)
                add(i,n+w[i]-1,c);
            if(w[i]<n)
                add(i,n+w[i]+1,c);
        }
        for(i=0;i<m;i++)
        {
            scanf("%d %d %d",&a,&b,&l);
            add(a,b,l);
            add(b,a,l);
        }
        ans=spaf();
        if(ans==inf)
            ans=-1;
        printf("Case #%d: %d\n",M++,ans);
    }
    return 0;
}