【算法与数据结构】684、685、LeetCode冗余连接I II

已于 2024-02-23 19:05:55 修改
阅读量1k 收藏 18
点赞数 22
分类专栏： 算法 文章标签： 算法
于 2024-02-23 17:40:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45765437/article/details/136257898
版权

文章目录

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

一、684、冗余连接 I

在这里插入图片描述
在这里插入图片描述

  思路分析：题目给出一个无向有环图，要求去掉一个边以后构成一个树（多叉树）。那么我们根据并查集理论，将所有的边加入到并查集中，前面的边先连上，边上的两个节点如果不在同一个集合中，就加入集合。如果两个节点已经出现在同一集合里，说明这两个节点已经连接在一起了，再加入一条后来的边就会构成环。因此去掉后来的这条边即可。

  程序如下：

class Solution {
private:
    int n = 200005;		// 节点数量 200000
    vector<int> father = vector<int>(n, 0);	// C++里面的一种数据结构
    // 并查集初始化
    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;      // 根不同，则令v的父节点为u
    }
public:
	vector<int> findRedundantConnection(vector<vector<int>>& edges) {
		init();
		for (int i = 0; i < edges.size(); i++) {
			if (isSame(edges[i][0], edges[i][1])) return edges[i];
			else join(edges[i][0], edges[i][1]);
		}
		return { };
	}
};

复杂度分析：

  • 时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)，其中 n n n是图中边的个数，即edges数组的大小。需要遍历图中的 n n n条边，对于每条边，需要对两个节点查找祖先，如果两个节点的祖先不同则需要进行合并，需要进行2次查找和最多1次合并。一共需要进行 2 n 2n 2n次查找和最多 n n n次合并，因此总时间复杂度是 O ( 2 n log ⁡ ⁡ n ) = O ( n log ⁡ n ) O(2n \log ⁡n)=O(n \log n) O(2nlog⁡n)=O(nlogn)。
  • 空间复杂度： O ( n ) O(n) O(n)，主要开销用于father数组。

二、685、冗余连接 II

在这里插入图片描述
在这里插入图片描述

  思路分析：题目说明，图原本是一棵树，只不过在不增加节点的情况下多了一条额外的边，我们需要把多出来的这一条边去除。与684题区别在于本题是有向图，684题是无向图。关于有向图有出度和入度的说法。出度是指节点发出的箭头数量，入度是指指向节点的箭头数量。根节点没有父节点，其他节点有且只有一个父节点，那么多出来的一条边就会改变了节点的入度数量，而出度的数量无法成为判断标准（一个父节点可以由多个子节点，出度数量不唯一）。出现入度为2的节点有以下两种情况：

在这里插入图片描述

  如果加入的这条边形成了有向环，那么入度不会改变：
在这里插入图片描述
  统计节点入度：

int inDegree[N] = {0}; // 记录节点入度
n = edges.size(); // 边的数量
for (int i = 0; i < n; i++) {
    inDegree[edges[i][1]]++; // 统计入度
}

  前两种入度为2的情况一定是删除入度为2的节点的两条边其中一条。题目还要求返回最后出现在二维数组的答案，也就是说要从后往前遍历，删除以后判断剩下的图是否构成树。如果说两条边都可以构成树，就删除最后一条边。

vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
// 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
for (int i = n - 1; i >= 0; i--) {
    if (inDegree[edges[i][1]] == 2) {
        vec.push_back(i);
    }
}
// 处理图中情况1 和 情况2
// 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
if (vec.size() > 0) {
    if (isTreeAfterRemoveEdge(edges, vec[0])) {
        return edges[vec[0]];
    } else {
        return edges[vec[1]];
    }
}

  情况三，明确没有入度为2的情况，一定是有环，我们从后往前遍历，找到删除以后的那个可以构成树的边。那么如何判断一个图是否为树，应该应用到并查集了。因为如果两个点所在的边在添加图之前如果就可以在并查集里找到了相同的根，那么这条边添加上之后 这个图一定不是树了。

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

  程序如下：

// 685、冗余连接II-并查集
class Solution2 {
private:
    static const int N = 1005;		// 节点数量 1005
    int father[N];
    int n;                          // 边的数量
    
    // 并查集初始化
    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;      // 根不同，则令v的父节点为u
    }

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

    // 删一条边之后判断是不是树
    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;
            }
            join(edges[i][0], edges[i][1]);
        }
        return true;
    }
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int inDegree[N] = { 0 }; // 记录节点入度
        n = edges.size(); // 边的数量
        for (int i = 0; i < n; i++) {
            inDegree[edges[i][1]]++; // 统计入度
        }
        vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
        // 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
        for (int i = n - 1; i >= 0; i--) {
            if (inDegree[edges[i][1]] == 2) {
                vec.push_back(i);
            }
        }

        // 情况一和情况二：如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
        if (vec.size() > 0) {
            if (isTreeAfterRemoveEdge(edges, vec[0])) {
                return edges[vec[0]];
            }
            else {
                return edges[vec[1]];
            }
        }

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

复杂度分析：

  • 时间复杂度： O ( n log ⁡ n ) O(n \log n) O(nlogn)。
  • 空间复杂度： O ( n ) O(n) O(n)。

三、完整代码

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

// 684、冗余连接I-并查集
class Solution {
private:
    int n = 200005;		// 节点数量 200000
    vector<int> father = vector<int>(n, 0);	// C++里面的一种数据结构
    // 并查集初始化
    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;      // 根不同，则令v的父节点为u
    }
public:
	vector<int> findRedundantConnection(vector<vector<int>>& edges) {
		init();
		for (int i = 0; i < edges.size(); i++) {
			if (isSame(edges[i][0], edges[i][1])) return edges[i];
			else join(edges[i][0], edges[i][1]);
		}
		return { };
	}
};

// 685、冗余连接II-并查集
class Solution2 {
private:
    static const int N = 1005;		// 节点数量 1005
    int father[N];
    int n;                          // 边的数量
    
    // 并查集初始化
    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;      // 根不同，则令v的父节点为u
    }

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

    // 删一条边之后判断是不是树
    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;
            }
            join(edges[i][0], edges[i][1]);
        }
        return true;
    }
public:
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int inDegree[N] = { 0 }; // 记录节点入度
        n = edges.size(); // 边的数量
        for (int i = 0; i < n; i++) {
            inDegree[edges[i][1]]++; // 统计入度
        }
        vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
        // 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
        for (int i = n - 1; i >= 0; i--) {
            if (inDegree[edges[i][1]] == 2) {
                vec.push_back(i);
            }
        }

        // 情况一和情况二：如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
        if (vec.size() > 0) {
            if (isTreeAfterRemoveEdge(edges, vec[0])) {
                return edges[vec[0]];
            }
            else {
                return edges[vec[1]];
            }
        }

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

int main() {
 //   // 684、冗余连接I-并查集-测试案例
	//vector<vector<int>> edges = { {1, 2}, {1, 3}, {2, 3} };
	//Solution s1;
	//vector<int> result = s1.findRedundantConnection(edges);

    // 685、冗余连接II-并查集-测试案例
    vector<vector<int>> edges = { {1, 2}, {1, 3}, {2, 3} };
    Solution2 s2;
    vector<int> result = s2.findRedundantDirectedConnection(edges);

	for (vector<int>::iterator it = result.begin(); it < result.end(); it++) {
		cout << *it << ' ';
	}
	cout << endl;
	system("pause");
	return 0;
}

end

晚安66
关注
  • 22
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
10-03
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
JavaScript数据结构与算法即LeetCode刷题记录.zip
12-27
大数据算法在数据分析中发挥着重要的作用，它可以提高分析工作的效率和准确性，为决策提供有力支持。具体来说，大数据算法可以分类、聚类、预测和关联规则分析等，从而发现数据之间的规律和关联关系，挖掘出潜在的...
python 数据结构与算法 leetcode 算法题与书籍 刷算法全靠套路与总结
12-27
python 数据结构与算法 leetcode 算法题与书籍 刷算法全靠套路与总结！Crack LeetCode, not only how, but also why.
《数据结构与算法 LeetCode刷题宝典》.docx
01-18
本文档使用python、#C两种语言向我们展示了常见一些算法。
上海市计算机学会竞赛平台2021年5月月赛丙组数球数
a121677_的博客
05-06 180
请问足球，篮球和排球各自有几个？
Golang | Leetcode Golang题解之第67题二进制求和
weixin_66442839的博客
05-04 544
Golang | Leetcode Golang题解之第67题二进制求和
异或思想的算法题
aaa114514aaaa的博客
05-02 2094
有关异或思想的两道题目的详细解析和代码实现。 1.消失的数字（简单） 2.只出现一次的数字（较难）
高精度加减乘除
2302_77099705的博客
05-05 741
给定两个正整数（不含前导 0），计算它们的和。
什么是限流？常见的限流算法
m0_63208096的博客
05-01 1233
介绍常见的限流算法
【算法】滑动窗口——长度最小的子数组
2302_79031646的博客
05-05 772
本篇文章是用一个实例来介绍常用算法之一“滑动窗口”的相关概念，有需要借鉴即可。
学习选择排序的可视化实现（一）
weixin_40539956的博客
05-03 479
开始：从数组的第一个元素开始，假设最小（或最大）元素就是第一个元素。比较：遍历未排序的部分，找到实际的最小（或最大）元素。交换：将找到的最小（或最大）元素与未排序部分的第一个元素交换位置。重复：移动到下一个元素，重复步骤2和3，直到数组完全排序。
【LeetCode刷题】34. 在排序数组中查找元素的第一个和最后一个位置
m0_71259890的博客
05-02 310
【代码】【LeetCode刷题】34. 在排序数组中查找元素的第一个和最后一个位置。
代码随想录算法训练营第四十三天
weixin_41902984的博客
05-05 297
思路主要是分成两个差不多大的两堆，所以需要用尽可能一半去减另一半即可。思路很重要啊，第一次确实想不明白。没有深挖为什么一定是从后向前遍历，不过感觉和上一题相似，都是通过前面的内容为基础，加到后面的。所以我们要求的是 x - (sum - x) = target。还一天就上班啦，陪产假结束，坚持坚持！假设加法的总和为x，那么减法对应的总和就是sum - x。一维表目前是理解随想录的思想，不过还没默写过。这步在二维表里异常关键，相当于保证能把方法叠加起来。还是没有完成今天的工作，我歇一歇，明天继续。
力扣67 二进制求和 C语言
XinxingZh的博客
05-02 194
官方题解中是将两个字符串反转，这样从低下标开始相加其实就是实际的加法过程了。对于进位问题，我原本想的是设一个变量 flag ，然后考虑 a[i] + b[i] + flag 对应的情况，官方题解中以 carry 表示进位，那么每一位的结果实际上是 （carry + a[i] + b[i]）%2 ,不需要用 if 进行判断，进位就是 （carry + a[i] + b[i]）/2，还挺妙的。官方题解的代码写的非常简洁，学到了反转字符串和 fmax（）函数。，以二进制字符串的形式返回它们的和。
搜索算法系列之三(插值查找)
磐门的博客
05-03 1000
插值查找仅适用于有序数据、有序数组，和二分查找类似，更讲究数据有序均匀分布。
leetCode33. 搜索旋转排序数组
qq_48290779的博客
05-06 336
leetCode33. 搜索旋转排序数组
leetcode53-Maximum Subarray
我的程序人生
05-06 262
求连续子数组的和，我们可以用一个变量cur记录连续子数组的最大和，当cur加上当前元素比当前元素还要小的时候说明不能再继续累加了，往后遍历的时候就应该用当前元素的值作为cur的初始值。同时遍历的过程中不停的取cur的最大值。给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。输入：nums = [-2,1,-3,4,-1,2,1,-5,4]解释：连续子数组 [4,-1,2,1] 的和最大，为 6。是数组中的一个连续部分。
分组背包问题
waitingforone的博客
05-06 195
分组背包问题
LeetCode746：使用最小花费爬楼梯
最新发布
m0_50127633的博客
05-08 229
给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。
程序员算法与数据结构入门
09-11
一些推荐的资源包括《算法导论》、《数据结构与算法分析》、LeetCode等在线平台。 记住，算法与数据结构是一个长期学习的过程，不仅需要理解概念，还需要实践和不断地思考如何应用它们解决实际问题。祝你在算法与...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晚安66

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值