【代码随想录训练营第42期 Day56打卡 - 图论Part6 - 并查集2 - 冗余连接问题

最新推荐文章于 2024-10-12 22:56:36 发布

逝去的秋风

最新推荐文章于 2024-10-12 22:56:36 发布

阅读量1.4k

点赞数 25

分类专栏：代码随想录打卡文章标签：图论算法并查集

本文链接：https://blog.csdn.net/2303_79786049/article/details/142152042

版权

代码随想录打卡专栏收录该内容

57 篇文章 0 订阅

订阅专栏

一、做题心得

冗杂连接问题是图论章节应用并查集的经典问题。所有的顶点通过边相连，且除了一个多余的边之外，其他的边都是必须的，用以保持图的所有顶点连通，而我们需要做的，就是删除这条边，即冗杂的边。

这里打卡的两道题分别从无向边和有向边两种情况进行考虑。

二、题目与题解

题目一：108. 冗余连接

题目链接

108. 冗余连接 (kamacoder.com)

题目描述

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

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

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

输入描述

第一行包含一个整数 N，表示图的节点个数和边的个数。

后续 N 行，每行包含两个整数 s 和 t，表示图中 s 和 t 之间有一条边。

输出描述

输出一条可以删除的边。如果有多个答案，请删除标准输入中最后出现的那条边。

输入示例
3
1 2
2 3
1 3
输出示例
1 3
提示信息

图中的 1 2，2 3，1 3 等三条边在删除后都能使原图变为一棵合法的树。但是 1 3 由于是标准输出里最后出现的那条边，所以输出结果为 1 3

数据范围：

1 <= N <= 1000.

题解：并查集

这题就是昨天打卡模板的经典应用。

这里需要注意的是：

判断是否形成环：在将这对节点合并之前，会调用 isSame 函数来判断 s 和 t 是否已经在同一个集合中

如果 isSame(s, t) 返回 true，则说明 s 和 t 已经在同一个集合中，合并它们将会形成一个环。因此，程序会输出这对节点并结束

合并集合：如果 isSame 函数返回 false，说明 s 和 t 不在同一个集合中，合并它们不会形成环，则调用 join 函数将 s 和 t 所在的集合合并。

代码如下：

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

int n;
vector<int> father(101, 0);

// 并查集初始化
void init()
{
    for (int i = 1; i <= n; i++) // 节点是从1到n
        father[i] = i;           
}

// 并查集里寻找该节点的根节点（带路径压缩）
int find(int u)
{
    if (u != father[u])
        father[u] = find(father[u]);
    return father[u];
}

// 判断u和v是否找到同一个根节点 -- 是否在同一个集合中
bool isSame(int u, int v)
{
    int rootu = find(u);
    int rootv = find(v);
    return rootu == rootv;
}

// join 函数用于合并两个节点所在的集合：将v->u这条边加入并查集
void join(int u, int v)
{
    int rootu = find(u);
    int rootv = find(v);
    if (rootu != rootv)
        father[rootv] = rootu;
}

int main()
{
    cin >> n;
    init(); // 初始化并查集
    while (n--)
    {
        int s, t;
        cin >> s >> t;
        if (isSame(s, t))
        {
            cout << s << " " << t;
            return 0;
        }
        else
            join(s, t);
    }
}

题目二：109. 冗余连接II

题目链接

109. 冗余连接II (kamacoder.com)

题目描述

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

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

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

输入描述

第一行输入一个整数 N，表示有向图中节点和边的个数。

后续 N 行，每行输入两个整数 s 和 t，代表这是 s 节点连接并指向 t 节点的单向边

输出描述

输出一条可以删除的边，若有多条边可以删除，请输出标准输入中最后出现的一条边。

输入示例
3
1 2
1 3
2 3
输出示例
2 3
提示信息

在删除 2 3 后有向图可以变为一棵合法的有向树，所以输出 2 3

数据范围：

1 <= N <= 1000.

题解：并查集

注意这题变成了有向图。

一个关键：

在有向图中，如果一个节点的入度为2，那么它至少是环的一部分。这是因为至少存在两条边从不同的节点指向该节点，如果这些边之间没有其他的边连接，那么它们就构成了一个环。

然后需要注意的是，对于有向图问题，我们需要用一个二维数组来存储所有有向边（该题中使用edges[][] 存储，edges[s][t]表示从s到t的有向边）

这里直接看代码：

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

int n;
vector<int> father(1001, 0);

// 并查集初始化
void init()
{
    for (int i = 1; i <= n; i++) // 节点是从1到n
        father[i] = i;
}

// 并查集里寻找该节点的根节点（带路径压缩）
int find(int u)
{
    if (u != father[u])
        father[u] = find(father[u]);
    return father[u];
}

// 判断u和v是否找到同一个根节点 -- 是否在同一个集合中
bool isSame(int u, int v)
{
    int rootu = find(u);
    int rootv = find(v);
    return rootu == rootv;
}

// join 函数用于合并两个节点所在的集合：将v->u这条边加入并查集
void join(int u, int v)
{
    int rootu = find(u);
    int rootv = find(v);
    if (rootu != rootv)
        father[rootv] = rootu;
}

// 在有向图里找到删除的那条边，使其变成树
void getRemoveEdge(const vector<vector<int>> &edges)
{
    init();                     // 初始化并查集
    for (int i = 0; i < n; i++) // 遍历所有的边
    {
        if (isSame(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 (isSame(edges[i][0], edges[i][1]))
            return false; // 如果构成有向环，则不是树
        else
            join(edges[i][0], edges[i][1]); // 将边加入并查集
    }
    return true; // 如果没有构成环，则是树
}

int main()
{
    int s, t;
    vector<vector<int>> edges;      // 存储所有边 -- 有向：edge[s][t]表示边 s->t
    cin >> n;                       // 输入边的数量
    vector<int> inDegree(n + 1, 0); // 记录节点入度
    for (int i = 0; i < n; i++)
    {
        cin >> s >> t;           // 输入边s->t（有向边）
        inDegree[t]++;           // 增加节点t的入度
        edges.push_back({s, t}); // 将边加入边列表 edge
    }

    vector<int> vec; // 存储入度为2的边的索引
    // 注意：找到入度为2的节点所对应的边，倒序遍历以优先删除最后出现的边
    for (int i = n - 1; i >= 0; i--)
    {
        if (inDegree[edges[i][1]] == 2)
            vec.push_back(i); // 将边的索引加入vec
    }
    // 如果有入度为2的边，则尝试删除这些边
    if (vec.size() > 0)
    {
        // 优先删除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);
}