【ICPC南京站网络赛】Magical Girl Haze 分层图

Magical Girl Haze

•  1000ms
•  262144K

There are NN cities in the country, and MMdirectional 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

题目来源

ACM-ICPC 2018 南京赛区网络预赛

题意：给出若干有向图，可以将其中的k条边的权值变为0，求最短路

分层图思想，最短路为2维空间，分层图就是三维空间

该层的点到该层与该点连通的路径权值不变，与该点连通所对应的下一层权值为0

代码为kuangbin模板改编

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=100005;
struct qnode
{
    int v;
    int c;
    int k;
    qnode(int _v=0,int _c=0,int _k=0):v(_v),c(_c),k(_k) {}  bool operator <(const qnode &r)const
    {
        return c>r.c;
    }
};
struct Edge
{
    int v,cost;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost) {}
};
int K;
vector<Edge>E[MAXN];
bool vis[MAXN][30];
long long dist[MAXN][30];
void Dijkstra(int n,int start)
{
    memset(vis,false,sizeof(vis));
    memset(dist,INF,sizeof(dist));
    priority_queue<qnode>que;
    while(!que.empty())que.pop();
    dist[start][0]=0;
    que.push(qnode(start,0,0));
    qnode tmp;
    while(!que.empty())
    {
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        int now=tmp.k;
        if(vis[u][now])continue;
        vis[u][now]=true;
        for(int i=0; i<E[u].size(); i++)
        {
            int v=E[tmp.v][i].v;
            int cost=E[u][i].cost;
            if(!vis[v][now]&&dist[v][now]>dist[u][now]+cost)
            {
                dist[v][now]=dist[u][now]+cost;
                que.push(qnode(v,dist[v][now],now));
            }
            if (now<K && !vis[v][now+1] && dist[v][now+1] > dist[u][now]) {
                dist[v][now+1] = dist[u][now];
                que.push(qnode(v,dist[v][now+1],now+1));
            }
        }
    }
}
void addedge(int u,int v,int w)
{
    E[u].push_back(Edge(v,w));
}
int main()
{
    int testnum;
    scanf("%d",&testnum);
    while(testnum--)
    {
        int n,num;
        scanf("%d%d%d",&n,&num,&K);
        for(int i=0;i<=n;i++)
            E[i].clear();
        while(num--){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
        }
        Dijkstra(n,1);
        long long ans = INF;
        for (int i = 0; i <= K; i++)
            ans = min(ans, dist[n][i]);
        printf("%lld\n", ans);
    }
}

结尾写成

for (int i = 0; i <= K; i++)
            ans = min(ans, dist[n][i]);

比较严谨，因为如果删除k条边，不一定删除k条边后的总里程最小

比如

3 2 5

1 2 3

2 3 4

如果直接输出dist【n】【k】的话会WA（但是数据并没有这种样例）