HDU4725 SPFA (最短路+层级建图)

---

---

问题描述
这是一个非常容易的问题，你的任务只是计算el camino mas corto en un grafico，而且只是单独干草阙cambiar un poco el algoritmo。如果你不理解这一段的话，那就继续吧。

Nya图是具有“层”的无向图。图中的每个节点都属于一个层，总共有N个节点。
您可以从层x中的任何节点移动到层x + 1中的任何节点，成本为C，因为道路是双向的，从层x + 1移动到层x也允许具有相同的成本。
此外，还有M个额外边缘，每个边缘连接一对节点u和v，成本为w。
帮助我们计算从节点1到节点N的最短路径。

输入
第一行的数字为T（T <= 20），表示测试用例的数量。
对于每个测试用例，第一行有三个数字N，M（0 <= N，M <= 105）和C（1 <= C <= 103），这是节点数，额外边数和成本在相邻层之间移动。
第二行有N个数字li（1 <= li <= N），这是第i个节点所属的层。
然后得到N行，每行有3个数字，u，v（1 <= u，v <= N，u <> v）和w（1 <= w <= 104），这意味着有一条额外的边，连接一个节点u和v对，成本为w。

产量
对于测试用例X，首先输出“Case #X：”，然后输出从节点1移动到节点N的最小成本。
如果没有解决方案，则输出-1。

样本输入
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

样本输出
案例＃1：2
案例＃2：3

---

---

---

如果是每个点向比他层级小一或大一的点连边的话，复杂度为n××2，所以说每层抽象一个点，每层的抽象出来的点先此层的点连边，以此就避免的枚举每个点的层数

坑点： 同层之间的点不连通

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <ctype.h>
#include <queue>
#include <stack>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <iostream>
#include <algorithm>
using namespace std;
#define pi acos(-1.0)
#define INF 0x3f3f3f3f
#define N 200017
int n, m, k, c;
int Edgehead[N], dis[N];
int vv[N], lay[N];
struct
{
    int v,w,next;
} Edge[20*N];
bool vis[N];
int cont[N];

void init()
{
    memset(Edgehead,0,sizeof(Edgehead));
    memset(vv,0,sizeof(vv));
}

void Addedge(int u,int v,int w)
{
    Edge[k].next = Edgehead[u];
    Edge[k].w = w;
    Edge[k].v = v;
    Edgehead[u] = k++;
}
int SPFA( int start)
{
    queue<int>Q;
    while(!Q.empty()) Q.pop();
    for(int i = 1 ; i <= N ; i++ )
        dis[i] = INF;
    dis[start] = 0;
    //++cont[start];
    memset(vis,false,sizeof(vis));
    vis[start] = 1;
    Q.push(start);
    while(!Q.empty())//直到队列为空
    {
        int u = Q.front();
        Q.pop();
        vis[u] = false;
        for(int i = Edgehead[u] ; i!=-1 ; i = Edge[i].next)//注意
        {
            int v = Edge[i].v;
            int w = Edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u]+w;
                if( !vis[v] )//防止出现环，也就是进队列重复了
                {
                    Q.push(v);
                    vis[v] = true;
                }
                //if(++cont[v] > n)//有负环
                //   return -1;
            }
        }
    }
    return dis[n];
}
int main()
{
    int u, v, w;
    int t;
    int cas = 0;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d%d",&n,&m,&c);
        k = 1;
        memset(Edgehead,-1,sizeof(Edgehead));

        for(int i = 1; i <= n; i++)
        {
            scanf("%d",&u);//i 在第u层
            lay[i] = u;
            vv[u] = 1;
        }

        for(int i = 1; i < n; i++)
        {
            if(vv[i] && vv[i+1])  //两层都出现过点相邻层才建边
            {
                Addedge(n+i,n+i+1,c);
                Addedge(n+i+1,n+i,c);
            }
        }

        for(int i = 1; i <= n; i++)  //层到点建边  点到相邻层建边
        {
            Addedge(n+lay[i],i,0);


            if(lay[i] > 1)
                Addedge(i,n+lay[i]-1,c);
            if(lay[i] < n)
                Addedge(i,n+lay[i]+1,c);
                

        }

        for(int i = 1 ; i <= m ; i++ )
        {
            scanf("%d%d%d",&u,&v,&w);
            Addedge(u,v,w);//双向链表
            Addedge(v,u,w);//双向链表
        }
        int s = SPFA(1);//从点1开始寻找最短路
        if(s == INF)
        {
            s = -1;
        }
        printf("Case #%d: %d
",++cas,s);
    }
    return 0;
}