DIJ最短路 - The Shortest Path in Nya Graph HDU - 4725

DIJ最短路 - The Shortest Path in Nya Graph HDU - 4725

题意：

$给定n个点(编号从1到n)，每个点所在的层次为l_i，相邻层次之间有一条权值为C的无向边，$

$另有m条额外的无向边(u,v,w)。$

$求从1号点到n号点的最短距离。$

$T组测试数据。$

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

数据范围：

$T\le 20，0\le n,m\le 10^5，1\le C\le 10^3，1\le u,v\le n，1\le w\le 10^4，1\le i\le n$

分析：

$本题难点在于建图。$

$如果我们将每一层的结点都存储下来，然后遍历每一层，将相邻两层之间的结点两两连接一条边，$

$若n个结点平均分布在两层，那么这样建图的复杂度将达到O(n^2)，在本题是不允许的。$

$这里采用建立一个虚{拟}^{\prime \prime }层结{点}^{\prime \prime }，来解决这个问题：$

$相邻层之间所有的点通过一{个}^{\prime \prime }层结{点}^{\prime \prime }建立连接，$

$我们对于l_i层，建立一个虚拟的结点V_i，它相当于l_i层的入口，$

$V_i与l_i层内的所有结点建立一条有向边，权值为0，$

$相邻层(l_i\pm 1层)的所有结点与V_i建立一条有向边，即通过V_i进入到l_i层，权值设置为C.$

$这样，我们就能够建出此图。$

复杂度分析：

$n个结点分布在k个不同的层次，那么一共就有n+k个结点，$

$①、每个结点需要与层结点建立一条从层结点指出的有向边，共需要建立n条边，$

$②、每个结点需要与相邻的两个层结点(最上层与最下层只有一个层结点)建立一条进入层结点的有向边，$

$假设每一层的结点数量为cn{t}_i，共需要建立{\sum }_{i=1}^{k}2\times cn{t}_i=2{\sum }_{i=1}^{k}cn{t}_i=2n条边$

$③、m条无向边，共需要建立2m条边。$

$故复杂度为O(3n+2m)，因此边的数量上限为5\times 10^5。在这里T了很多发。$

另外： $多测注意清空邻接表指针。$

代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>

#define x first
#define y second

using namespace std;

const int N = 200010, M = 500010, inf = 0x3f3f3f3f;
typedef pair<int, int> P;

int n, m, C;
int e[M], ne[M], w[M], h[N], idx;
int dis[N];
bool st[N];
vector<int> l[N];

void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

int dijkstra()
{
    priority_queue<P, vector<P>, greater<P> > heap;
    dis[1] = 0;
    heap.push(make_pair(0, 1));
    
    while(heap.size())
    {
        P t = heap.top();
        heap.pop();
        
        int u = t.y;
        if(st[u]) continue;
        st[u] = true;
        
        for(int i = h[u]; ~i; i = ne[i])
        {
            int j = e[i];
            if(dis[j] > dis[u] + w[i])
            {
                dis[j] = dis[u] + w[i];
                heap.push(make_pair(dis[j], j));
            }
        }
    }
    return dis[n] == inf ? -1 : dis[n];
}

void cls()
{
    idx = 0;
    memset(l, 0, sizeof l);
    memset(h, -1, sizeof h);
    memset(st, 0, sizeof st);
    memset(dis, 0x3f, sizeof dis);
}

int main()
{
    int T;
    scanf("%d", &T);
    for(int t = 1; t <= T; t++)
    {
        cls();  //多测
        scanf("%d%d%d", &n, &m, &C);
        
        int layers;
        for(int i=1;i<=n;i++) 
        {
            scanf("%d", &layers);
            l[layers].push_back(i);
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<l[i].size();j++)
            {
                add(i+n, l[i][j], 0);   //层结点
                if(l[i+1].size()) add(l[i][j], i+1+n, C);
                if(l[i-1].size()) add(l[i][j], i-1+n, C);
            }
        }

        int a, b, c;
        while(m--)
        {
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, c), add(b, a, c);
        }
        printf("Case #%d: %d\n", t, dijkstra());
    }
    
    return 0;
}