HYSBZ - 2763 飞行路线（分层图最短路）

Alice和Bob现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在n个城市设有业务，设这些城市分别标记为0到n-1，一共有m种航线，每种航线连接两个城市，并且航线有一定的价格。Alice和Bob现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多k种航线上搭乘飞机。那么Alice和Bob这次出行最少花费多少？

Input

数据的第一行有三个整数，n,m,k，分别表示城市数，航线数和免费乘坐次数。

第二行有两个整数，s,t，分别表示他们出行的起点城市编号和终点城市编号。(0<=s,t<n)

接下来有m行，每行三个整数，a,b,c，表示存在一种航线，能从城市a到达城市b，或从城市b到达城市a，价格为c。(0<=a,b<n,a与b不相等，0<=c<=1000)

 

Output

 

只有一行，包含一个整数，为最少花费。

Sample Input

5 6 1 0 4 0 1 5 1 2 5 2 3 5 3 4 5 2 3 3 0 2 100

Sample Output

8

Hint

 

对于30%的数据,2<=n<=50,1<=m<=300,k=0;

 

对于50%的数据,2<=n<=600,1<=m<=6000,0<=k<=1;

 

对于100%的数据,2<=n<=10000,1<=m<=50000,0<=k<=10.

---

解题思路：分层图最短路   dis[i][j]代表i点在使用j次无效化路径后的最短路  判断条件为两个 不使用无效化时松弛边 使用无效化时松弛的边

---

#include <bits/stdc++.h>
#define met(a, b) memset(a, b, sizeof(a))
const int MAXN = 1e4 + 10;
using namespace std;

struct Dijkstra
{
    typedef struct EdgeNode
    {
        int to, val, next;
        EdgeNode(int _to, int _val, int _next) { to = _to, val = _val, next = _next; }
    }edges;
    typedef struct HeapNode
    {
        int now, high, val;
        HeapNode(int _now, int _high, int _val) { now = _now, high = _high, val = _val; }
        bool operator < (const HeapNode& rhs) const { return val > rhs.val; }
    }node;
    vector<edges> V;
    int idx, dis[MAXN][15], head[MAXN];
    void init()
    {
        met(dis, 0x3f);
        met(head, -1);
        V.clear();
        idx = 0;
        return ;
    }
    void add(int u, int v, int val)
    {
        V.push_back(edges(v, val, head[u]));
        head[u] = idx++;
        return ;
    }
    int dijkstra(int bg, int ed, int k)
    {
        priority_queue<node> Q;
        Q.push(node(bg, 0, dis[bg][0] = 0));
        while (!Q.empty())
        {
            node q = Q.top(); Q.pop();
            if (dis[q.now][q.high] < q.val)
                continue;
            for (int i = head[q.now]; i != -1; i = V[i].next)
            {
                int to = V[i].to;
                if (dis[to][q.high] > q.val + V[i].val)
                    Q.push(node(to, q.high, dis[to][q.high] = q.val + V[i].val));
                if (q.high < k && dis[to][q.high + 1] > q.val)
                    Q.push(node(to, q.high + 1, dis[to][q.high + 1] = q.val));
            }
        }
        return dis[ed][k];
    }
};

Dijkstra solve;

int main()
{
    int n, m, k;
    while (cin >> n >> m >> k)
    {
        int bg, ed;
        cin >> bg >> ed;
        bg++, ed++;
        solve.init();
        for (int i = 0; i < m; i++)
        {
            int u, v, val;
            cin >> u >> v >> val;
            u++, v++;
            solve.add(u, v, val);
            solve.add(v, u, val);
        }
        cout << solve.dijkstra(bg, ed, k) << endl;
    }
    return 0;
}