《算法笔记》第4章 入门篇（2）---算法初步 9.6 并查集

9.6.1 并查集的定义：

9.6.2 并查集的基本操作：

1.初始化：

for(int i=1; i<=N; i++)
{
    father[i]=i;
}

2.查找：

//findFather函数返回元素x所在的集合的根结点：
int findFather(int x)
{
    while(x!=father[x]) //如果不是根结点，继续循环
        x=father[x];     //让x为自己的父亲结点
    return x;
    
}

//使用递归来实现：
int findFather(int x)
{
    if(x==father[x])       //如果找到根结点直接返回x
        return x;
    else
        return findFather(father[x]);   //否则，调用递归函数
}

3.合并：

//void函数类型：Union 形参是 int类型 a，b
/*
    //调用findFather函数，参数为a，令其值放到faA中，同理，查找b的更结点
    如果faA!=faB，则合并
    


*/

void Union(int a, int b)
{
    int faA=findFather(a);       //查找a的根结点，记为faA
    int faB=findFather(b);      //查找b的根结点，记为faB
    if(faA!=faB)        //如果两个点的根结点不同，则合并
    {
        father[faA]=faB;
    }
}

9.6.3 路径压缩：

//int函数类型： findFather 形参为int 类型 x
/*
    由于x在下面的while中会变成根结点，因此先把原先的x保存一下
    while循环，寻找根结点
    此时x存放的是根结点，下面把所有路径上的结点father都改为根结点
        1.如果a不是根结点
        2.先保存a的值到z，然后回溯父亲结点
        3.将原先的结点a的父亲改为根结点x
    返回根结点x


*/

int findFather(int x)
{
    int a=x;
    while(x!=father[x])   //找到父亲结点
    {
        x=father[x];
    }
    if(a!=father[a])    //a不是根结点
    {
        int z=a;
        a=father[a];
        father[z]=x;
    }
}

//递归的方式
/*
    int类型函数：findFather 参数为int类型 v
    1.如果v是根结点，则直接返回v
    2.否则
        1.递归调用 findFather函数，参数为father[v]，放到参数F中
        2.将v的父亲设置为F
        3.最后返回根节点


*/

int findFather(int v)
{
    if(v==father[v])
        return v;
    else
    {
        int F=findFather(father[v]);
        father[v]=F;           //注意这里在一直深入递归后，函数开始返回值，是返回v，而注意每个v都是代表father[v]，则就将原本的每个结点的父亲结点设置为F（根结点），相当于上面的a=father[a];&father[z]=x;
    }
    return F;
}

---

---

#include<iostream>
using namespace std;
const int maxn=1000;
int father[maxn];
bool isRoot[maxn];
int findFather(int x)
{
    int a=x;
    while(x!=father[x])
        x=father[x];
        
    /*压缩路径可要可不要，有的话，就是将链改为树的形式
    while(a!=father[a])
    {
        int z=a;
        a=father[a];
        father[z]=x;
    }*/
    return x;
}


/*上面代码的递归版本
void findFather(int x)
{
    if(x==father[x])
        return x;
    else
    {
        F=findFather(father[x]);
        father[x]=F;
    }
    return F;
}*/

void Union(int a,int b)       //通过两两合并，最终将整个值合并为一条链
{
    int faA=findFather(a);
    int fbB=findFather(b);
    if(faA!=fbB)
        father[faA]=fbB;
}



void init(int n)
{
    for(int i=1; i<=n; i++)
    {
        father[i]=i;
        isRoot[i]=false;
    }
}

int main()
{
    int n,m,a,b;
    cin >> n >> m;
    init(n);
    for(int i=0; i<m; i++)
    {
        cin >> a >> b;
        Union(a,b);
    }
    for(int i=1; i<=n; i++)
    {
        isRoot[findFather(i)]=true;                //通过findFather可以找到，一条链上的结点，将其对应的isRoot改为true，也就代表了这是一个链，一个家族
    }
    int ans=0;
    for(int i=1; i<=n; i++)
    {
        ans+=isRoot[i];
    }
    cout << ans;
    return 0;
}