leetcode并查集刷题顺序

已于 2023-09-09 16:32:42 修改
阅读量179 收藏
点赞数
分类专栏： Leetcode 文章标签： leetcode 算法 职场和发展
于 2021-01-01 13:24:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521670/article/details/112059840
版权

文章目录

128. 最长连续序列

难度困难331

给定一个未排序的整数数组，找出最长连续序列的长度。

要求算法的时间复杂度为 O(n)。

示例:

输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。

class Solution {
public:
    struct UnionSet {
        int *fa, *cnt;
        UnionSet(int n) {
            fa = new int[n + 1];
            cnt = new int[n + 1];
            for (int i = 0; i <= n; i++) {
                fa[i] = i;
                cnt[i] = 1;
            }
        }
        bool isroot(int x) {
            return x == fa[x];
        }
        int get(int x) {
            return (fa[x] = (x == fa[x] ? x : get(fa[x])));
        }
        void merge(int a, int b) { 
            int aa = get(a), bb = get(b);
            if (aa == bb) return ;
            fa[aa] = bb;
            cnt[bb] += cnt[aa];
            return ;
        }
        ~UnionSet() {
            delete[] fa;
            delete[] cnt;
        }
    };

    int longestConsecutive(vector<int>& nums) {
        UnionSet u(nums.size());
        unordered_map<int, int> h;
        for (int i = 0; i < nums.size(); i++) {
            if (h.find(nums[i]) != h.end()) continue;
            if (h.find(nums[i] - 1) != h.end()) {
                u.merge(i, h[nums[i] - 1]);
            }
            if (h.find(nums[i] + 1) != h.end()) {
                u.merge(i, h[nums[i] + 1]);
            }
            h[nums[i]] = i;
        }
        int ans = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (!u.isroot(i)) continue;
            ans = max(ans, u.cnt[i]);
        }
        return ans;
    }
};
130. 被围绕的区域

难度中等213

给定一个二维的矩阵，包含 'X' 和 'O'（字母 O）。

找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例:

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释:

被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

class Solution {
public:
    struct UnionSet {
        int *fa, *cnt;
        UnionSet(int n) {
            fa = new int[n + 1];
            cnt = new int[n + 1];
            for (int i = 0; i <= n; i++) {
                fa[i] = i;
                cnt[i] = 1;
            }
        }
        bool isroot(int x) {
            return x == fa[x];
        }
        int get(int x) {
            return (fa[x] = (x == fa[x] ? x : get(fa[x])));
        }
        void merge(int a, int b) { 
            int aa = get(a), bb = get(b);
            if (aa == bb) return ;
            fa[aa] = bb;
            cnt[bb] += cnt[aa];
            return ;
        }
        ~UnionSet() {
            delete[] fa;
            delete[] cnt;
        }
    };
    int n, m;
    int ind(int i, int j) {
        return (i * m) + j + 1;
    }
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0) return ;
        n = board.size();
        m = board[0].size();
        UnionSet u(n * m);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'X') continue;
                if (i && board[i - 1][j] == 'O') u.merge(ind(i, j), ind(i - 1, j));
                if (j && board[i][j - 1] == 'O') u.merge(ind(i, j), ind(i, j - 1));
                if (i == 0 || i == n - 1) u.merge(ind(i, j), 0);
                if (j == 0 || j == m - 1) u.merge(ind(i, j), 0);
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'X') continue;
                if (u.get(ind(i, j)) == u.get(0)) continue;
                board[i][j] = 'X';
            }
        }
        return ;
    }
};
200. 岛屿数量

难度中等573

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1:

输入:
11110
11010
11000
00000
输出: 1

示例 2:

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

class Solution {
public:
    struct UnionSet {
        int *fa, *cnt;
        UnionSet(int n) {
            fa = new int[n + 1];
            cnt = new int[n + 1];
            for (int i = 0; i <= n; i++) {
                fa[i] = i;
                cnt[i] = 1;
            }
        }
        bool isroot(int x) {
            return x == fa[x];
        }
        int get(int x) {
            return (fa[x] = (x == fa[x] ? x : get(fa[x])));
        }
        void merge(int a, int b) { 
            int aa = get(a), bb = get(b);
            if (aa == bb) return ;
            fa[aa] = bb;
            cnt[bb] += cnt[aa];
            return ;
        }
        ~UnionSet() {
            delete[] fa;
            delete[] cnt;
        }
    };
    int n, m;
    int ind(int i, int j) {
        return (i * m) + j + 1;
    }
    int numIslands(vector<vector<char>>& grid) {
        if (grid.size() == 0) return 0;
        n = grid.size();
        m = grid[0].size();
        UnionSet u(n * m);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == '0') continue;
                if (i && grid[i - 1][j] == '1') u.merge(ind(i, j), ind(i - 1, j));
                if (j && grid[i][j - 1] == '1') u.merge(ind(i, j), ind(i, j - 1));
            }
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == '0') continue;
                if (!u.isroot(ind(i, j))) continue;
                ans += 1;
            }
        }
        return ans;
    }
};
684. 冗余连接

难度中等109

在本问题中, 树指的是一个连通且无环的无向图。

输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。

返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。

示例 1：

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
  1
 / \
2 - 3

示例 2：

输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
    |   |
    4 - 3

注意:

  • 输入的二维数组大小在 3 到 1000。
  • 二维数组中的整数在1到N之间，其中N是输入数组的大小。
class Solution {
public:
    struct UnionSet {
        int *fa;
        UnionSet(int n) {
            fa = new int[n + 1];
            for (int i = 0; i <= n; i++) {
                fa[i] = i;
            }
            return ;
        }
        int get(int x) {
            return (fa[x] = (x - fa[x] ? get(fa[x]) : x));
        }
        int merge(int a, int b) {
            if (get(a) == get(b)) return 0;
            fa[get(a)] = get(b);
            return 1;
        }
    };

    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        UnionSet u(edges.size());
        vector<int> ret;
        for (int i = 0; i < edges.size(); i++) {
            int a = edges[i][0];
            int b = edges[i][1];
            if (u.merge(a, b)) continue;//联通时候
            ret.push_back(a);//不连通记录下来
            ret.push_back(b);//不连通记录下来
            break;
        }
        return ret;
    }
};
685. 冗余连接 II

难度困难62

在本问题中，有根树指满足以下条件的有向图。该树只有一个根节点，所有其他节点都是该根节点的后继。每一个节点只有一个父节点，除了根节点没有父节点。

输入一个有向图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。 每一个边 的元素是一对 [u, v]，用以表示有向图中连接顶点 u and v和顶点的边，其中父节点u是子节点v的一个父节点。

返回一条能删除的边，使得剩下的图是有N个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。

示例 1:

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的有向图如下:
  1
 / \
v   v
2-->3

示例 2:

输入: [[1,2], [2,3], [3,4], [4,1], [1,5]]
输出: [4,1]
解释: 给定的有向图如下:
5 <- 1 -> 2
     ^    |
     |    v
     4 <- 3

注意:

  • 二维数组大小的在3到1000范围内。
  • 二维数组中的每个整数在1到N之间，其中 N 是二维数组的大小。
class Solution {
public:
    struct UnionSet {
        int *fa, cnt;
        UnionSet(int n) {
            fa = new int[n + 1];
            for (int i = 0; i <= n; i++) {
                fa[i] = i;
            }
            cnt = n;
            return ;
        }
        int get(int x) {
            return (fa[x] = (x - fa[x] ? get(fa[x]) : x));
        }
        int merge(int a, int b) {
            if (get(a) == get(b)) return 0;
            cnt -= 1;
            fa[get(a)] = get(b);
            return 1;
        }
    }; 
    vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {
        int indeg[edges.size() + 1];
        int outdeg[edges.size() + 1];
        int fa[edges.size() + 1];
        int vis[edges.size() + 1];
        memset(indeg, 0, sizeof(indeg));
        memset(outdeg, 0, sizeof(outdeg));
        memset(fa, 0, sizeof(fa));
        memset(vis, 0, sizeof(vis));
        int flag = -1;
        for (int i = 0; i < edges.size(); i++) {
            int u = edges[i][0];
            int v = edges[i][1];
            indeg[v] += 1;
            outdeg[u] += 1;
            fa[v] = u; 
            if (indeg[v] == 2) flag = v;
        }
        if (flag != -1) {
            for (int i = edges.size() - 1; i >= 0; i--) {
                if (flag - edges[i][1]) continue;
                UnionSet u(edges.size());
                for (int j = 0; j < edges.size(); j++) {
                    if (i == j) continue;
                    u.merge(edges[j][0], edges[j][1]);
                }
                if (u.cnt != 1) continue;
                return edges[i];
            }
        }
        queue<int> q;
        for (int i = 1; i <= edges.size(); i++) {
            if (outdeg[i] == 0) q.push(i);
        }
        while (!q.empty()) {
            int ind = q.front();
            vis[ind] = 1;
            q.pop();
            outdeg[fa[ind]] -= 1;
            if (outdeg[fa[ind]] == 0) q.push(fa[ind]);
        }
        for (int i = edges.size() - 1; i >= 0; i--) {
            int u = edges[i][0];
            int v = edges[i][1];
            if (vis[u] || vis[v]) continue;
            return edges[i];
        }
        return edges[0]; // 没用的
    }
};
一.Leetcode刷题顺序
11-14 466
1.按照数据结构 数组和链表（二分查找，排序（初级排序（选择，插入，希尔），高级排序（归并，快速，优先队列）），双指针，滑动窗口）， 栈和队列（单调栈，单调队列，优先队列），树（二叉树, 二叉查找树， 平衡查找树，堆），图（无向图（DFS，BFS ），有向图，最小生成树（Prim,Kruskal）,最短路径（Dijkstra）），Hash 2.按照算法思想 递归，回溯，分治，贪心，动态规划（背包） ......
leetcode-刷题顺序推荐
weixin_38087674的博客
02-25 901
题目分类及刷题顺序推荐 一. 数组 题目分类 题目编号 数组的遍历 485、495、414、628 统计数组中的元素 645、697、448、442、41、274 数组的改变、移动 453、665、283 二维数组及滚动数组 118、119、661、598、419 数组的旋转 189、396 特定顺序遍历二维数组 54、59、498 二维数组变换 566、48、73、289 前缀和数组 303、304、238 题解 数组篇 二. 字符串 题目分类
leetcode刷题之并查集
zlgahu的博客
01-26 280
学习链接：https://zhuanlan.zhihu.com/p/93647900 三个关键点： 1）初始化底层数组，一般是若干个孤立的点。 2）合并连通域 3）查找每个连通域的代表元素。 性能优化： 1）路径压缩 即将当前节点的父节点设置成代表元（递归设置成父节点的父节点）。 2）秩合并 将秩小的的元素的代表元合并到秩大的代表元。 题目： 684. 冗余连接 对无向图类型的树而言，N个节点有N-1条边。如果有N条边，则有一条边加进来的时候会形成环。如果一条边在合并之前属于两个不.
128最长连续序列；684冗余连接；685冗余连接 II
Lifelong Learning Pan
05-17 181
给定一个未排序的整数数组，找出最长连续序列的长度。 要求算法的时间复杂度为 O(n)。 示例: 输入: [100, 4, 200, 1, 3, 2] 输出: 4 解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。 class Solution {//方法一：无序哈希表 public: int longestConsecutive(vector<int>& nums) { unordered_set<int> s(nums.be
LeetCode刷题--并查集
qq_43325216的博客
10-20 397
遍历外层数组，使用并查集将每个内层数组的两个节点merge，如果遍历过程中发现两个节点的root已经相同， 说明两个节点早就在一个集合里面，删除这个连接也不会影响，因此，这个边就是题目要寻找的边。并查集是一种典型的数据结构，用于处理一些不相交集合的合并和查询问题。给出的edges是一个二维数组，其中外层数组是两两关联的点，内层数组是连接的这两个点。一个无向图，找到可以删除的边，要求删除这个边后，剩下的n个节点是一个树。两个城市相连的时候怎么办？两个城市直接相连是1，不直接相连是0，题目用二维数组进行呈现。
leetcode-并查集
MaYingColdPlay的博客
06-04 820
leetcode-广度优先遍历/图/并查集_MaYingColdPlay的博客-CSDN博客 5941 找出知道秘密的所有专家 class UnionFind: def __init__(self, n): self.count = n self.parent = [i for i in range(n)] self.rank = [0] * n def find(self, i): if self...
1029-除法求值
LINZEYU666的博客
03-17 401
题目如下 给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。 另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。 返回所有问题的答案 。如果存在某个无法确定的答案，则
【Leetcode刷题】并查集
最新发布
m0_51976564的博客
04-29 453
原 Leetcode547.朋友圈 Leetcode128.最长连续序列 Leetcode399.除法求值 Leetcode684.冗余连接 Leetcode1061.按字典序排列最小的等效字符串
leetcode刷题笔记——并查集
md_Ji的博客
01-18 662
leetcode刷题笔记——并查集 目前完成的并查集相关的leetcode算法题序号： 中等：721 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reconstruct-itinerary 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 文章目录leetcode刷题笔记——并查集算法理解一、721题：账户合并1.题干2.思路3.代码4.总结 算法理解 并查集（union-find, 或disjoint set）可以动态地连
ACM金牌选手整理的【LeetCode刷题顺序】1
08-03
此外，还提到了并查集，如LeetCode 206的反转链表，虽然没有直接列出并查集的题目，但它的概念在解决连接和断开问题时经常被用到。 总的来说，这个刷题顺序全面覆盖了编程基础和进阶算法，是提高编程能力和准备算法...
LeetCode刷题攻略
Redemption___的博客
06-13 7377
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
leetcode刷题记录：算法（八）并查集(Union find)
qq_39561198的博客
11-10 529
并查集(Union find)： 在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。 我个人理解的人话就是： 将相关的元素并到一个集合里，在这个过程中要先查这些元素是不是已经在集合中 并查集分为三个部分 把每个点所在集合初始化为其自身。通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。 查找元素所在的集合，即根节点。 将两个元素所在的集合
leetcode 并查集
weixin_41964962的博客
03-05 822
并查集 并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作： Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。 Union：将两个子集合并成同一个集合。 由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-fi...
leetcode并查集
qq_35985044的博客
12-07 133
leetcode 547. Friend Circles class Solution { public: int findCircleNum(vector<vector<int>>& M) { int n = M.size(), res = 0; vector<int> father(n, 0); ...
LeetCode——并查集
ThreeAspects的博客
12-25 569
并查集的具体实现细节可参见：并查集及其应用，大多数的并查集的题目都可用一个板子解决。 200.岛屿数量（可用DFS/BFS/并查集） 399.除法求值
Leetcode-并查集
albyc22660的专栏
08-20 273
200.岛屿数量https://leetcode-cn.com/problems/number-of-islands/ 给定一个由'1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。 示例: 输入: 11000 11000 00100 00011 输...
LeetCode-并查集
码来-陈平安的博客
10-26 206
并查集 应用：判断两个节点是否连通，查找两个节点的最近公共节点；找出图成环的最后加入的一条边（最小生成树）。
LeetCode刷题总结——并查集
weixin_51335655的博客
09-25 1516
LeetCode刷题总结——并查集
LeetCode刷题顺序
Hello World
11-12 179
GitHub地址
Leetcode刷题修炼手册
热门推荐
Machine Learning with Tutors
01-25 5万+
我的机器学习教程「美团」算法工程师带你入门机器学习 已经开始更新了，欢迎大家订阅~ 任何关于算法、编程、AI行业知识或博客内容的问题，可以随时扫码关注公众号「图灵的猫」，加入”学习小组“，沙雕博主在线答疑~此外，公众号内还有更多AI、算法、编程和大数据知识分享，以及免费的SSR节点和学习资料。其他平台（知乎/B站）也是同名「图灵的猫」，不要迷路哦~ “跟着...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值
>