The Shortest Path in Nya Graph HDU

题目链接：https://vjudge.net/problem/HDU-4725

题意：附上一张图吧，把题目的意思画出来，我本来是按照上面的图建图，以为层节点和层上的节点无向就OK了，然后看了别人的代码发现层结点和相邻的层的点都无向，

然后想到一个样例就是我上面图无法解决的，我把权值和走的边都标出来了，就比较形象，于是去了一行代码加上两行代码就可以过了。

核心思想就是把每层抽象为一个层节点，层节点到该层的所有点权值为0，就可以了，再加上“层结点和相邻的层的点都无向”，加上点之间的无向边就可以直接跑图了，

当然，因为点太多O（n^2）已经无法满足了，所有要dijkstra加上堆优化，使得复杂度降到O（nlogn）。

层节点放在（n + u）个节点上，代码有注释。

---

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <iomanip>
using namespace std;

typedef long long LL;
#define inf (1LL << 29) - 1
#define rep(i,j,k) for(int i = (j); i <= (k); i++)
#define rep__(i,j,k) for(int i = (j); i < (k); i++)
#define per(i,j,k) for(int i = (j); i >= (k); i--)
#define per__(i,j,k) for(int i = (j); i > (k); i--)

const int N = 100010 * 10;
int n,m,C;
int head[N];
int dis[N];//最短路数组
int app[N]; //存节点存在于第几层
bool vis[N];
int cnt;//链式前向星
struct Edge{

    int to;
    int next;
    int w;
}edge[N];

struct Node{
    int num;
    int W;

    bool friend operator<(Node a,Node b){
        return a.W > b.W;
    }
};

void add(int u,int v,int w){

    edge[cnt].to = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

//接下来直接是裸的（dijkstra + 优先队列优化）
void dijkstra(){

    rep(i,1,n + n) vis[i] = 0;
    rep(i,1,n + n) dis[i] = inf;

    priority_queue<Node> que;
    que.push(Node{1,0});
    dis[1] = 0;

    while(!que.empty()){

        Node tmp = que.top();   
        que.pop();
        int u = tmp.num;
        if(!vis[u]){
            vis[u] = true;

            for(int j = head[u]; ~j; j = edge[j].next){
                
                int v = edge[j].to;
                int w = edge[j].w;
                if(!vis[v] && dis[v] > dis[u] + w){
                    dis[v] = dis[u] + w;
                    que.push(Node{v,dis[v]});
                }
                    
            }
        }
    }
}

int main(){
    
    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;

    rep(p,1,T){

        cin >> n >> m >> C;

        rep(i,1,n + n) head[i] = -1;
        rep(i,1,n + n) app[i] = -1;
        cnt = 1;
        rep(i,1,n){ //第几个点
            int u;
            cin >> u; //属于第几层
            add(n + u,i,0); //第u层上加了到第i个点的边，权值为0
            // add(i,n + u,0);
            app[i] = u;
        }

        //相邻层点无向边权值为C
        rep__(i,n + 1,n + n){
            //相邻层都存在
            if(head[i] != -1 && head[i + 1] != -1){
                add(i,i + 1,C);
                add(i + 1,i,C);
            }              
        }

        //层节点和相邻层的节点进行无向
        rep(i,1,n){
            if(app[i] == -1) continue;
            //下面第二个判断，判断该层是否存在
            if(app[i] > 1) if(head[n + app[i] - 1] != -1) add(i,n + app[i] - 1,C);
            if(app[i] < n) if(head[n + app[i] + 1] != -1) add(i,n + app[i] + 1,C);
        }

        //点之间的无向边
        int u,v,w;
        rep(i,1,m){
        
            cin >> u >> v >> w;
            add(u,v,w);
            add(v,u,w);
        }


        dijkstra();
        cout << "Case #" << p << ": ";
        if(dis[n] == inf) cout << "-1" << endl;
        else cout << dis[n] << endl;
    }


    getchar();getchar();

    return 0;
}