食物链（并查集）

                                                        食物链

 

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。
现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这N个动物所构成的食物链关系进行描述：
第一种说法是"1 X Y"，表示X和Y是同类。
第二种说法是"2 X Y"，表示X吃Y。
此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
1） 当前的话与前面的某些真的话冲突，就是假话；
2） 当前的话中X或Y比N大，就是假话；
3） 当前的话表示X吃X，就是假话。
你的任务是根据给定的N（1 <= N <= 50,000）和K句话（0 <= K <= 100,000），输出假话的总数。

Input

第一行是两个整数N和K，以一个空格分隔。
以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。
若D=1，则表示X和Y是同类。
若D=2，则表示X吃Y。

Output

只有一个整数，表示假话的数目。

Sample Input

    100 7
    1 101 1
    2 1 2
    2 2 3
    2 3 3
    1 1 3
    2 3 1
    1 5 5

Sample Output

3

第一种解法《开n*3的数组》

给每个动物赋予三个节点（n,2n,3n）这题有3种关系,这样就将并查集的节点数量扩展到3n，用并查集维护这3n个节点的信息就行

n,2n,3n 分别代表A、B、C（A吃B， B吃C，C吃A）。

1. 如果a和b是同类，则连接通  (a_n,b_n),     (a_2n,b_2n),      (a_3n,b_3n)
2. 如果a吃b，则连通  (a_n,b_2n),     (a_2n,b_3n),      (a_3n,b_n)

可以画一下，

1. 如果输入a吃b,b吃c，则必有c吃a，即c_n与a_2n连通（其他两个节点也连通）//c吃a
2. 如果输入a吃b，c吃b，则必有a_n与c_n连通（其他两个节点也连通）//a、c是同类
3. 如果输入a吃b，a吃c，则必有b_n与c_n连通（其他两个节点也连通）//b、c是同类

 

如果按照上面的规则对每一个动物去建立关系，那么，

1. 如果a和b是同类，必定有a_n与b_n连通；
2. 如果a吃b，必定有a_n与b_2n连通；
3. 如果b吃a，必定有b_n与a_2n连通。

或者说

如果x与y同类则

Find(x,y);

Find(x+n,y+n);

Find(x+2*n,y+2*n);

 

如果x吃y，则

 

Find(x+2*n,y);

Find(x+n,y+2*n);

Find(x,y+n);

 

//并查集
解法一
#include<iostream>

#include<algorithm>

#include<cmath>

#include<cstring>

using namespace std;

const int maxn=50005;

int pre[maxn*3];

int n,m;

int ans;

int Find(int x)
{
    if(x == pre[x])
        return x;
    return pre[x] = Find(pre[x]);
}

void Join(int x,int y)
{
    int a=Find(x);
    int b=Find(y);
    if(a!=b)
        pre[a]=b;
}//基本并查集操作

int main()
{

    ios::sync_with_stdio(false);  
    
    cin>>n>>m;
    
    for(int i=1; i<=3*n; i++)
    
        pre[i]=i;
        
    for(int i=1; i<=m; i++)
    {
        int k,a,b;
        
        cin>>k>>a>>b;
        
        if(a<1||a>n||b<1||b>n)//其中一种假话情况，当前的话中X或Y比N大，就是假话；
        {
            ans++;
            continue;
        }
        if(k==2&&a==b)//另一种假话情况，当前的话表示X吃X，就是假话。
        {
            ans++;
            continue;
        }
        if(k==1) //当a,b同类
        {
            if(Find(a)==Find(b+n)||Find(b)==Find(a+n)) 
            
               ans++;//如果a吃b或者b吃a，说明是假话
            
            else  //否则是真话，建立a和b同类的关系
            {
                Join(a,b);
                Join(a+n,b+n);
                Join(a+2*n,b+2*n);
            }
        }
        else if(k==2) //a吃b
        {
            if(Find(a)==Find(b)||Find(b)==Find(a+n)) 
            
               ans++;//如果a,b同类或者b吃a，说明是假话
               
            else  //否则是真话，建立a吃b的关系
            {
                Join(a,b+n);
                Join(a+n,b+2*n);
                Join(a+2*n,b);
            }
        }
    }
    cout<<ans<<endl;
    return 0;
}

解法二《只需要开n大的数组》

 第一步定义rank[i]中i与父亲的关系

rank[i]=x1---------i与父亲同级

rank[i]=x2---------i被父亲吃

rank[i]=x3---------i吃父亲

用rank[i]数组保存子与父的关系

公式：rank[x]（子到爷的关系）=(rank[x]（子到父的关系）+rank[y]（父到爷的关系）)%3;

初始化时rank[i]=0; 表示自己和自己同类，并不影响以后的计算

第二步：路径压缩

我们说了我们要把每一个正确的值与父结点串在一起，（无论什么关系）用rank保存关系，那么问题来了：

我们要把3和1连到一起，那么可以在路径压缩的时候，更新rank[3]表示3到根节点1的关系（用步骤一枚举得到的公式：

rank[x]（3到1的关系）=(rank[x]（3到2的关系）+rank[y]（2到1的关系）)%3;）

第三步：对于输入数据的处理

判断真假话

1.  当前的话与前面的某些真的话冲突，就是假话；
2.  当前的话中X或Y比N大，就是假话；
3.  当前的话表示X吃X，就是假话。
4. 2与3三直接判断，是假话 continue ; ans++;

对于1：

当我们输入x,y时，先求根节点

1）若两者根节点相同，说明我们已经赋予x，y关系了，只需要验证题中给的关系符合不符合我们已有的关系即可

此时知道rank[x]与rank[y]，则x到y的关系是：(3+rank[x]+(-rank[y]))%3（根据向量的关系，也可以枚举一下）即判断(3+rank[x]-rank[y])%3与flag-1是否相等。加3是因为减的过程可能会出现负数。

2）若两者根节点不相同，说明我们还没有赋予x，y关系，令root1=f(x),root2=f(y);pre[root2]=root1,关键就是怎么求rank[root2]

这时我们换种角度思考，之前一直都是rank[x]表示x与x父的关系，现在我们把它想成x父与x的关系，向量的方向要变了！

如图，此时求的是e1,  d1=a1+b1 ;  e1=d1-c1 ; e1=(a1+b1-c1);

a1=rank[x] ; c1=rank[y] ; b1=flag-1;(题上给的x，y的关系)

现在就是要求-c1，已知子与根节点的关系，求根节点与子的关系

 子与根节点的关系      根节点与子的关系

        0                                0

        1                                2

        2                                1

得-c1=(3-rank[y]) %3;

综上：e1=( (rank[x]+flag-1) %3+(3-rank[y]) %3 )%3;

即rank[root2]=(rank[x]+flag-1+3-rank[y])%3;

 

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
 
const int maxn = 2e5 + 5;
int father[maxn], rank[maxn]; 
// rank表示跟父亲节点的关系 0表示同类，1表示被吃，2表示吃 
int n, m;
 
int find(int x)
{
    if(x != father[x])
    {
        int f = father[x];
        father[x] = find(father[x]);
        rank[x] = (rank[x] + rank[f]) % 3;
    }
    return father[x];
}
 
int union_(int d, int x, int y)
{
    int a = find(x);
    int b = find(y);
    if(a != b)
    {
        father[b] = a;
        rank[b] = (3-rank[y]+(d-1)+rank[x]) % 3; 
        return 0;
    }
    if ((rank[y]-rank[x]+3)%3 != d-1) 
        return 1;
    return 0;
}
 
int main()
{
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++)
            father[i] = i;
        memset(rank, 0, sizeof rank);
        int ans = 0;
        while(m --)
        {
            int d, x, y;
            scanf("%d%d%d", &d, &x, &y);
            if(d == 2 && x == y )
                ans ++;
            else if(x > n || y > n)
                ans ++;
            else if(union_(d, x, y))
                ans ++;
 
        } 
        printf("%d\n", ans);
        return 0;
 }