分层图最短路（模板）

这一题看似就是一个有权值的最短路问题，但是中间有K次免费，这几次免费会造成非常大的影响，所以我们把原图，复制多份，然后每上下两个图之间，每个点的和另一个图所有与自己本图连通点的对应点有一个权值为0 的路径，比如，12，13连通，就在1与2.2，1与2.3建立两条0权值。跑到2层，就开始在2层与3层跑，一直跑到k+1层，最终终点变成t+n*k。。

之后就是用dijkstra跑s到t+n*k的最短路了！

不会dijkstra或者建图，建议看这里

Dijkstra 算法#图论-CSDN博客

图论基础算法入门笔记-CSDN博客

#include <bits/stdc++.h>
using namespace std;
const int N = 110005, INF = 0x3f3f3f3f; // 定义最大节点数和无穷大常量

// 边结构体：存储边的目标节点、下一条边的索引和边权值
struct Edge { int to, next, cost; } edge[2500001];
int cnt = 0, head[N];                   // 边计数器和邻接表头数组
int dis[N];                             // 存储最短路径距离
bool vis[N];                            // 标记节点是否已处理

// 快速添加边到邻接表
inline void add_edge(int u, int v, int c = 0) {
    edge[++cnt] = {v, head[u], c};      // 插入新边，使用聚合初始化
    head[u] = cnt;                      // 更新表头为最新边的索引
}

// Dijkstra算法：计算从起点s出发到所有节点的最短路径
void Dijkstra(int s) {
    memset(dis, 0x3f, sizeof(dis));     // 初始化为无穷大
    dis[s] = 0;                         // 起点到自身距离为0
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    q.push({0, s});                     // 优先队列存储{距离, 节点}对
    while (!q.empty()) {
        int u = q.top().second; q.pop();
        if (vis[u]) continue;           // 跳过已处理的节点
        vis[u] = 1;                     // 标记节点为已处理
        for (int i = head[u]; i; i = edge[i].next) {  // 遍历所有邻接边
            int v = edge[i].to, c = edge[i].cost;
            if (dis[v] > dis[u] + c) {  // 松弛操作
                dis[v] = dis[u] + c;
                q.push({dis[v], v});    // 将更新后的节点加入队列
            }
        }
    }
}

int main() {
    int n, m, k, s, t;                  // n:城市数 m:航线数 k:免费次数 s:起点 t:终点
    scanf("%d%d%d%d%d", &n, &m, &k, &s, &t);
    
    // 构建分层图
    for (int i = 0, u, v, c; i < m; ++i) {
        scanf("%d%d%d", &u, &v, &c);    // 输入每条航线
        
        // 原始层的双向边
        add_edge(u, v, c);
        add_edge(v, u, c);
        
        // 构建k层分层图
        for (int j = 1; j <= k; ++j) {
            // 免费升级边：从j-1层到j层，边权为0
            add_edge(u + (j - 1) * n, v + j * n, 0);
            add_edge(v + (j - 1) * n, u + j * n, 0);
            
            // 同层边：在第j层内移动，边权为c
            add_edge(u + j * n, v + j * n, c);
            add_edge(v + j * n, u + j * n, c);
        }
    }
    
    // 允许在终点使用免费次数，但不移动位置
    for (int i = 1; i <= k; ++i)
        add_edge(t + (i - 1) * n, t + i * n, 0);
    
    Dijkstra(s);                        // 从起点开始计算最短路径
    printf("%d\n", dis[t + k * n]);     // 输出使用k次免费后的最短路径
    return 0;
}

无 注释版

#include <bits/stdc++.h>
using namespace std;
const int N = 110005, INF = 0x3f3f3f3f;

struct Edge { int to, next, cost; } edge[2500001];
int cnt = 0, head[N], dis[N];
bool vis[N];

inline void add_edge(int u, int v, int c = 0) {
    edge[++cnt] = {v, head[u], c};
    head[u] = cnt;
}

void Dijkstra(int s) {
    memset(dis, 0x3f, sizeof(dis));
    dis[s] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    q.push({0, s});
    while (!q.empty()) {
        int u = q.top().second; q.pop();
        if (vis[u]) continue;
        vis[u] = 1;
        for (int i = head[u]; i; i = edge[i].next) {
            int v = edge[i].to, c = edge[i].cost;
            if (dis[v] > dis[u] + c) {
                dis[v] = dis[u] + c;
                q.push({dis[v], v});
            }
        }
    }
}

int main() {
    int n, m, k, s, t;
    scanf("%d%d%d%d%d", &n, &m, &k, &s, &t);
    for (int i = 0, u, v, c; i < m; ++i) {
        scanf("%d%d%d", &u, &v, &c);
        add_edge(u, v, c);
        add_edge(v, u, c);
        for (int j = 1; j <= k; ++j) {
            add_edge(u + (j - 1) * n, v + j * n);
            add_edge(v + (j - 1) * n, u + j * n);
            add_edge(u + j * n, v + j * n, c);
            add_edge(v + j * n, u + j * n, c);
        }
    }
    for (int i = 1; i <= k; ++i)
        add_edge(t + (i - 1) * n, t + i * n);
    Dijkstra(s);
    printf("%d\n", dis[t + k * n]);
    return 0;
}