代码随想录Day 56|题目：冗余连接、109. 冗余连接II

提示：DDU，供自己复习使用。欢迎大家前来讨论~

图论part06

题目一：冗余连接

这道题目要求你在无向图中删除一条边，使得剩下的图结构成为一棵树。

解题思路：

1. 题目要求

• 给定一个无向图。
• 删除一条边，让剩余的图结构变成一棵树。
• 如果有多个解，返回最后出现的那条边。

2. 并查集的作用

• 集合操作：判断两个节点是否在同一个集合中，或者将两个节点添加到同一个集合。
• 连通性：用于管理图中的连通性，确保图在删除一条边后仍然是连通的。

3. 解题步骤

• 初始化：使用并查集初始化所有节点，每个节点自成一个集合。

• 遍历边

  ：从后向前遍历所有边，这样做是因为最后出现的边可能是答案。

  • 判断连通性：如果两个节点不在同一个集合中，说明它们之间还没有直接连接，可以安全地添加这条边。
  • 合并集合：使用并查集的合并操作将两个节点加入到同一个集合中。
  • 记录可删除边：如果两个节点已经在同一个集合中，记录这条边，因为它是可删除的。

如图所示，节点A 和节点 B 不在同一个集合，那么就可以将两个 节点连在一起。

如果边的两个节点已经出现在同一个集合里，说明着边的两个节点已经连在一起了，再加入这条边一定就出现环了。

如图所示：

已经判断 节点A 和 节点B 在在同一个集合（同一个根），如果将 节点A 和 节点B 连在一起就一定会出现环。

这个思路清晰之后，代码就很好写了。

总结：

• 并查集是解决无向图中边的删除问题的有效工具。
• 通过从后向前遍历边，并使用并查集判断和合并操作，可以找到可删除的边。
• 路径压缩技巧可以提升并查集的性能。

并查集C++代码如下：

#include <iostream>
#include <vector>
using namespace std;
int n; // 节点数量
vector<int> father(1001, 0); // 按照节点大小范围定义数组

// 并查集初始化
void init() {
    for (int i = 0; i <= n; ++i) {
        father[i] = i;
    }
}
// 并查集里寻根的过程
int find(int u) {
    return u == father[u] ? u : father[u] = find(father[u]);
}
// 判断 u 和 v是否找到同一个根
bool isSame(int u, int v) {
    u = find(u);
    v = find(v);
    return u == v;
}
// 将v->u 这条边加入并查集
void join(int u, int v) {
    u = find(u); // 寻找u的根
    v = find(v); // 寻找v的根
    if (u == v) return ; // 如果发现根相同，则说明在一个集合，不用两个节点相连直接返回
    father[v] = u;
}

int main() {
    int s, t;
    cin >> n;
    init();
    for (int i = 0; i < n; i++) {
        cin >> s >> t;
        if (isSame(s, t)) {
            cout << s << " " << t << endl;
            return 0;
        } else {
            join(s, t);
        }
    }
}

可以看出，主函数的代码很少，就判断一下边的两个节点在不在同一个集合就可以了。

题目二：109. 冗余连接II

代码随想录 (programmercarl.com)

题目目标

在有向图中找到并删除一条边，使得剩下的图成为一棵有向树。

解题步骤

1. 记录边和节点入度：首先记录每条边和每个节点的入度。
2. 查找入度为2的节点：遍历边，找到入度为2的节点，并记录这些边。
3. 处理入度为2的节点：如果存在入度为2的节点，判断删除哪条边可以使得图变成有向树。优先删除最后出现的边。
4. 判断是否为有向树：使用并查集判断删除某条边后的连通性。
5. 查找有向环：如果没有入度为2的节点，说明图中存在环，需要找到构成环的边并删除。
6. 使用并查集：并查集用于判断节点间的连通性，帮助确定是否形成环。

本题C++代码如下：（详细注释了）

#include <iostream>
#include <vector>
using namespace std;
int n;
vector<int> father (1001, 0);
// 并查集初始化
void init() {
    for (int i = 1; i <= n; ++i) {
        father[i] = i;
    }
}
// 并查集里寻根的过程
int find(int u) {
    return u == father[u] ? u : father[u] = find(father[u]);
}
// 将v->u 这条边加入并查集
void join(int u, int v) {
    u = find(u);
    v = find(v);
    if (u == v) return ;
    father[v] = u;
}
// 判断 u 和 v是否找到同一个根
bool same(int u, int v) {
    u = find(u);
    v = find(v);
    return u == v;
}

// 在有向图里找到删除的那条边，使其变成树
void getRemoveEdge(const vector<vector<int>>& edges) {
    init(); // 初始化并查集
    for (int i = 0; i < n; i++) { // 遍历所有的边
        if (same(edges[i][0], edges[i][1])) { // 构成有向环了，就是要删除的边
            cout << edges[i][0] << " " << edges[i][1];
            return;
        } else {
            join(edges[i][0], edges[i][1]);
        }
    }
}

// 删一条边之后判断是不是树
bool isTreeAfterRemoveEdge(const vector<vector<int>>& edges, int deleteEdge) {
    init(); // 初始化并查集
    for (int i = 0; i < n; i++) {
        if (i == deleteEdge) continue;
        if (same(edges[i][0], edges[i][1])) { // 构成有向环了，一定不是树
            return false;
        }
        join(edges[i][0], edges[i][1]);
    }
    return true;
}

int main() {
    int s, t;
    vector<vector<int>> edges;
    cin >> n;
    vector<int> inDegree(n + 1, 0); // 记录节点入度
    for (int i = 0; i < n; i++) {
        cin >> s >> t;
        inDegree[t]++;
        edges.push_back({s, t});
    }

    vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
    // 找入度为2的节点所对应的边，注意要倒序，因为优先删除最后出现的一条边
    for (int i = n - 1; i >= 0; i--) {
        if (inDegree[edges[i][1]] == 2) {
            vec.push_back(i);
        }
    }
    // 情况一、情况二
    if (vec.size() > 0) {
        // 放在vec里的边已经按照倒叙放的，所以这里就优先删vec[0]这条边
        if (isTreeAfterRemoveEdge(edges, vec[0])) {
            cout << edges[vec[0]][0] << " " << edges[vec[0]][1];
        } else {
            cout << edges[vec[1]][0] << " " << edges[vec[1]][1];
        }
        return 0;
    }

    // 处理情况三
    // 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
    getRemoveEdge(edges);
}

通过分析节点的入度和使用并查集，可以有效地找到并删除一条边，使得有向图变成有向树。优先考虑删除最后出现的边，如果没有入度为2的节点，则需要找到并删除构成环的边。

总结

1. 分析入度：检查每个节点的入度，寻找入度为2的节点。这通常意味着有多余的连接，删除其中任意一条指向该节点的边可能恢复有向树的结构。如果两条边都可以删除，根据题目要求，选择最后出现的那条边。

2. 使用并查集：利用并查集来检测删除某条边后的连通性，确保删除后剩余的图是有向树。如果没有入度为2的节点，说明存在环，需要通过并查集找到构成环的边并删除。