并查集(Union-find)及经典问题

最新推荐文章于 2024-11-09 21:51:15 发布
最新推荐文章于 2024-11-09 21:51:15 发布
阅读量91 收藏
点赞数
文章标签： 算法 数据结构 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45061460/article/details/132090627
版权

并查集的基础知识

Quick-Find算法

染色方法：

  1. 基于染色的思想，一开始所有点的颜色不同
  2. 连接两个点的操作，可以看成将一种颜色的点染成另一种颜色
  3. 如果两个点颜色一样，证明联通，否则不联通
  4. 这中方法叫做并查集的：【Quick-Find 算法】
    联通判断O(1) 合并操作O(n)
class UnionSet {
public: 
	int *color, n;
	UnionSet(int n): n(n){
		color = new int[n + 1];
		for(int i = 0; i <= n; i++){
			color[i] = i;
		}
	}
	int find(int x){
		return color[x];
	}
	void merge(int a, int b){
		if(color[a] === color[b]) return;
		int cb = color[b];
		for(int i = 0;i <= n; i++){
			if(color[i] === cb) color[i] = color[a];
		}
		return;
	}
}
int main(){
	
	return 0;
}
  1. quick-find算法的联通判断非常快，可是合并操作非常慢
  2. 本质上问题中只是需要知道一个点与哪些点的颜色相同
  3. 而若干点的颜色可以通过间接指向同一个节点
  4. 合并操作时，实际上是将一棵树作为另一棵树的子树

Quick-Union算法

使用树型结构
联通判断 与tree-height 树高有关 合并操作O(n) 与tree-height 树高有关

class UnionSet {
public:
	int *boss, n;
	UnionSet(int n): n(n){
		boss = new int[n + 1];
		for(int i = 0; i <= n ; i++){
			boss[i] = i;
		}
	}
	int find(int x){
		if(boss[x] === x) return x;
		return find(boss[x]);
	}
	void merge(int a, int b){
		int fa = find(a), fb = find(b);
		if(fa === fb) return;
		boss[fa] = fb;
		return;
	}
}
int main(){
	return;
}

有效的减少树高能够提高效率

  1. 极端情况下会退化成一条链
  2. 将节点数量多的接到少的树上面，导致了退化
  3. 将树高深的接到浅的上面，导致了退化

问题：若要改进，是按照节点数量还是按照树的高度为合并参考？
指标：平均查找次数 = 所有节点的深度数量相加/ 总节点数量
节点少的作为儿子，节点多的作为爸爸

优化后：

class UnionSet {
public:
	int *fa, *size, n;
	UnionSet(int n): n(n){
		fa = new int[n + 1];
		size = new int[n + 1];
		for(int i = 0; i <= n; i++){
			fa[i] = i;
			size[i] = 1;
		}
	}
	int find(int x){
		if(fa[x] == x) return x;
		return find(fa[x]);
	}
	void merge(int a, int b){
		int ra = find(a), rb = find(b);
		if(ra == rb) return;
		if(size[ra] < size[rb]){
			fa[ra] = rb;
			size[rb] += size[ra];
		}else{
			fa[rb] = ra;
			size[ra] += size[rb];
		}
		return;
	}
}
int main(){
	return;
}

对树进行扁平化操作，让效率变高

class UnionSet {
public:
	int *fa, *size, n;
	UnionSet(int n): n(n){
		fa = new int[n + 1];
		size = new int[n + 1];
		for(int i = 0; i <= n; i++){
			fa[i] = i;
			size[i] = 1;
		}
	}
	int find(int x){
		if(fa[x] == x) return x;
		int root = find(fa[x]);
		fa[x] = root;
		return root;
	}
	void merge(int a, int b){
		int ra = find(a), rb = find(b);
		if(ra == rb) return;
		if(size[ra] < size[rb]){
			fa[ra] = rb;
			size[rb] += size[ra];
		}else{
			fa[rb] = ra;
			size[ra] += size[rb];
		}
		return;
	}
}
int main(){
	return;
}

并查集模版代码

class UnionSet {
public:
	int *fa, n;
	UnionSet(int n): n(n){
		fa = new int[n + 1];
		for(int i = 0;i <= n; i++){
			fa[i] = i;
		}
	}
	int get(int x){
		return fa[x] = (fa[x] == x ? x : get(fa[x]));
	}
	void merge(int a, int b){
		fa[get(a)] = get(b);
	}
};

int main(){
	return 0;
}

百变大咖：并查集
并查集是一类抽象化程度很高的数据结构

经典面试题 - 并查集基础题目

547. 省份数量


class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };

    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        UnionSet u(n);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < i; j++){
                if(isConnected[i][j]) u.merge(i, j);
            }
        }
        int ans = 0;
        for(int i = 0; i < n; i++){
            if(u.get(i) == i) ans += 1;
        }
        return ans;
    }
};

200.岛屿数量

  • 如果当前点和上面的点都是1，就把当前点和上面的点进行联通
  • 如果当前点和左边的点都是1，就把当前点和左边的点进行联通
  • 最后统计并查集中根节点的数量
class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };

    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        UnionSet u(n * m);
        #define ind(i, j) ((i) * m + (j))
        for(int i = 0 ; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == '0') continue;
                if(i > 0 && grid[i - 1][j] == '1') u.merge(ind(i, j), ind(i - 1, j));
                if(j > 0 && 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] == '1' && u.get(ind(i, j)) == ind(i, j)) ans += 1;
            }
        }
        #undef ind;
        return ans;
    }
};

990. 等式方程的可满足性

class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };
    bool equationsPossible(vector<string>& equations) {
        UnionSet u(26);
        for(auto s: equations){
            if(s[1] == '!') continue;
            int a = s[0] - 'a';
            int b = s[3] - 'a';
            u.merge(a, b);
        }
        for(auto s: equations){
            if(s[1] == '=') continue;
            int a = s[0] - 'a';
            int b = s[3] - 'a';
            if (u.get(a) == u.get(b)) return false;
        }
        return true;
    }
};

684. 冗余连接

class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };

    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
        UnionSet u(edges.size());
        for(auto e: edges){
            int a = e[0];
            int b = e[1];
            if(u.get(a) == u.get(b)) return e;
            u.merge(a, b);
        }
        return vector<int>();
    }
};

1319. 连通网络的操作次数

class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };
    int makeConnected(int n, vector<vector<int>>& connections) {
        if(connections.size() < n - 1) return -1;
        UnionSet u(n);
        for(auto e: connections){
            int a = e[0];
            int b = e[1];
            u.merge(a, b);
        }
        int cnt = 0;
        for(int i = 0; i < n; i++){
            if(u.get(i) == i) cnt += 1;
        }
        return cnt - 1;
    }
};

128. 最长连续序列


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

    int longestConsecutive(vector<int>& nums) {
        unordered_map<int, int> ind;
        UnionSet u(nums.size());
        for(int i = 0; i < nums.size(); i++){
            int x = nums[i];
            if(ind.find(x) != ind.end()) continue;
            if(ind.find(x - 1) != ind.end()){
                u.merge(i, ind[x - 1]);
            }
            if(ind.find(x + 1) != ind.end()){
                u.merge(i, ind[x + 1]);
            }
            ind[x] = i;
         
        }
        int ans = 0;
        for(int i = 0;i < nums.size(); i++){
            if(u.get(i) == i && u.cnt[i] > ans) ans = u.cnt[i];
        }
        return ans;
    }
};

947. 移除最多的同行或同列石头

class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };

    int removeStones(vector<vector<int>>& stones) {
        UnionSet u(stones.size());
        unordered_map<int, int> ind_x, ind_y;
        for(int i = 0; i < stones.size(); i++){
            int x = stones[i][0];
            int y = stones[i][1];
            if(ind_x.find(x) != ind_x.end()){
                u.merge(i, ind_x[x]);
            }
            if(ind_y.find(y) != ind_y.end()){
                u.merge(i, ind_y[y]);
            }
            ind_x[x] = i;
            ind_y[y] = i;
        }
        int cnt = 0;
        for(int i = 0; i < stones.size(); i++){
            if(u.get(i) == i) cnt += 1;
        }
        return stones.size() - cnt;
    }
};

1202. 交换字符串中的元素

class Solution {
public:
    class UnionSet {
    public:
        int *fa, n;
        UnionSet(int n): n(n){
            fa = new int[n + 1];
            for(int i = 0;i <= n; i++){
                fa[i] = i;
            }
        }
        int get(int x){
            return fa[x] = (fa[x] == x ? x : get(fa[x]));
        }
        void merge(int a, int b){
            fa[get(a)] = get(b);
        }
    };

    string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
        UnionSet u(s.size());
        priority_queue<char, vector<char>, greater<char>> h[s.size()];
        for(auto p: pairs){
            int i = p[0];
            int j = p[1];
            u.merge(i, j);
        }
        for(int i = 0; i< s.size(); i++ ){
            h[u.get(i)].push(s[i]);
        }
        string ret = "";
        for(int i = 0; i < s.size(); i++){
            ret += h[u.get(i)].top();
            h[u.get(i)].pop();
        }
        return ret;
    }
};
欢欢学编程
关注
并查集（Union-Find）
小朱小朱绝不认输的博客
05-26 1406
并查集是一种巧妙的算法思想，主要解决连通性问题的场景，比如：一组对象被划分成了若干个区域，求解被划分区域的数量，或者求解如何将这几个区域连接起来。 文章目录1. 并查集（Union-Find）算法介绍1.1 动态连通性1.2 union-find算法API2 union-find的实现2.1 quick-find算法2.2 quick-union算法2.3 加权quick-union算法2.4 使用路径压缩的加权quick-union算法2.5 算法比较 1. 并查集（Union-Find）算法介绍 1.1
并查集（union-find）算法理解
Joemt
12-08 651
在图像处理中，往往会遇到连通域判断的情况，而在处理过程中往往是利用并查集（union-find）算法。 并查集（Union-Find）是解决动态连通性问题的一类非常高效的数据结构。并查集主要分为两个过程；1、查，2、并。查主要目的是查找满足联通的点，并主要目的是将查到的点合并到连通域中。 并查集有三种常见算法：quick-find、quick-union、加权quick-union，其中检测速度也...
并查集(Union-Find) (图文详解)
热门推荐
qq_57469718的博客
06-22 1万+
并查集 数据结构 算法 Leetcode
数据结构与算法——并查集（Union-Find）
jay_zzs的博客
09-03 607
1. 原理/概念 并查集（Union-Find）主要用来解决无向图的【动态连通性】问题，对于无向图的连通，一般具有如下几个性质： 自反性：节点p和 p 是连通的； 对称性：如果节点 p 和节点 q 连通，那么节点 q 和 p 也是连通的； 传递性：如果节点 p 和 q 连通， q 和 r 连通，那么 p 和 r 连通。 本文参考一个大神labuladong的算法小抄：Union-Find算法详解，主页在这。 注意，并查集只能用来解决无向图的连通性的问题，如果是有向图，要找其强连通分量，需要用t..
【Leetcode】并查集（Union-Find）算法
小朱小朱绝不认输的博客
05-27 2345
在并查集（Union-Find）中学习了并查集算法的原理以及几种算法实现。 下面通过leetcode的算法题来具体使用并查集（Union-Find）算法。 文章目录Union-Find模板1. 使用路径压缩的加权quick-union算法2. quick-union算法1319. 连通网络的操作次数1. 题目描述2. 思路分析3. 代码实现547. 省份数量1. 题目描述2. 思路分析3. 代码实现 Union-Find模板 1. 使用路径压缩的加权quick-union算法 class UF{
并查集(Union-Find)算法全面详解
行走
06-25 6673
一、前言 在看一个算法题时，其中一种解法用到了并查集，并查集在《算法第四版——1.5案例研究： union-find 算法》中有讲解，这里按照自己的理解记录一下并查集。 二、用途 并查集用于判断连个点所在的集合是否属于同一个集合，若属于同一个集合但还未合并则将两个集合进行合并。同一个集合的意思是这两个点是连通的，直接相连或者通过其它点连通。 三、什么是并查集 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在..
并查集算法 | Union-Find Algorithm
嗅探网的博客
09-06 719
Union-Find Algorithm即并查集算法，常用于解决 动态连通性，判断有向无圈图等问题。根本上讲，Union-Find算法就和他的名字一样是一种对不相交集数据结构执行两个有用操作的算法，不相交集数据结构是跟踪一组元素的数据结构，这些元素被划分为多个不相交（非重叠）子集。在这篇文章中，我们将讨论不相交集数据结构的应用。该应用是检查给定图形是否包含循环。我们跟踪一维数组中的子集，我们称之为 parent[]。以下图为例：对于每条边，用边的两个顶点制作子集。
数据结构之并查集Union-Find Sets
GarfieldEr007的专栏
03-28 1322
1、  概述 并查集（Disjoint set或者Union-find set）是一种树型的数据结构，常用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。 2、  基本操作 并查集是一种非常简单的数据结构，它主要涉及两个基本操作，分别为： A． 合并两个不相交集合 B． 判断两个元素是否属于同一个集合 （1）       合并两个不相
并查集（Union-Find）介绍
Songxianshengbei的博客
04-12 640
首先，我们将每台计算机看作一个独立的集合，然后使用并查集的联合操作将相连的计算机合并到同一个集合中。按秩合并的思想是，在合并两个集合时，将秩（树的高度）较小的树连接到秩较大的树下，从而尽量保持树的平衡，减小树的高度。路径压缩的思想是在查找的过程中，直接将查找路径上的每个节点直接连接到根节点上，从而减小树的高度，提高后续查找的效率。树的根节点代表该集合，每个节点都包含其父节点的引用。在实际情况中，经过优化的并查集通常具有接近常数的查找和联合时间复杂度，这使得并查集在处理大规模数据集时具有非常高的效率。
[算法系列] 数据结构并查集union-find sets多图详解：介绍+2种实现+多种优化
lawfree的博客
05-28 1664
1. 为什么会有并查集？并查集做啥用的？ 假设有n个村庄，有些村庄之间有连接的路，有些村庄之间没有： 设计一个数据结构，能够快速执行2个操作 查询2个村庄之间是否有连接的路 连接2个村庄 对于上面这两个需求，可以用我们已知的一些数据结构进行完成（数组、链表、平衡二叉树、集合），比如用一个数组维护所有有连接的村庄。不过这样查询find和连接union的时间复杂度都为O（n）级别的。 而并查集就是专门做这两件事的数据结构：“并”union 和 “查” find 并且其查询、连接的均摊时间复杂度最佳可优化
并查集（Union-Find）介绍.zip
04-12
并查集（Union-Find）是一种用于处理连接关系的数据结构，它在计算机科学中有着广泛的应用，尤其是在图论、算法设计以及数据结构的学习中。这个数据结构的主要目标是高效地解决“查找”和“合并”两个操作，常用于...
数据结构：并查集 Union-Find算法(不相交集)原理及C++实现.zip
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
PCA（主成分分析）算法的应用场景
最新发布
huanfeng_AI的博客
11-09 150
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 108
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 344
Leetcode 160. 相交链表
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 736
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
二叉树(一)
m0_74340589的博客
11-05 452
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 840
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
JavaCV 图像边缘检测 之 Sobel算子 算法
欢迎拜读我的作品，喜欢的领域请给我留言
11-04 1568
JavaCV 是一个基于 OpenCV 和 FFmpeg 的 Java 计算机视觉库。它提供了对各种计算机视觉算法和图像处理功能的访问，包括图像读取、处理、显示，以及视频处理等。JavaCV 封装了底层的 C/C++ 库，使得在 Java 中进行计算机视觉开发更加方便快捷。本文详细介绍了JavaCV中的Sobel 算子在边缘检测中的应用。从Sobel 算子的原理出发，阐述了一阶导数与边缘检测的关系，以及Sobel 算子的卷积核和边缘检测过程。接着介绍了JavaCV的简介和Maven。
并查集(Union-Find)算法深度解析
Union-Find算法，也称为并查集，是一种用于处理动态连通性问题的数据结构。在图论中，动态连通性问题指的是我们需要快速判断两个节点是否在同一个连通分量（即两节点间存在路径）中，以及在操作过程中能够合并两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值