题目链接

题目

题目描述

Island 发生了一场暴乱！现在 Rinne 要和 Setsuna 立马到地上世界去。

众所周知：Island 是有一些奇怪的城镇和道路构成的（题目需要，游戏党勿喷），有些城镇之间用双向道路连接起来了，且每条道路有它自己的距离。但是有一些城镇已经被派兵戒严，虽然主角可以逆天改命强闯，但是为了体验该游戏的平衡性，他们只能穿过不超过 K 次被戒严的城镇。

定义“穿过”：从一个戒严的点出发到达任意一个点，都会使得次数加1

现在他们想从 1 号城镇最快的走到 n 号城镇（即出口），现在他们想让你告诉他们最短需要走多少路。

输入描述

第一行三个整数 n,m,k，分别表示城镇数量，边数量和最多能闯过被戒严的城市的次数。
接下来 n 行，每行一个整数 1 或 0，如果为 1 则表示该城市已被戒严，0 则表示相反。
接下来 m 行，每行三个数 u,v,w，表示在 u 城镇和 v 城镇之间有一条长度为 w 的双向道路。

输出描述

输出一行一个数字，表示从 1 到 n 的最短路径，如果到达不了的话，请输出 -1。

示例1

输入

4 5 1
1
0
1
0
1 2 10
2 3 10
3 1 15
1 4 60
3 4 30

输出

60

备注:

\(2 \leq n \leq 800,1 \leq m \leq 4000,1 \leq k \leq 10,1 \leq w \leq 10^6\)

保证没有多条道路连接同一对城市，也没有一条道路连向自己。

题解

知识点：最短路。

显然，我们需要给 \(dis\) 加上一个维度记录走了几个戒严点。注意实现的细节，超过 \(K\) 个才不能走，刚好 \(K\) 个还能继续走，因此判断加在循环开头。

时间复杂度 \(O(nk + cm),c是常数\)

空间复杂度 \(O(nk+m)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

template<class T>
struct Graph {
    struct edge {
        int v, nxt;
        T w;
    };
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }

    void add(int u, int v, T w) {
        e[++idx] = edge{ v,h[u],w };
        h[u] = idx;
    }
};

const int N = 800 + 7, M = 4000 + 7 << 1;
Graph<int> g(N, M);
int n, m, k;
bool a[N];

int dis[N][17];
bool vis[N][17];
struct node {
    int v, cnt, w;
    friend bool operator<(const node &a, const node &b) {
        return a.w > b.w;
    }
};
priority_queue<node> pq;
void dijkstra(int st) {
    for (int i = 1;i <= n;i++)
        for (int j = 0;j <= k;j++)
            dis[i][j] = 0x3f3f3f3f, vis[i][j] = 0;
    dis[st][0] = 0;
    pq.push(node{ st,0,0 });
    while (!pq.empty()) {
        int u = pq.top().v, cnt = pq.top().cnt;
        pq.pop();
        if (cnt + a[u] > k || vis[u][cnt]) continue;
        vis[u][cnt] = 1;
        for (int i = g.h[u];i;i = g.e[i].nxt) {
            int v = g.e[i].v, w = g.e[i].w;
            if (dis[v][cnt + a[u]] > dis[u][cnt] + w) {
                dis[v][cnt + a[u]] = dis[u][cnt] + w;
                pq.push(node{ v,cnt + a[u],dis[v][cnt + a[u]] });
            }
        }
    }
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m >> k;
    for (int i = 1;i <= n;i++) cin >> a[i];
    for (int i = 1;i <= m;i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g.add(u, v, w);
        g.add(v, u, w);
    }
    dijkstra(1);
    int ans = *min_element(*(dis + n), *(dis + n) + k + 1);
    cout << ans << '\n';
    return 0;
}