[最短路树] aw3628. 边的删减(dijkstra算法+最短路树+知识理解+好题+aw周赛002_3)

1. 题目来源

链接：3628. 边的删减

相关：[图+最短路+模板] 五大最短路常用模板

2. 题目解析

最短路树与堆优化 dijkstra() 的应用。

在连通图中求最短路时，若有 n 个点，那么则会有 n-1 条边。以 dijkstra() 算法为例，如果 a 点更新了 b 点，那么我们将 a 点定义为 b 点的父节点。若存在多个点都可以更新 b 点，只需要保存其中任意一条即可，因为均能保证 b 的最短路，且对前后不产生影响。

这样定义父节点之后，就能形成树的结构，将其称为最短路树。

---

相关性质：

• 保留最短路树的所有边，即便任意删边，所有点的最短路均不变。
• 若想让图中一点最短路保持不变，那么该点的前驱边不能被删除。

---

本题中让保留 k 条边，那么最多只能让 k+1 个点的最短路保持不变，k+1 个点为最短路不变点的数量上界。

只需从根节点开始遍历，任意一个包含 k 条边的连通块均保证了 k+1 个点最短路不变。即均是一个可行答案。

在 dijkstra() 算法求完最短路后，只需要判断 dist[a]+w==dist[b] 就能说明是 a-->b 这条边是最短路树中的一条边，就可将其加入连通块中。但如果仅拿松弛操作进行判断的话是无法保证多点的同时更新，如 dist[c]+w==dist[b]，此时 a、c 都能更新 b，若将其全部添加、全部删除，只会同时影响一个点 b，所以需要保证每个点只被计算一次，需要一个判重数组。

---

本题需要对 dijkstra() 算法有个深刻的理解和认识，是怎么一步步求出所有点到 1 号源点的最短路的，贪心选边是怎么选的，是怎么进行更新的，这样的更新有什么性质？

dijkstra() 的贪心思路为：每次更新到起点距离最短的点的最短路长度，故对于每轮更新出的最短路点来讲，最后一次更新它的边一定会在选中该点时成为最短路树中的一条边。

可以在 dijkstra() 算法中记录最后一次更新的边，由于具有连通性，可以直接输出答案。见题解：题解1 直接输出答案、题解2 巨佬写的很清楚

---

时间复杂度：$O(nlogn)$

空间复杂度：$O(n)$

---

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

typedef long long LL;
typedef pair<LL, int> PII;

const int N = 1e5 + 5, M = 2 * N;

int n, m, k;
int h[N], e[M], w[M], ne[M], id[M], idx;
LL dist[N];
bool st[N];
vector<int> cnt;

void add(int a, int b, int c, int d) {
    e[idx] = b, w[idx] = c, id[idx] = d, ne[idx] = h[a], h[a] = idx ++ ;
}

void dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});
    
    while (heap.size()) {
        auto t = heap.top(); heap.pop();
        
        int d = t.first, idx = t.second;
        st[idx] = true;
        
        for (int i = h[idx]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[idx] + w[i]) {
                dist[j] = dist[idx] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
}

// 搜索 u 的所有出边点，将满足松弛操作的出边点选中，说明其为最短路树中的边，加入答案
// 和树的遍历一样，st 数组保证每个点只搜一次，再对出边点进行相同操作即可
void dfs(int u) {
    st[u] = true;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (!st[j] && dist[j] == dist[u] + w[i]) {
            if (cnt.size() < k) cnt.push_back(id[i]);
            
            dfs(j);
        }
    }
}

int main() {
    scanf("%d%d%d", &n, &m, &k);
    memset(h, -1, sizeof h);
    
    for (int i = 1; i <= m; i ++ ) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c, i), add(b, a, c, i);
    }
    
    dijkstra();
    
    memset(st, 0, sizeof st);   // 保证每个点只被搜一次
    dfs(1);                     // 从起点 1 号点开始搜
    
    printf("%d\n", cnt.size());     // 打印 k
    for (auto e : cnt) printf("%d ", e);    // 打印点编号
    puts("");
    
    return 0;
}