并查集（力扣1971）

并查集的功能：判断两个节点是否在同一个集合中/将两个节点加入同一集合中。模板如下：

cpp 复制代码

#include<iostream>
#include<vector>
using namespace std;
const int n = 1e6 + 5;//视题目具体节点数量而定，比节点数量稍大即可
vector<int>father(n, 0);

//并查集初始化
void init()
{
	for (int i = 0; i < n; i++)
	{
		father[i] = i;
	}
}
//寻根，路径压缩
int find(int u)
{
	if (u == father[u]) return u;
	else father[u] = find(father[u]);
	return father[u];
}
//判断u和v是否找到同一个根
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;
}

我们用一个father数组，存储每个集合的"根"（可以将集合抽象为一棵n叉树）。

初始时，每个节点自己为一个集合，因此它们的根都是本身。

寻根时，我们使用路径压缩的方式。将集合抽象为一棵n叉树后，为了方便判断两个节点的根是否相同，我们尽可能地让在同一个集合中的节点都直接与该集合的"根"连接，这样尽可能地缩小了这棵n叉树的高度，因而在查询的时候就提高了效率。

如何路径压缩？就是在寻找节点u的根的过程中，让它的父节点father[u]承接住find(father[u])。形象地说，如果u有爷爷，那么就让father[u]成为u的爷爷，如果u有曾祖父，那就让father[u]成为u的曾祖父...

接着就是判断两个节点是否在同一个集合中，也就是判断它们的根是否相同。

然后就是将两个节点u和v加入。如果u和v的祖先相同，那就不用加入了，否则就让v的父亲为u.

提出疑问：模板中，isSame函数与join函数是否有一部分重复了？能否归并为如下形式？

cpp 复制代码

// 判断 u 和 v是否找到同一个根
bool isSame(int u, int v) 
{
    u = find(u);
    v = find(v);
    return u == v;
}

// 将v->u 这条边加入并查集
void join(int u, int v) 
{
    if (isSame(u, v)) return ; 
    father[v] = u;
}

这么写是有问题的，在join函数中我们需要寻找 u 和 v 的根，然后再进行连线在一起，而不是直接用 u 和 v 连线在一起。

举个例子：

cpp 复制代码

join(1, 2);
join(3, 2);

此时构成的图应该为：2->1,2->3

此时问 1，3是否在同一个集合，我们调用 join(1, 2); join(3, 2); 很明显本意要表示 1，3是在同一个集合。

但当我们调用 isSame(1, 3)的时候，find(1) 返回的是1，find(3)返回的是3。 return 1 == 3 返回的是false，代码告诉我们 1 和 3 不在同一个集合，这明显不符合我们的预期。问题出在我们精简的代码上，即 join 函数一定要先通过find函数寻根再进行关联。

正确模拟：

cpp 复制代码

void join(int u, int v)
{
	u = find(u);
	v = find(v);
	if (u == v) return;
	father[v] = u;
}

join(1,2)：使得2->1.

join(3,2)：由于要找祖先，所以会使得1->3.

这么一来，图就变成了：2->1->3，显然达到了我们预期的效果。因为在join函数里，我们有find函数进行寻根的过程，这样就保证元素 1，2，3在这个有向图里是强连通的。

我们回到题目上。这道题显然是用并查集。先看错误示例：

cpp 复制代码

class Solution
{
public:
    int find(vector<int>& father, int index)
    {
        if (index == father[index])
        {
            return index;
        }
        return father[index] = find(father, father[index]);
    }
    void join(vector<int>& father, int u, int v)
    {
        u = find(father, u);
        v = find(father, v);
        if (u == v) return;
        father[v] = u;
    }
    bool validPath(int n, vector<vector<int>>& edges, int source, int destination)
    {
        vector<int>father(n);
        for (int i = 0; i < n; i++)
        {
            father[i] = i;
        }
        for (auto p : edges)
        {
            join(father, p[0], p[1]);
        }
        return father[source] == father[destination];
    }
};

如果edge为：

cpp 复制代码

[[4,3],[1,4],[4,8],[1,7],[6,4],[4,2],[7,4],[4,0],[0,9],[5,4]]

我们来模拟一下。

step1：father[3]=4

step2：father[4]=1

走到这里，实际上已经可以发现问题了。如果source=3,destination=4，那么由于father[source]==4!=father[destination]==1，会返回false，但实际上是true.

也就是说，路径压缩是具有惰性的。如果没有调用find函数，father[u]仍然可能指向某个中间节点。

因此，我们真正需要判断的是，source和destination是否同根，而不是它们的父亲是否相同。

正确代码：

cpp 复制代码

class Solution
{
public:
    int find(vector<int>& father, int index)
    {
        if (index == father[index])
        {
            return index;
        }
        return father[index] = find(father, father[index]);
    }
    void join(vector<int>& father, int u, int v)
    {
        u = find(father, u);
        v = find(father, v);
        if (u == v) return;
        father[v] = u;
    }
    bool validPath(int n, vector<vector<int>>& edges, int source, int destination)
    {
        vector<int>father(n);
        for (int i = 0; i < n; i++)
        {
            father[i] = i;
        }
        for (auto p : edges)
        {
            join(father, p[0], p[1]);
        }
        return find(father, source) == find(father, destination);
    }
};