HDU 4725 The Shortest Path in Nya Graph（SPFA）

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 5) and C(1 <= C <= 10 3), 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 4), 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个点，每个点都属于某层（每层不确定有几个点），相邻层之间移动需要花费c。第一行三个数n，m，c，表示n个点，m条边，相邻层移动花费为c，接下来n个数字，表示第i个数字属于第几层，接下来m行表示u到v有一条花费为vi的数。问从1到n花费最小为多少，若不通则输出-1。

题解：我们把第i层看作编号为n+i的点，把与该层与相邻层上的点连一条花费为c的边，把该层与该层上的点连一条花费为0的边（注意都是单向边），然后正常跑最短路就可以了。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=800000+10;
bool pd[maxn];
int a[maxn];
struct cc{
    int from,to,cost;
}es[maxn];
int first[maxn],nxt[maxn];
int tot=0;
void build(int ff,int tt,int pp)
{
    es[++tot]=(cc){ff,tt,pp};
    nxt[tot]=first[ff];
    first[ff]=tot;
}
int dis[maxn];
bool vis[maxn];
queue<int>q;
void spfa(int s)
{
    dis[s]=0;
    vis[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        vis[u]=0;
        for(int i=first[u];i;i=nxt[i])
        {
            int v=es[i].to;
            if(dis[v]>dis[u]+es[i].cost)
            {
                dis[v]=dis[u]+es[i].cost;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int k=1;k<=T;k++)
    {
        memset(pd,0,sizeof(pd));
        memset(first,0,sizeof(first));
        tot=0;
        int n,m,c;
        scanf("%d%d%d",&n,&m,&c);
        for(int i=1;i<=n;i++)
        {
            int x;
            scanf("%d",&x);
            pd[x]=1;//判断该层上是否有点
            a[i]=x;
        }
        for(int i=1;i<=n;i++)
        {
            build(n+a[i],i,0);//层上的点
            
            if(pd[a[i]-1])//上面有一层
            {
                build(i,n+a[i]-1,c);
            }
            if(pd[a[i]+1])//下面有一层
            {
                build(i,n+a[i]+1,c);
            }
        }
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            build(x,y,z);
            build(y,x,z);
        }
        memset(dis,63,sizeof(dis));
        spfa(1);
        printf("Case #%d: ",k);
        if(dis[n]!=dis[0])
        {
            printf("%d\n",dis[n]);
        }
        else
        {
            printf("-1\n");
        }
    }
    return 0;
}