图论篇--代码随想录算法训练营第五十六天打卡| 108. 冗余连接，109. 冗余连接II

108. 冗余连接

题目链接：108. 冗余连接

题目描述：

有一个图，它是一棵树，他是拥有 n 个节点（节点编号1到n）和 n - 1 条边的连通无环无向图（其实就是一个线形图），如图：

现在在这棵树上的基础上，添加一条边（依然是n个节点，但有n条边），使这个图变成了有环图，如图：

先请你找出冗余边，删除后，使该图可以重新变成一棵树。

解题思路：

并查集的直接应用

代码：

#include<iostream>
#include<vector>
using namespace std;

const int N = 1010;
vector<int> father(N,0);

void init(int n)
{
    for(int i = 1; i <= n; i++) father[i] = i;
}

int find(int u)
{
    return u == father[u] ? u : father[u] = find(father[u]);
}

bool isSame(int u, int t)
{
    if(find(u) == find(t)) return true;
    else return false;
}

void join(int u, int s)
{
    u = find(u);
    s = find(s);
    if(u == s) return;
    father[s] = u;
}

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

109. 冗余连接II

题目链接：109. 冗余连接II

题目描述：

有一种有向树,该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。有向树拥有 n 个节点和 n - 1 条边。如图： 

现在有一个有向图，有向图是在有向树中的两个没有直接链接的节点中间添加一条有向边。如图：

输入一个有向图，该图由一个有着 n 个节点(节点编号 从 1 到 n)，n 条边，请返回一条可以删除的边，使得删除该条边之后该有向图可以被当作一颗有向树。

解题思路：

本题目要将一个有向图转变成为一颗有向树。知一个有向图=一颗有向树 + 一条有向边

有向树的特点是只有根节点入度为0，其他节点入度都为1。

1. 情况一：如果我们找到入度为2的点，那么删一条指向该节点的边就行了。
2. 情况二，对于某些入度为2的点，只能删特定的一条边，如下图所示。
3. 情况三： 如果没有入度为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);
}