本文用于个人算法竞赛学习，仅供参考
目录
一.什么是并查集
二.并查集实现
三.路径优化
四.时间复杂度
五.并查集+路径压缩 模板
五.题目
一.什么是并查集
并查集（Disjoint Set）是一种数据结构，用于处理一系列不相交的集合的合并与查询问题。并查集主要支持两种操作：
1. 合并（Union）：将两个集合合并为一个集合。
2. 查询（Find）：确定一个元素属于哪个集合，通常用于判断两个元素是否属于同一个集合。
并查集通常使用树结构来表示集合，其中每个节点表示一个元素，树的根节点表示集合的代表元素。通过路径压缩和按秩合并（没什么用）等优化方式，可以在近似常数时间内进行合并和查询操作。
二.并查集实现
1.存储方式
使用一维数组来实现，通过数组将元素连通在一起，就相当于将元素放在同一个集合中了。比如将A、B、C放在同一个集合，有
2.功能实现
const int N = 10010;
int father[N];
//并查集寻根的过程--递归
int find(int u)
{
//等于本身就是根节点，返回根节点
if (u == father[u])
return u;
//不是根节点，向下寻根
else
return find(father[u]);
}
// v -> u加入这条边
void join(int u, int v)
{
u = find(u);//寻根
v = find(v);//寻根
//同一集合就不用加入了
if (u == v)
return;
father[v] = u;
}
//判断是否同一个集合---是否同一个根
bool isSame(int u, int v)
{
u = find(u);//寻根
v = find(v);//寻根
return u == v;
}
//初始化---每个节点初始化指向自己
void init()
{
for (int i = 0; i < N; i++)
{
father[i] = i;
}
}三.路径优化
对于一个集合，将其抽象成树形结构可能是：
对于find函数，其实是一个寻根过程，比如
对于插入一条边和查询是否同一个集合，都是通过查找根节点后进行操作的，那么find的效率就取决于路径的长度，既然都是找根，那么同一个集合的元素直接插到同一个节点不就行了，将树的结构改成：
这样每次find就不用递归那么多层了，这种思想就是路径压缩。
只需要改一下find函数就可以实现：
int find(int u) {
return u == father[u] ? u : father[u] = find(father[u]);
}四.时间复杂度
路径压缩后的并查集时间复杂度在O(logn)与O(1)之间，且随着查询或者合并操作的增加，时间复杂度会越来越趋于O(1)。
五.并查集+路径压缩 模板
const int N = 10010;
int father[N];
//并查集寻根的过程--递归
int find(int u)
{
return u == father[u] ? u : father[u] = find(father[u]);
}
// v -> u加入这条边
void join(int u, int v)
{
u = find(u);//寻根
v = find(v);//寻根
//同一集合就不用加入了
if (u == v)
return;
father[v] = u;
}
//判断是否同一个集合---是否同一个根
bool isSame(int u, int v)
{
u = find(u);//寻根
v = find(v);//寻根
return u == v;
}
//初始化---每个节点初始化指向自己
void init()
{
for (int i = 0; i < N; i++)
{
father[i] = i;
}
}五.题目
1971. 寻找图中是否存在路径 - 力扣（LeetCode）
class Solution {
//并查集
//模板实现
private:
int n = 200005;
vector<int> father = vector<int>(n, 0);
//初始化
void init()
{
for(int i = 0; i < n; i++)
{
father[i] = i;
}
}
//find找根，路径压缩实现
int find(int u)
{
return u == father[u] ? u : father[u] = find(father[u]);
}
//判断是否同根
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);
v = find(v);
if(u == v)
{
return;
}
father[v] = u;
}
public:
bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
init();
for(int i = 0; i < edges.size(); i++)
{
join(edges[i][0], edges[i][1]);
}
return isSame(source,destination);
}
};684. 冗余连接 - 力扣（LeetCode）
class Solution {
//并查集
private:
int n = 1005;
vector<int> father = vector<int>(n, 0);
//初始化
void init()
{
for(int i = 0; i < n; i++)
{
father[i] = i;
}
}
//查找&&并查集
int find(int u)
{
return father[u] == u ? u : father[u] = find(father[u]);
}
//判断是否同一跟根节点
bool isSame(int u, int v)
{
u = find(u);
v = find(v);
return u == v;
}
//加入同一集合
void join(int u, int v)
{
u = find(u);
v = find(v);
if(u == v)
{
return;
}
father[v] = u;
}
public:
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
init();//记得初始化
for(int i = 0; i < n; i++)
{
if(isSame(edges[i][0], edges[i][1]))
return edges[i];
else
join(edges[i][0], edges[i][1]);
}
return {};
}
};685. 冗余连接 II - 力扣（LeetCode）
class Solution {
private:
static const int N = 1010; // 如题：二维数组大小的在3到1000范围内
int father[N];
int n; // 边的数量
// 并查集初始化
void init() {
for (int i = 1; i <= n; ++i) {
father[i] = i;
}
}
// 并查集里寻根的过程
int find(int u) {
return u == father[u] ? u : father[u] = find(father[u]);
}
// 将v->u 这条边加入并查集
void join(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return ;
father[v] = u;
}
// 判断 u 和 v是否找到同一个根
bool same(int u, int v) {
u = find(u);
v = find(v);
return u == v;
}
// 在有向图里找到删除的那条边，使其变成树
vector<int> getRemoveEdge(const vector<vector<int>>& edges) {
init(); // 初始化并查集
for (int i = 0; i < n; i++) { // 遍历所有的边
if (same(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 (same(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);
}
}
// 处理图中情况1 和 情况2
// 如果有入度为2的节点，那么一定是两条边里删一个，看删哪个可以构成树
if (vec.size() > 0) {
if (isTreeAfterRemoveEdge(edges, vec[0])) {
return edges[vec[0]];
} else {
return edges[vec[1]];
}
}
// 处理图中情况3
// 明确没有入度为2的情况，那么一定有有向环，找到构成环的边返回就可以了
return getRemoveEdge(edges);
}
};
