「代码随想录算法训练营」第四十八天 | 图论 part6

108. 冗余连接

题目链接:https://kamacoder.com/problempage.php?pid=1181
文章讲解:https://www.programmercarl.com/kamacoder/0108.冗余连接.html
题目状态:看题解

思路:

构建并查集,然后通过并查集来判断节点,若当前这对节点(s, t)在同一个集合中,那么输出这对节点即可达到题目要求,否则,就将s和t合并到同一个集合中。

代码:

#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

题目链接:https://kamacoder.com/problempage.php?pid=1182
文章讲解:https://www.programmercarl.com/kamacoder/0109.冗余连接II.html
题目状态:看题解

思路:

函数

  1. init():

    • 初始化并查集,每个节点的父节点指向自身。
  2. find(int u):

    • 递归查找节点 u 的根节点,并进行路径压缩。
  3. join(int u, int v):

    • 合并两个节点所在的集合。
  4. same(int u, int v):

    • 判断两个节点是否在同一个集合中。
  5. getRemoveEdge(const vector<vector<int>>& edges):

    • 遍历所有边,找到构成有向环的边并输出。
  6. isTreeAfterRemoveEdge(const vector<vector<int>>& edges, int deleteEdge):

    • 删除指定边后检查图是否为树。

main() 函数

  • 读取节点数 n 和边。
  • 计算每个节点的入度。
  • 找到入度为 2 的节点对应的边,优先删除最后出现的一条边。
  • 如果删除后形成树,输出该边。
  • 如果没有入度为 2 的节点,调用 getRemoveEdge 找到并输出构成环的边。

逻辑流程

  1. 处理入度为 2 的情况:

    • 找出入度为 2 的节点,尝试删除对应的边,检查是否能形成树。
  2. 处理无入度为 2 的情况:

    • 如果没有入度为 2 的节点,必然存在一个环,找到并删除构成环的边。

代码:

#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);
}