描述

There are NN cities in the country, and MM directional roads from uu to v(1\le u, v\le n)v(1≤u,v≤n). Every road has a distance c_ici. Haze is a Magical Girl that lives in City 11, she can choose no more than KK roads and make their distances become 00. Now she wants to go to City NN, please help her calculate the minimum distance.

Input

The first line has one integer T(1 \le T\le 5)T(1≤T≤5), then following TT cases.

For each test case, the first line has three integers N, MN,M and KK.

Then the following MM lines each line has three integers, describe a road, U_i, V_i, C_iUi,Vi,Ci. There might be multiple edges between uu and vv.

It is guaranteed that N \le 100000, M \le 200000, K \le 10N≤100000,M≤200000,K≤10,
0 \le C_i \le 1e90≤Ci≤1e9. There is at least one path between City 11 and City NN.

Output

For each test case, print the minimum distance.

樣例輸入

1
5 6 1
1 2 2
1 3 4
2 4 3
3 4 1
3 5 6
4 5 2

樣例輸出

3

題目來源

思路

給出一個

我們需要利用類似動態規劃的思想來進行轉移。

我們定義:

• dis[i][j]$dis[i][j]$：從起點st到i點，使用了j次優惠機會所使用的最小花費.
• vis[i][j]$vis[i][j]$：從起點st到i點，使用了j次優惠機會這個狀態有沒有被標記

我們需要對普通的迪傑斯特拉轉移的時候進行一些改變：

1. 不使用免費機會的時候：

   如果 到點u的花費dis[u][k]+從u到v的邊權w<到v的邊權dis[v][k]
   正常轉移更新:dis[v][k]=dis[u][k]+w
   加入堆q.push(node(v,k,dis[v][k]))

2. 使用免費機會的時候:

   如果 到點u的時候使用了k次機會的花費dis[u][k]<到v點的時候使用了k+1次機會的邊權dis[v][k+1]
   這條邊免費更新dis[v][k+1]=dis[u][k]
   加入堆q.push(node(v,k+1,dis[v+1][k]))

剩下的就是迪傑斯特拉的堆優化模板了。

程式碼

#include <bits/stdc++.h>
using namespace std;
#define mem(a, b) memset(a, b, sizeof(a))
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10;
int first[N], tot;
int n, m, k;
struct edge
{
    int v, w, next;
} e[N * 2];
void add_edge(int u, int v, int w)
{
    e[tot].v = v, e[tot].w = w;
    e[tot].next = first[u];
    first[u] = tot++;
}
void init()
{
    mem(first, -1);
    tot = 0;
}
struct node
{
    int id, k, now;
    node() {}
    node(int _id, int _k, int _now)
    {
        id = _id, k = _k, now = _now;
    }
    bool friend operator<(node a, node b)
    {
        return a.now > b.now;
    }
};
int dis[N][12], vis[N][12];
void dijkstra(int st)
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j <= k; j++)
        {
            dis[i][j] = inf;
            vis[i][j] = 0;
        }
    }
    dis[st][0] = 0;
    priority_queue<node> q;
    q.push(node(st, 0, 0));
    while (!q.empty())
    {
        node u = q.top();
        q.pop();
        if (!vis[u.id][u.k])
        {
            vis[u.id][u.k] = 1;
            for (int i = first[u.id]; ~i; i = e[i].next)
            {
                int v = e[i].v, w = e[i].w;
                if (!vis[v][u.k] && dis[u.id][u.k] + w < dis[v][u.k])
                {
                    dis[v][u.k] = dis[u.id][u.k] + w;
                    q.push(node(v, u.k, dis[v][u.k]));
                }
                if (u.k < k && !vis[v][u.k] && dis[u.id][u.k] < dis[v][u.k + 1])
                {
                    dis[v][u.k + 1] = dis[u.id][u.k];
                    q.push(node(v, u.k + 1, dis[v][u.k + 1]));
                }
            }
        }
    }
}
void solve()
{
    int u, v, w;
    scanf("%d%d%d", &n, &m, &k);
    init();
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        add_edge(u, v, w);
    }
    dijkstra(1);
    int ans = inf;
    for (int i = 0; i <= k; i++)
        ans = min(ans, dis[n][i]);
    printf("%d\n", ans);
}
int main()
{
    //freopen("in.txt", "r", stdin);
    int t;
    scanf("%d", &t);
    while (t--)
        solve();
    return 0;
}