HDU 4725 建图

http://acm.hdu.edu.cn/showproblem.php?pid=4725

The Shortest Path in Nya Graph

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7869    Accepted Submission(s): 1766

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

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

 

Source

一开始无脑暴力建 N1*N2的图，后来超时后才发现，如果层数稀疏，点数密集的话建的边数上亿，肯定要超时的，我们想办法巧妙地建图。

把每一层看做是一个点，通过点->层->点的连接从而实现层与层的连接，可以少建许多边，但我第一次没考虑周到，让点与对应的层建立了双向边，这是致命的，，

因为每一层的点之间距离并非是0，这样构图的话每一层得点相互之间都能0距离显然是错误的。

考虑建单向边，让每一层向层上的点建一条0边，然后对于每个点，向与其相邻且存在的层建立一条权值为C的边，这样就符合了题意。

spfa和dij都写了感觉复杂度差不多，但是第一次建图错误时spfa提示TLE，dij返回WA不知道是否说明dij快点- -反正二者AC的时间差不大多

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
inline int read()
{
    int r=0;  char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) {r=r*10+c-'0';c=getchar();}
    return r;
}
struct Edge
{
    int to,w,next;
}e[600005];
int cnt,first[200005];
void add(int u,int v,int w)
{
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=first[u];
    first[u]=cnt++;
}
struct node
{
    int u,w;
    bool operator<(const node &x)const{
    return w>x.w;
    }
};
int d[200005];
int dij(int N)
{
    bool vis[200005];
    priority_queue<node>Q;
    memset(vis,0,sizeof(vis));
    memset(d,inf,sizeof(d));
    d[1]=0;
    Q.push(node{1,0});
    while(!Q.empty()){
        node t1=Q.top();Q.pop();
        int u=t1.u;
        if(vis[u]) continue;
        vis[u]=1;
        if(u==N) break;
        for(int i=first[u];i+1;i=e[i].next){
            Edge x=e[i];
            if(!vis[x.to]&&d[x.to]>d[u]+x.w){
                d[x.to]=d[u]+x.w;
                Q.push(node{x.to,d[x.to]});
            }
        }
    }
    return d[N]==inf?-1:d[N];
}
int spfa(int N)
{
    bool vis[200005];
    queue<int>Q;
    memset(vis,0,sizeof(vis));
    memset(d,inf,sizeof(d));
    Q.push(1);
    vis[1]=1;
    d[1]=0;
    while(!Q.empty()){
        int u=Q.front(); Q.pop();
        vis[u]=0;
        for(int i=first[u];i+1;i=e[i].next){
            Edge x=e[i];
            if(d[x.to]>d[u]+x.w){
                d[x.to]=d[u]+x.w;
                if(!vis[x.to]){
                    Q.push(x.to);
                }
            }
        }
    }
    return d[N]==inf?-1:d[N];
}
int main()
{
    //ios::sync_with_stdio(false);
    int T,N,M,C,i,j,k=0;
    int u,v,w,x[100005];
    bool layer[100005];
   #ifndef ONLINE_JUDGE
   freopen("in.txt","r",stdin);
   #endif
    T=read();
    for(int cas=1;cas<=T;++cas)
    {
        cnt=0;
        memset(first,-1,sizeof(first));
        memset(layer,0,sizeof(layer));
        cin>>N>>M>>C;
        for(i=1;i<=N;++i)
        {
            x[i]=read();
            layer[x[i]]=1;
        }
       for(i=1;i<=N;++i)
        {
            add(x[i]+N,i,0);
            add(i,x[i]+N,0);
            if(x[i]>1&&layer[x[i]-1])
                add(i,x[i]+N-1,C);
            if(x[i]<N&&layer[x[i]+1])
                add(i,x[i]+N+1,C);
        }
        while(M--){
        scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            add(v,u,w);
        }
        printf("Case #%d: %d
",cas,dij(N)/*spfa(N)*/);
    }
    return 0;
}