带权并查集

对于基础的并查集而言,只存在着两种操作,一种是寻找祖先一种是进行合并

int find(int x)
{
    if(x==pre[x]) return x;
    else return pre[x]=find(pre[x]);
}
void join(int x,int y)
{
    pre[find(x)]=find(y);
}

 对于带权并查集而言,它可以在我们的基础并查集上去维持一定的其他关系,比如距离等,在这里我们以杭电~HDUyyds的How Many Answers Are Wrong为例,在这个题目中每个语句给你每个点之间数目总和,而你要去判断在这些句子之中有哪些是错误的,并且输出错误的数目.

 对于每个句子中给的左边界和右边界,我们都可以将他们看作是一个点,而这个区间的总和就是这个边上面的权值,而我们可以将这个权值转化为一个相对值,得到的是一堆点关于一个点的值,在对点进行合并的操作之后,我们就可以得到两个点之间的相对值

 以上面的点a,b 为例,我们可以得到a,b的父亲分别是fa和fb,并且a,b之间的权值关系是v,此时我们将a代表的那一支合并到我们的b一支商去,此时我们可以得到等式关系 v 1 + v x = v + v 2 v_{1} +v_{x} = v+v_2 v1​+vx​=v+v2​,由此我们更新得到这个fa关于fb的权值

 code is as below

#include 
#define N 200005
using namespace std;
int f[N],value[N];
inline int find(int x) {
    if(x == f[x]) return x;
    else {
        int a = f[x];
        f[x] = find(f[x]);
        value[x] = value[x] + value[a];
        return f[x];
    }
}
int ans = 0;
int main() {
    int n,m;
    scanf ("%d%d",&n,&m);
    for (int i = 1;i <= n;i++) f[i] = i;
    int x,y,z;
    for (int i = 1;i <= m;i++) {
        scanf("%d%d%d",&x,&y,&z);
        int fl = find(x),fr = find(y);
        if(fr == fl) {
            if(value[x] - value[y] != z) ans++;
            else {
                f[fl] = fr;
                value[fl] = -value[x] + value[y] + z;
            }
        }
    }
    printf("%d",ans);
}

 种类并查集其实就是所有的元素是属于某一几个类的,然后根据每个点之间的逻辑关系去判断这个结果是否成立,种类并查集模版

 种类并查集科研算作是权值并查集的一个分支,但是也不能完全算作是,下面我来介绍关于种类并查集的两种写法

#include 
using namespace std;
int f[100000],re[100000]; // re表示的是每个点对应的关系,有0,1,2, 0 表示的是同类,1表示的是捕食关系,2表示的是被捕食关系
int n,m,ans;
int find(int a)
{
   int fa=f[a];
   if (a!=fa) {
       f[a]=find(fa);
       re[a]=(re[a]+re[fa])%3;
       return f[a];
   }
   else return fa;
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) f[i] = i;
    for (int i=1;i<=m;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&z,&x,&y);
        if ((x>n||y>n)||(z==2&&x==y)) {   //两种特殊情况
            ans++; continue;
        }
       if (z==1)
       {
           int f1=find(x),f2=find(y);
           if (f1==f2&&re[x]!=re[y])
           {
               ans++; continue;
           }
           else if(f1!=f2)
           {
               f[f1]=f2; re[f1]=(3-re[x]+re[y])%3;
             // 合并并查集,他们种类是相同的,故应该是相等的
           }
       }
       else {
           int f1=find(x),f2=find(y);
           if (f1==f2)
           {
             // 如果此时已经进行过合并了,那么此时如果不是捕食的关系,那么错误
               int rela=(re[x]-re[y]+3)%3;
               if (rela!=1) {
                   ans++; continue;
               }
           }
           else {
               f[f1]=f2; re[f1]=(3-re[x]+re[y]+1)%3;
             // 种类是不相同的,存在着捕食的关系,故要加1
           }
       }
   }
    printf("%dn",ans);
    return 0;
}

 用 i i i表示本身, i + n i+n i+n表示其捕食的对象, i + 2 ∗ n i+2*n i+2∗n表示其被捕食的强者

#include 
#define N 1010
using namespace std;
int f[N*3];
inline int find(int x){
    if(x == f[x]) return x;
    else{
        return f[x] = find(f[x]);
    }
}
int main() {
    int n,m,ans = 0;
    scanf("%d%d",&n,&m);
    for (int i = 1;i <= 3*n;i++) f[i] = i;
    for (int i = 1;i <= m;i++) {
        int x,y,z;
        scanf("%d%d%d",&z,&x,&y);
        if(x > n|| y > n||(z == 2&&x == y)) {ans++;continue;}
        if(z == 1) {
            if (find(x+n) == find(y) || find(y+n) == find(x)) {ans++;}
            else  {
                f[find(x)] = find(y);
                f[find(x+n)] = find(y+n);
                f[find(x+2*n)] = find(y+2*n);
            }
        } else {
            int fx = find(x);
            int fy = find(y);
            if (fx == fy|| find(x+2*n) == fy) {ans++;}
            else {
              f[find(x + n)] = fy;
              f[find(y+n)] = f[find(x+2*n)];
              f[find(y+2*n)] = fx;
            }
        }
    }
    printf("%dn",ans);
}

溜了,太菜了,c++实验还没写,cf还没上分(div3不能ak的都是辣鸡,太菜了)