通过以上例子可知，并查集一般可以解决一下问题：
1. 查找元素属于哪个集合
沿着数组表示树形关系以上一直找到根(即：树中中元素为负数的位置)
2. 查看两个元素是否属于同一个集合
沿着数组表示的树形关系往上一直找到树的根，如果根相同表明在同一个集合，否则不在
3. 将两个集合归并成一个集合
将两个集合中的元素合并
将一个集合名称改成另一个集合的名称

4. 集合的个数 
遍历数组，数组中元素为负数的个数即为集合的个数。

并查集主要支持以下三种基本操作：

1. 查找（Find）：确定一个元素属于哪个集合。
2. 合并（Union）：将两个集合合并为一个集合。
3. 初始化（Init）：为每个元素创建一个独立的集合。

class UnionFindSet
{
public:
	// 初始时，将数组中元素全部设置为-1
	UnionFindSet(size_t size)
		: _ufs(size, -1)
	{}
	// 给一个元素的编号，找到该元素所在集合的名称
	int FindRoot(int index)
	{
			// 如果数组中存储的是负数，找到，否则一直继续
			while (_ufs[index] >= 0)
			{
				index = _ufs[index];
			}

		return index;
	}
	bool Union(int x1, int x2)
	{
		int root1 = FindRoot(x1);
		int root2 = FindRoot(x2);

		// x1已经与x2在同一个集合
		if (root1 == root2)
			return false;

		// 将两个集合中元素合并
		_ufs[root1] += _ufs[root2];

		// 将其中一个集合名称改变成另外一个
		_ufs[root2] = root1;
		return true;
	}
	// 数组中负数的个数，即为集合的个数
	size_t Count()const
	{
		size_t count = 0;
		for (auto e : _ufs)
		{
			if (e < 0)
				++count;
		}

		return count;
	}

private:
	vector<int> _ufs;
};

四、并查集的实现方式和优化策略

并查集有两种常见的实现方式：路径压缩和按秩合并。

• 路径压缩：在查找操作中，将查找路径上的所有节点的父节点直接指向根节点，以减少查找路径的深度。
• 按秩合并：在合并操作中，将秩较小的集合合并到秩较大的集合中，以减少树的高度。

为了提高查找操作的效率，通常结合使用路径压缩和按秩合并两种策略。路径压缩确保查找操作的时间复杂度接近常数，而按秩合并则减少了树的高度，进一步优化了合并操作的时间复杂度。

五、并查集的实现（完整版）

#include <iostream>
#include <vector>

class UnionFind {
private:
    std::vector<int> parent;
    std::vector<int> rank;

public:
    UnionFind(int n) : parent(n), rank(n) {
        for (int i = 0; i < n; ++i) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]); // 路径压缩
        }
        return parent[x];
    }

    void unite(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) return;

        if (rank[rootX] > rank[rootY]) {
            parent[rootY] = rootX;
        } else if (rank[rootX] < rank[rootY]) {
            parent[rootX] = rootY;
        } else {
            parent[rootY] = rootX;
            rank[rootX] += 1;
        }
    }

    bool connected(int x, int y) {
        return find(x) == find(y);
    }
};

int main() {
    int n, m;
    std::cin >> n >> m;
    UnionFind uf(n);
    for (int i = 0; i < m; ++i) {
        int a, b;
        std::cin >> a >> b;
        uf.unite(a - 1, b - 1); // 转换为0-based索引
    }
    for (int i = 0; i < m; ++i) {
        int a, b;
        std::cin >> a >> b;
        std::cout << (uf.connected(a - 1, b - 1) ? "YES" : "NO") << std::endl;
    }
    return 0;
}

六、总结

并查集的高效性在于其优化策略，使得查找和合并操作的时间复杂度保持在较低的水平，从而在处理大规模数据集时依然表现出色。平时我们在刷题或学习中还是会经常遇到并查集的