HDU 4725 The Shortest Path in Nya Graph

题意：有n个点，他们属于（1~n）中的某些层,相邻层的费用为c，并且只能相邻层才能相互到达，意思是如果这层没有点，此层的上层的点就不能到达此层的下层点，有m条额外的双向边（u，v）。问（1->n）最短的距离。

分析：

这道题重在建图。首先应该想到，把层作为一个点（我们用(n-2*n)的点表示层），属于此层的点与它的距离为0，层与层距离为c，额外边直接加就行。建完这个图，我们会发现，在同一层的距离始终为0，而事实上，同一层的点并没连通。所以这样建图肯定是错的，那么我们接下来就解决这个问题。

两种方法：

法一：我们把拆出来的表示层的点再拆成两个点。第i层的用相邻两个点表示为 n+2*i-1,和n+2*i，设为u,v。我们把u作为这层的入口，v作为这层的出口（相对于某点的入口出口）。那么假设,x,y都属于这层，我们建边add(x,u,0),add(v,x,0);  add(y,u,0),add(v,y,0)。这样建图会发现，x,y虽然属于同一层，但是他们是不能到达的。

那么层与层之间的关系怎么表示呢？设i层入口,出口为ui，vi,    i+1层为uj,vj .我们加边 add(ui,vj,c);add(uj,vi,c)  

意思就是，此层的点距相邻层的点为c,那么我们可以通过此层的入口通完下层的出口，找到该点。（自己画一下就明白了）。

由于拆出来了2个点，总共就有3n个点，如果用SPFA,O(km)的复杂度，k为点的入队平均次数，还有t组测试样例，会超时。用优先队列优化的dij 就行了。他的复杂度为mlogm。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 300005
#define LL long long
#define INF 0x3f7f7f7f
struct node
{
    int en,len,next;
    node(int en=0,int len=0,int next=0):
        en(en),len(len),next(next){}
    friend bool operator<(node x,node y)
    {
        return x.len>y.len;
    }
};
struct node Edge[MAXN*5];
int p[MAXN],num,n,m,c;
int l[MAXN];
int dis[MAXN],vis[MAXN];
void init()
{
    for(int i=0;i<=3*n;i++)
    {
        p[i]=-1;
    }
    num=0;
}
void add(int st,int en,int len)
{
    Edge[num].en=en;
    Edge[num].len=len;
    Edge[num].next=p[st];
    p[st]=num++;
}
void dij(int st,int en)
{
    int i;
    for(i=1;i<=n*3;i++)
    {
        dis[i]=INF;
        vis[i]=0;
    }
    priority_queue<node>q;
    q.push(node(st,0));
    dis[st]=0;
    while(!q.empty())
    {
        node tx=q.top();
        q.pop();
        int id=tx.en;
        if(vis[id])continue;
        vis[id]=1;
        for(i=p[id];i!=-1;i=Edge[i].next)
        {
            int en=Edge[i].en;
            int len=Edge[i].len;
            if(!vis[en]&&dis[en]>dis[id]+len)
            {
                dis[en]=dis[id]+len;
                q.push(node(en,dis[en]));
            }
        }
    }
    if(dis[en]==INF)puts("-1");
    else printf("%d\n",dis[en]);
}
int main()
{
    int i,t,cas;
    scanf("%d",&t);
    for(cas=1;cas<=t;cas++)
    {
        scanf("%d%d%d",&n,&m,&c);
        init();
        for(i=1;i<=n;i++)
        {
            scanf("%d",&l[i]);
          //  vis[l[i]]=1;//标记此层有无点
            add(i,n+2*l[i]-1,0);//i点属于此层，此层的入口为n+2*l[i]-1
            add(n+2*l[i],i,0);//出口为n+2*l[i]，
        }
        for(i=1;i<n;i++)
        {
            add(n+2*i-1,n+2*(i+1),c);//层与层的联系
            add(n+2*(i+1)-1,n+2*i,c);
        }
        for(i=1;i<=m;i++)
        {
            int u,v,len;
            scanf("%d%d%d",&u,&v,&len);
            add(u,v,len);
            add(v,u,len);
        }
        printf("Case #%d: ",cas);
        dij(1,n);
    }
    return 0;
}

法二：基于最初的思想，我们只拆n个点出来作为层，为了避免同一层的点距离为0的情况。我们只加一条边add(n+li,i,0);表示通过li层可以找到i点。那么i点怎么表示与相邻层的关系呢，我们再加边，add(i,n+li+1,c)。

add(i,n+li-1,c);表示i可以到相邻层找其他点，距离为c。接下来可以用优先队列DIJ直接过。用SPFA还需要优化。

就是这一层如果没有点就不加边，尽量少加边。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 200005//只有2*n个点
#define LL long long
#define INF 0x3f7f7f7f
struct node
{
    int en,len,next;
    node(int en=0,int len=0,int next=0):
        en(en),len(len),next(next){}
};
struct node Edge[MAXN*5];
int p[MAXN],num,n,m,c;
int l[MAXN];
int dis[MAXN],vis[MAXN];
void init()
{
    for(int i=0;i<=2*n;i++)
    {
        p[i]=-1;
        vis[i]=0;
    }
    num=0;
}
void add(int st,int en,int len)
{
    Edge[num].en=en;
    Edge[num].len=len;
    Edge[num].next=p[st];
    p[st]=num++;
}
void spfa(int st,int en)
{
    int i;
    for(i=1;i<=n*2;i++)
    {
        dis[i]=INF;
        vis[i]=0;
    }
    queue<int>q;
    q.push(st);
    dis[st]=0;
    vis[st]=1;
    while(!q.empty())
    {
        int id =q.front();
        q.pop();
        vis[id]=0;
        for(i=p[id];i!=-1;i=Edge[i].next)
        {
            int en=Edge[i].en;
            int len=Edge[i].len;
            if(dis[en]>dis[id]+len)
            {
                dis[en]=dis[id]+len;
                if(!vis[en])
                {
                    vis[en]=1;
                    q.push(en);
                }

            }
        }
    }
    if(dis[en]==INF)puts("-1");
    else printf("%d\n",dis[en]);
}
int main()
{
    int i,t,cas;
    scanf("%d",&t);
    for(cas=1;cas<=t;cas++)
    {
        scanf("%d%d%d",&n,&m,&c);
        init();
        for(i=1;i<=n;i++)
        {
            scanf("%d",&l[i]);
            vis[l[i]]=1;
            add(n+l[i],i,0);//层到i点
        }
        for(i=1;i<=n;i++)
        {
            if(l[i]!=n&&vis[l[i]+1])
                add(i,n+l[i]+1,c);//点到相邻层
            if(l[i]!=1&&vis[l[i]-1])
                add(i,n+l[i]-1,c);
        }
        for(i=1;i<=m;i++)
        {
            int u,v,len;
            scanf("%d%d%d",&u,&v,&len);
            add(u,v,len);
            add(v,u,len);
        }
        printf("Case #%d: ",cas);
        spfa(1,n);
    }
    return 0;
}