1489. 找到最小生成树里的关键边和伪关键边

给你一个 n 个点的带权无向连通图，节点编号为 0 到 n-1 ，同时还有一个数组 edges ，其中 edges[i] = [fromi, toi, weighti] 表示在 fromi 和 toi 节点之间有一条带权无向边。最小生成树 (MST) 是给定图中边的一个子集，它连接了所有节点且没有环，而且这些边的权值和最小。

请你找到给定图中最小生成树的所有关键边和伪关键边。如果从图中删去某条边，会导致最小生成树的权值和增加，那么我们就说它是一条关键边。伪关键边则是可能会出现在某些最小生成树中但不会出现在所有最小生成树中的边。

请注意，你可以分别以任意顺序返回关键边的下标和伪关键边的下标。

示例 1：

输入：n = 5, edges = [[0,1,1],[1,2,1],[2,3,2],[0,3,2],[0,4,3],[3,4,3],[1,4,6]]
输出：[[0,1],[2,3,4,5]]
解释：上图描述了给定图。
下图是所有的最小生成树。

注意到第 0 条边和第 1 条边出现在了所有最小生成树中，所以它们是关键边，我们将这两个下标作为输出的第一个列表。
边 2，3，4 和 5 是所有 MST 的剩余边，所以它们是伪关键边。我们将它们作为输出的第二个列表。

示例 2 ：

输入：n = 4, edges = [[0,1,1],[1,2,1],[2,3,1],[0,3,1]]
输出：[[],[0,1,2,3]]
解释：可以观察到 4 条边都有相同的权值，任选它们中的 3 条可以形成一棵 MST 。所以 4 条边都是伪关键边。

提示：

2 <= n <= 100
1 <= edges.length <= min(200, n * (n - 1) / 2)
edges[i].length == 3
0 <= fromi < toi < n
1 <= weighti <= 1000
所有 (fromi, toi) 数对都是互不相同的。

---

解题思路

使用Kruskal算法（并查集）判断。

对边由小到大排序，依次删除每条边，判断删除该边后的情况：

• case1：删除该边后如果剩下的图不联通，或者生成的最小生成树权值增加，则该边是关键边
• case2：如果不是关键边，但是包含该边的最小生成树的权值不变，则该边是为关键边 （可以将该边作为第一条边生成最小生成树）

#include "bits/stdc++.h"
using namespace std;

class UnionFind {
public:
    UnionFind(int n)
    {
        pre.resize(n);
        for (int i = 0; i < n; ++i) {
            pre[i] = i;
        }
    }

    int Find(int x)
    {
        return x == pre[x] ? x : (pre[x] = Find(pre[x]));
    }

    void Union(int x, int y)
    {
        pre[Find(x)] = Find(y);
    }

public:
    vector<int> pre;
};

static bool Cmp(const vector<int>& a, const vector<int>& b)
{
    return a[2] < b[2];
}

class Solution {
public:
    // 查找最小生成树的关键边和伪关键边
    vector<vector<int>> findCriticalAndPseudoCriticalEdges(int n, vector<vector<int>>& edges) {
        vector<vector<int>> result(2);

        // 记录每条边的下标
        for (int i = 0; i < edges.size(); ++i) {
            edges[i].emplace_back(i);
        }

        // 排序
        sort(edges.begin(), edges.end(), Cmp);

        // 计算最小生成树权值
        int minWeight = 0;
        int curNum = 0;
        UnionFind uf(n);
        for (int i = 0; i < edges.size(); ++i) {
            int rootA = uf.Find(edges[i][0]);
            int rootB = uf.Find(edges[i][1]);
            if (rootA != rootB) {
                minWeight += edges[i][2];
                ++curNum;
                if (curNum == n - 1) {
                    break;
                }
                // 合并两节点
                uf.pre[rootA] = rootB;
            }
        }

        for (int i = 0; i < edges.size(); ++i) {
            // 删除边i后，图不联通或最小生成树权值增加，则边i为关键边
            int weight = 0;
            int num = 0;
            uf = UnionFind(n);
            for (int j = 0; j < edges.size(); ++j) {
                if (j == i) {
                    continue;
                }
                int rootA = uf.Find(edges[j][0]);
                int rootB = uf.Find(edges[j][1]);
                if (rootA != rootB) {
                    weight += edges[j][2];
                    ++num;
                    if (num == n - 1) {
                        break;
                    }
                    // 合并两节点
                    uf.pre[rootA] = rootB;
                }
            }
            if (weight > minWeight || num != n - 1) {   // error：第一次提交没考虑不联通情况
                result[0].emplace_back(edges[i][3]);
                continue;
            }

            // 边i不是关键边，单从该边开始也能生成最小生成树（权值和==minWeight），则边i为伪关键边
            uf = UnionFind(n);
            uf.Union(edges[i][0], edges[i][1]);
            weight = edges[i][2];
            num = 1;
             for (int j = 0; j < edges.size(); ++j) {
                if (j == i) {
                    continue;
                }
                int rootA = uf.Find(edges[j][0]);
                int rootB = uf.Find(edges[j][1]);
                if (rootA != rootB) {
                    weight += edges[j][2];
                    ++num;
                    if (num == n - 1) {
                        break;
                    }
                    // 合并两节点
                    uf.pre[rootA] = rootB;
                }
            }
            if (weight == minWeight) {
                result[1].emplace_back(edges[i][3]);
            }
        }
        return result;
    }
};