并查集

站长

2024年06月11日 23:34 · 阅读数 39

并查集（Union-Find）是一些树组织成的森林，也叫不相交集合（Disjoint-Sets）。Union 和 Find 是并查集中常用的两个操作，Disjoint-Sets 表示了并查集的数据形态，是一个一个的集合，它们没有公共元素，属于同一个集合的元素不计较顺序。

并查集用于：

处理不相交集合的 合并 与 查询 问题；
回答 动态连通性 问题。动态连通性是指：连通关系不是一开始就确定好的，需要根据已经连接的边的关系，决定接下来要连接哪些边。

并查集是树的集合

并查集通常来说是一些「树」的集合。和「堆」一样，并查集也是建立在数组上的树形结构。这是因为：并查集在实现的时候，结点的个数通常是确定的。并查集形成树的特点是：由 孩子结点指向父亲结点 ，从而形成一条边。

并查集主要提供了以下 2 个操作：

并：把两个集合「合并」成一个集合；
查：查询元素属于哪一个集合，可以顺便回答两个元素是否在一个集合中；

连通分量

定义：无向图的极大连通子图称为一个连通分量。

在生活中，「朋友圈」的概念就是连通分量的很好的体现。在一个朋友圈里的所有的人组成的集合就是一个连通分量，在一个朋友圈里任意两个人有一条路径连接，这条路径可以是直接的，也可以是间接的，并且好友关系是双向的。

「连通性」与「路径问题」

并查集只能回答两个结点是否「连接」，不能回答两个结点之间的路径是什么。正如优先队列（二叉堆）一样，完全可以通过「遍历当前队列里的所有元素得到最大（小）值」将最值出队，但是这样的操作复杂度太高。

「并查集」和「二叉堆」看起来不能够完美地回答一个问题，但它们的设计是恰到好处的。正是因为它们针对了一个特别的问题，设计了复杂度较低的算法，使得应用它们的问题能够得到高效的解决。

并查集的抽象数据类型

返回值	方法名	方法描述
构造函数无返回值	UnionFind(int N)	初始化并查集
void	union(int x, int y)	在 x 和 y 之间添加一条连接
int	find(int x)	返回 x 所在的连通分量的标识
boolean	isConnected(int x, int y)	如果 x 和 y 存在于同一个连通分量中则返回true
int	getCount()	返回连通分量的数量

并查集的两种实现思路

quick-find：顾名思义，这个思路查找是快速的，将数据组织成线性结构;
quick-union：这是常见的并查集的实现方式，将数据组织成树形结构;

quick-find 实现

并查集

quick-find 的设计思想在生活中并不少见：

在工作场合，我们会穿着指定的工作服，表明我们是同事关系；
情侣或孪生兄弟，会身着情侣装和相同的衣服；
古时候两军交战，双方士兵会身着不同颜色的战袍，以分清敌我；

quick-find 基于 id 的思想：给每一个组一个编号，这个编号称为 id ，如果两个元素的 id 一样，就认为它们同属于一个集合，时间复杂度为 O(1)。

要想合并两个组，就需要将它们的 id 设置成一样。在最差情况下，需要修改几乎整个数组元素的 id，时间复杂度为 O(N)。所以这一版并查集「查询」快，但是「合并」慢。

并查集

quick-union 实现

并查集

代表元法

在日常生活中也有这样场景：两个公司或者集团，他们宣布合并，但事实上他们的网站还是各自的网站，没有改名字，不同的是其中一个公司宣布成为另一个公司的子公司。并查集基于 quick-union 思想的实现也是类似的：

为每一个不相交的集合设置一个代表元素来标识这个元素。一开始和 quick-find 一样，所有的元素都是独立的。只要有发生合并，不是修改标识，而是把其中一个元素的根结点的链接指向另一个元素的根结点；
在这种合并的过程中，就形成一棵树又一棵树，这些树的特点是：没有公共结点，于是形象地被我们称为「森林」；
在查询的时候，一定要查询到结点所在树的根结点，根结点相同，才能够说明两个结点在一个集合中；

优化 1：按秩合并

并查集

树的问题，绝大多数情况下优化的方向是： 让树的高度更低

按秩合并 是指在「合并」两个集合的时候的两个参考依据：

根结点的树的结点个数 size；
根结点的树的高度 rank。

size

把 结点数 较少的树的根结点指向 结点数 较多的树的根结点。

rank

将高度较低树的根结点指向高度较高的树的根结点。

优化 2：路径压缩

路径压缩，是在「查找」的过程中，使得树的高度变得更低，这是并查集特有的操作：边查边改。依然是根据代表元法的设计思路：树的形态并不重要。基于这一点，在「查找」的过程中，可以顺便修改结点的指向，好让以后再查询的时候，能够更快地查找到某个结点所在的树的根结点。

路径压缩也有两种方式，它们是隔代压缩和完全压缩。

隔代压缩

让查询过程中经历的 部分结点 指向它的父亲结点的父亲结点。相对于「完全压缩」而言，压缩没有那么彻底。

find(x){
    while(x !== this.parent[x]) {
        parent[x] = parent[parent[x]];
        x = parent[x];
    }
    return x;
}

完全压缩

让查询根结点的过程中，沿途经过的 所有结点 指向都指向根结点。

find(x) {
    if (x !== this.parent[x]) {
        this.parent[x] = find(this.parent[x])
    }
    return this.parent[x]
}

比较

第 1 种虽然压缩不完全，但是这种压缩有些时候是恰到好处的：

首先，在代码层面相对好理解；
其次，在性能方面是胜于「完全压缩」的。这是因为「完全压缩」需要先从查询点开始遍历，一直遍历到根结点，然后再把沿途经过的结点指向根结点，有「一来一回」的过程，从查询结点到根结点的路径要走 2 次；
「隔代压缩」在循环中完成，而「完全压缩」需要借助递归，得遍历两次；

经验

「按秩合并」与「路径压缩」两个优化只使用一种就可以了，有些时候只写「路径压缩」就能得到一个不错的结果；
「按秩合并」与「路径压缩」同时使用的时候，「秩」的定义已经被破坏，但并不妨碍它作为合并的参考。可能会给出错误的答案，但绝大多数时候是对的；
没有必要维护秩的定义。首先，准确维护秩的定义很难，其次也没有必要，维护秩的定义有一定性能消耗：要做判断，要做数据的修改；
有些并查集问题即使「按秩合并」与「路径压缩」同时使用，时间依然消耗很多；

练习

冗余链接 - 中等

/**
 * @param {number[][]} edges
 * @return {number[]}
 */
var findRedundantConnection = function (edges) {
	const len = edges.length;
	const unionFind = new UnionFind(len);
	let result;
	for (let i = 0; i < len; i++) {
		const cur = edges[i];
		const data = unionFind.union(cur[0], cur[1]);
		result = data ? data : result;
	}
	return result;
};

class UnionFind {
	constructor(k) {
		this.parent = new Array(k).fill(null).map((el, idx) => idx);
	}
	find(index) {
		while (index != this.parent[index] && this.parent[index]) {
			this.parent[index] = this.parent[this.parent[index]];
			index = this.parent[index];
		}
		return index;
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		// 可删除
		if (idx === idy) return [x, y];

		if (idx < idy) {
			this.parent[idy] = idx;
		} else {
			this.parent[idx] = idy;
		}

		return null;
	}
}

连通网络的操作次数 - 中等

/**
 * @param {number} n
 * @param {number[][]} connections
 * @return {number}
 */
var makeConnected = function (n, connections) {
	const len = connections.length;
	const unionFind = new UnionFind(n);
	for (let i = 0; i < len; i++) {
		unionFind.union(connections[i][0], connections[i][1]);
	}
	return unionFind.result();
};
class UnionFind {
	constructor(k) {
		this.parent = new Array(k).fill(null).map((el, index) => index);
		// 多余的网线
		this.count = 0;
	}
	find(index) {
		while (index !== this.parent[index] && this.parent[index]) {
			this.parent[index] = this.parent[this.parent[index]];
			index = this.parent[index];
		}
		return this.parent[index];
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) {
			this.count++;
		} else if (idx < idy) {
			this.parent[idy] = idx;
		} else {
			this.parent[idx] = idy;
		}
	}
	result() {
		// 需要的网线
		let need = 0;
		for (let i = 0; i < this.parent.length; i++) {
			if (i === this.parent[i]) {
				need++;
			}
		}
		need--;
		return this.count >= need ? need : -1;
	}
}

等式方程的可满足性 - 中等

/**
 * @param {string[]} equations
 * @return {boolean}
 */
var equationsPossible = function (equations) {
	const len = equations.length;

	// 遍历一次，找出所有变量
	const data = [];
	const countMap = {};
	for (let i = 0; i < len; i++) {
		const cur = equations[i];
		const prev = cur[0];
		const next = cur[3];

		if (!countMap[prev]) {
			countMap[prev] = true;
			data.push(prev);
		}

		if (!countMap[next]) {
			countMap[next] = true;
			data.push(next);
		}
	}

	console.log("data", data);
	const unionFind = new UnionFind(data.length, data);

	const unequal = [];
	for (let i = 0; i < len; i++) {
		const cur = equations[i];
		const prev = cur[0];
		const next = cur[3];
		const sign = cur[1];

		// 合并
		if (sign === "=") {
			unionFind.union(data.indexOf(prev), data.indexOf(next));

			// 不等式过滤
		} else {
			unequal.push([data.indexOf(prev), data.indexOf(next)]);
		}
	}

	for (let i = 0; i < unequal.length; i++) {
		if (!unionFind.isSame(unequal[i][0], unequal[i][1])) {
			return false;
		}
	}

	return true;
};

class UnionFind {
	constructor(len, data) {
		this.parent = new Array(len).fill(null).map((el, index) => index);
		this.data = data;
	}
	find(index) {
		while (index !== this.parent[index]) {
			index = this.parent[index];
		}
		return index;
	}
	union(prevIndex, nextIndex) {
		const prev = this.find(prevIndex);
		const next = this.find(nextIndex);

		if (prev === next) return;
		if (this.data[prev].charCodeAt() > this.data[next].charCodeAt()) {
			this.parent[prev] = next;
		} else {
			this.parent[next] = prev;
		}
	}
	isSame(prevIndex, nextIndex) {
		const prev = this.find(prevIndex);
		const next = this.find(nextIndex);

		console.log("isSame", prevIndex, nextIndex, prev, next);
		if (prev === next) return false;
		return true;
	}
}

最长连续序列 - 中等

/**
 * @param {number[]} nums
 * @return {number}
 */
var longestConsecutive = function (nums) {
	const len = nums.length;

	if (!len) return 0;

	const map = {};

	const uf = new UnionFind(nums);
	for (let i = 0; i < len; i++) {
		const cur = nums[i];

		if (map[cur] === undefined) {
			map[cur] = i;
		} else {
			continue;
		}

		if (map[cur + 1] !== undefined) {
			uf.union(i, map[cur + 1]);
		}

		if (map[cur - 1] !== undefined) {
			uf.union(i, map[cur - 1]);
		}
	}

	return uf.getMaxSize();
};

class UnionFind {
	constructor(data) {
		this.data = data;
		this.parent = new Array(data.length).fill(null).map((el, index) => index);
		this.size = new Array(data.length).fill(1);
	}
	find(x) {
		while (x !== this.parent[x]) {
			x = this.parent[x];
		}
		return x;
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;

		if (this.data[idy] > this.data[idx]) {
			this.parent[idy] = idx;
			this.size[idx] += this.size[idy];
		} else if (this.data[idy] < this.data[idx]) {
			this.parent[idx] = idy;
			this.size[idy] += this.size[idx];
		}
	}
	getMaxSize() {
		let max = 1;
		console.log(this.parent, this.size);
		for (let i = 0; i < this.size.length; i++) {
			max = Math.max(max, this.size[i]);
		}
		return max;
	}
}

按公因数计算最大组件大小 - 困难

/**
 * @param {number[]} nums
 * @return {number}
 */
var largestComponentSize = function (nums) {
	const len = nums.length;
	if (len === 1) return 1;

	const uf = new Uf(nums);
	const primeToIndexMap = new Map();

	for (let i = 0; i < len; i++) {
		const factors = getPrimeFactors(nums[i]);
		for (const factor of factors) {
			if (!primeToIndexMap.has(factor)) {
				primeToIndexMap.set(factor, i);
			} else {
				uf.union(i, primeToIndexMap.get(factor));
			}
		}
	}

	return uf.getMaxSize();
};

class Uf {
	constructor(data) {
		const len = data.length;
		this.data = data;
		this.parent = new Array(len).fill(null).map((el, index) => index);
		this.size = new Array(len).fill(1);
		this.max = 1; // 初始值应为1，因为最小的集合大小为1
	}

	gcd(a, b) {
		return b === 0 ? a : this.gcd(b, a % b);
	}

	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;

		this.parent[idx] = idy;
		this.size[idy] += this.size[idx];

		this.max = Math.max(this.max, this.size[idy]);
	}

	find(x) {
		while (x !== this.parent[x]) {
			this.parent[x] = this.parent[this.parent[x]];
			x = this.parent[x];
		}
		return this.parent[x];
	}

	getMaxSize() {
		return this.max;
	}
}

function getPrimeFactors(num) {
	const factors = new Set();
	while (num % 2 === 0) {
		factors.add(2);
		num = Math.floor(num / 2);
	}
	for (let i = 3; i <= Math.sqrt(num); i += 2) {
		while (num % i === 0) {
			factors.add(i);
			num = Math.floor(num / i);
		}
	}
	if (num > 2) {
		factors.add(num);
	}
	return factors;
}

岛屿数量 - 中等

/**
 * @param {character[][]} grid
 * @return {number}
 */
var numIslands = function (grid) {
	const len1 = grid.length;
	const len2 = grid[0].length;
	const k = len1 * len2;
	const uf = new Uf(k + 1);
	for (let i = 0; i < len1; i++) {
		for (let j = 0; j < len2; j++) {
			const cur = grid[i][j];
			if (cur === "1") {
				if (grid?.[i]?.[j + 1] === "1") {
					uf.union(len2 * i + j, len2 * i + j + 1);
				}
				if (grid?.[i + 1]?.[j] === "1") {
					uf.union(len2 * i + j, len2 * (i + 1) + j);
				}
			} else {
				uf.union(len2 * i + j, k);
			}
		}
	}
	return uf.count - 1;
};

class Uf {
	constructor(k) {
		this.parent = new Array(k).fill(null).map((el, index) => index);
		this.count = k;
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;
		this.parent[idx] = idy;
		this.count--;
	}
	find(x) {
		while (x != this.parent[x]) {
			this.parent[x] = this.parent[this.parent[x]];
			x = this.parent[x];
		}
		return x;
	}
}

被围绕的区域 - 中等

/**
 * @param {character[][]} board
 * @return {void} Do not return anything, modify board in-place instead.
 */
var solve = function (board) {
	const len1 = board.length;
	const len2 = board[0].length;
	const k = len1 * len2;
	const uf = new Uf(k + 1, board, len1, len2);

	for (let i = 0; i < len1; i++) {
		for (let j = 0; j < len2; j++) {
			if (board?.[i]?.[j] === "O") {
				// 处于上下左右边界
				if (i === 0 || i === len1 - 1 || j === 0 || j === len2 - 1) {
					uf.union(i * len2 + j, k);
					continue;
				}

				// 右边0
				if (board[i][j + 1] === "O") {
					uf.union(i * len2 + j, i * len2 + j + 1);
				}

				// 左边0
				if (board[i][j - 1] === "O") {
					uf.union(i * len2 + j, i * len2 + j - 1);
				}

				// 下边0
				if (board[i + 1][j] === "O") {
					uf.union((i + 1) * len2 + j, i * len2 + j);
				}

				// 上边0
				if (board[i - 1][j] === "O") {
					uf.union((i - 1) * len2 + j, i * len2 + j);
				}
			}
		}
	}

	return uf.result();
};

class Uf {
	constructor(k, data, len1, len2) {
		this.k = k;
		this.data = data;
		this.len1 = len1;
		this.len2 = len2;
		this.parent = new Array(k).fill(null).map((el, index) => index);
	}
	find(x) {
		if (x != this.parent[x]) {
			this.parent[x] = this.find(this.parent[x]);
		}
		return this.parent[x];
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;

		const rowx = Math.floor(idx / this.len2);
		const colx = idx % this.len2;

		const rowy = Math.floor(idy / this.len2);
		const coly = idy % this.len2;

		if (idx == this.k - 1) {
			this.parent[idy] = idx;
			return;
		} else if (idy === this.k - 1) {
			this.parent[idx] = idy;
			return;
		}

		if (this.data[rowx][colx] > this.data[rowy][coly]) {
			this.parent[idy] = idx;
		} else {
			this.parent[idx] = idy;
		}
	}
	result() {
		for (let i = 0; i < this.parent.length - 1; i++) {
			let x = i;

			while (x != this.parent[x]) {
				x = this.parent[x];
			}

			const row = Math.floor(i / this.len2);
			const col = i % this.len2;

			if (this.data[row][col] === "O") {
				if (this.parent[x] !== this.k - 1) {
					this.data[row][col] = "X";
				}
			}
		}
		return this.data;
	}
}

由斜杠划分区域 - 中等

/**
 * @param {string[]} grid
 * @return {number}
 */
var regionsBySlashes = function (grid) {
	const n = grid.length;

	// n * 2n2的矩阵
	const uf = new Uf(n * n * 2);

	for (let i = 0; i < n; i++) {
		const cur = grid[i];
		for (let j = 0; j < n; j++) {
			const leftIndex = i * (2 * n) + j * 2;
			const rightIndex = i * (2 * n) + (2 * j + 1);
			// 因为是从上到下，左到右遍历，因此只能合并左和上元素

			switch (cur[j]) {
				case " ":
					uf.union(leftIndex, rightIndex);
					// 靠左
					// 存在左元素
					if (j - 1 >= 0) {
						uf.union(leftIndex, leftIndex - 1);
					}
					// 存在上元素
					if (i - 1 >= 0) {
						if (grid[i - 1][j] === "\") {
							uf.union(leftIndex, (i - 1) * (2 * n) + j * 2);
						} else {
							uf.union(leftIndex, (i - 1) * (2 * n) + j * 2 + 1);
						}
					}

					break;
				case "/":
					// 靠左
					// 存在左元素
					if (j - 1 >= 0) {
						uf.union(leftIndex, leftIndex - 1);
					}
					// 存在上元素
					if (i - 1 >= 0) {
						if (grid[i - 1][j] === "\") {
							uf.union(leftIndex, (i - 1) * (2 * n) + j * 2);
						} else {
							uf.union(leftIndex, (i - 1) * (2 * n) + j * 2 + 1);
						}
					}

					break;
				case "\":
					// 靠左
					// 存在左元素
					if (j - 1 >= 0) {
						uf.union(leftIndex, leftIndex - 1);
					}

					// 靠右
					// 存在上元素
					if (i - 1 >= 0) {
						if (grid[i - 1][j] === "\") {
							uf.union(rightIndex, (i - 1) * (2 * n) + j * 2);
						} else {
							uf.union(rightIndex, (i - 1) * (2 * n) + j * 2 + 1);
						}
					}

					break;
			}
		}
	}

	return uf.count;
};

class Uf {
	constructor(k) {
		this.parent = new Array(k).fill(0).map((el, index) => index);
		this.count = k;
	}
	find(x) {
		// 完全路径压缩，全部指向根节点
		if (x != this.parent[x]) {
			this.parent[x] = this.find(this.parent[x]);
		}
		return this.parent[x];
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;

		// 指向更大的节点
		if (this.parent[idx] > this.parent[idy]) {
			this.parent[idy] = idx;
		} else {
			this.parent[idx] = idy;
		}

		this.count--;
	}
}

除法求值 - 中等

/**
 * @param {string[][]} equations
 * @param {number[]} values
 * @param {string[][]} queries
 * @return {number[]}
 */
var calcEquation = function (equations, values, queries) {
	const sMap = new Map();
	let index = 0;
	for (let i = 0; i < equations.length; i++) {
		const one = sMap.get(equations[i][0]);
		const two = sMap.get(equations[i][1]);
		if (!one) {
			sMap.set(equations[i][0], index);
			index++;
		}
		if (!two) {
			sMap.set(equations[i][1], index);
			index++;
		}
	}

	const uf = new Uf(index);

	for (let i = 0; i < equations.length; i++) {
		const x = sMap.get(equations[i][0]);
		const y = sMap.get(equations[i][1]);
		uf.union(x, y, values[i]);
	}

	const result = [];
	for (let i = 0; i < queries.length; i++) {
		const x = sMap.get(queries[i][0]);
		const y = sMap.get(queries[i][1]);

		const idx = uf.find(x);
		const idy = uf.find(y);

		if (x === undefined || y === undefined) {
			result.push(-1);
			continue;
		}

		// 如果不是同一集合
		if (uf.getParent(x) !== uf.getParent(y)) {
			result.push(-1);

			// 同一集合
		} else {
			// 分母是根节点
			if (y === idy) {
				result.push(uf.weight[x]);
				continue;
			}
			// 分子是根节点
			if (x === idx) {
				result.push(1 / uf.weight[y]);
				continue;
			}

			result.push(uf.weight[x] / uf.weight[y]);
		}
	}

	return result;
};

class Uf {
	constructor(len) {
		this.parent = new Array(len).fill(0).map((el, index) => index);
		this.weight = new Array(len).fill(1); // 值
	}
	find(x) {
		if (x !== this.parent[x]) {
			let origin = this.parent[x];
			this.parent[x] = this.find(this.parent[x]);
			this.weight[x] *= this.weight[origin];
		}
		return this.parent[x];
	}
	union(x, y, w) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;
		this.parent[idx] = idy;
		this.weight[idx] = (w * this.weight[y]) / this.weight[x];
	}
	getParent(x) {
		return this.find(x);
	}
}

冗余连接 II - 困难

/**
 * @param {number[][]} edges
 * @return {number[]}
 */
var findRedundantDirectedConnection = function (edges) {
	const n = edges.length;
	const uf = new Uf(n);
	for (let i = 0; i < n; i++) {
		const x = edges[i][0];
		const y = edges[i][1];

		uf.union(x, y);
	}

	if (uf.result1 && !uf.result2) return uf.result1;
	if (!uf.result1 && uf.result2) return uf.result2;

	return [uf.parent[uf.result1[1]], uf.result1[1]];
};

class Uf {
	constructor(k) {
		this.parent = new Array(k + 1).fill(null).map((el, index) => index);
		this.result1 = null; // 冲突的边
		this.result2 = null; // 导致环形的边
	}
	find(x) {
		while (x !== this.parent[x]) {
			x = this.parent[x];
		}
		return x;
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		// 当前已有父节点
		if (idy !== y) {
			this.result1 = [x, y];
			return;
		}

		// 导致环
		if (idx === idy) {
			this.result2 = [x, y];
			return;
		}

		this.parent[y] = x;
	}
}

情侣牵手 - 困难

/**
 * @param {number[]} row
 * @return {number}
 */
var minSwapsCouples = function (row) {
	const len = row.length;
	const uf = new Uf(len / 2);
	for (let i = 0; i < len; ) {
		const left = Math.floor(row[i] / 2);
		const right = Math.floor(row[i + 1] / 2);
		uf.union(left, right);
		i += 2;
	}
	const map = {};
	for (let i = 0; i < len / 2; i++) {
		const data = uf.find(i);
		if (map[data] !== undefined) {
			map[data] += 1;
		} else {
			map[data] = 0;
		}
	}

	let ret = 0;
	for (const value of Object.values(map)) {
		ret += value;
	}
	return ret;
};

class Uf {
	constructor(l) {
		this.parent = new Array(l).fill(0).map((el, idx) => idx);
	}
	find(x) {
		if (x !== this.parent[x]) {
			this.parent[x] = this.find(this.parent[x]);
		}
		return this.parent[x];
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);

		if (idx === idy) return;

		this.parent[idx] = idy;
	}
}

连接所有点的最小费用 - 中等

/**
 * @param {number[][]} points
 * @return {number}
 */
var minCostConnectPoints = function (points) {
	const len = points.length;
	const disList = [];
	for (let i = 0; i < len - 1; i++) {
		for (let j = i + 1; j < len; j++) {
			disList.push([dist(points[i], points[j]), i, j]);
		}
	}
	disList.sort((a, b) => a[0] - b[0]);

	const uf = new Uf(len);

	let result = 0;
	let count = 1;
	for (const [dist, x, y] of disList) {
		if (uf.union(x, y)) {
			result += dist;
			count++;
			if (count === len) break;
		}
	}

	return result;
};

class Uf {
	constructor(k) {
		this.parent = new Array(k).fill(0).map((el, idx) => idx);
	}
	find(x) {
		if (x !== this.parent[x]) {
			this.parent[x] = this.find(this.parent[x]);
		}
		return this.parent[x];
	}
	union(x, y) {
		const idx = this.find(x);
		const idy = this.find(y);
		if (idx === idy) return false;
		this.parent[idx] = y;
		return true;
	}
}

const dist = (x, y) => {
	return Math.abs(y[0] - x[0]) + Math.abs(y[1] - x[1]);
};

转载自:https://juejin.cn/post/7376459064267112460