POJ 1182 食物链(并查集：路径压缩)

POJ 1182 食物链(并查集：路径压缩)

http://poj.org/problem?id=1182

题意：

        动物王国中有三类动物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

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

分析：

        首先要意识到本题是路径压缩并查集问题。对于任意节点X与Y，只要X与Y在同一个分量中，就表示他们之间的关系是已知的(可以通过中间节点推出来)。

        设节点A->节点B的值=节点A与节点B的关系：

        A->B==0 表示A与B同类，此时B->A也==0(B与A同类)。

        A->B==1表示A吃B，此时B->A==2(B被A吃)。

        A->B==2表示A被B吃，此时B->A==1(B吃A)。

        通过任意A->B和B->C的关系，我们能推出A->C的关系。通过任意A与B关系，B与C关系，C与D关系我们能推出A与D关系。因为A->B的值等于B->A的值的逆(想想是不是)。

        分析到此我们可以用一般的路基压缩并查集来做本题，即：

        findset(x)时，先找出x的父亲节点->根的关系v2，然后用r[x](表x到x父亲的关系)与v2合并可以得出x到根的关系。比如x->父==1时，父->根==1时，那么x->根==2(想想是不是)。

        对于bind(u，v，relation)来说，只要找出u->u分量根的关系，v->v分量根的关系，且利用u与v的关系relation，可以推断出u分量根fu与v分量根fv的关系。

        对于并查集的基础结构就做完了，当如果输入r x y时，且x与y在同一分量(x与y的关系可推断出)，那么只要x与y的关系与r所指关系不同，那么说明本句是假话。另外两种假话情况很简单就不讨论了。

        

        优化：如果仅通过if else来把findset和bind中所有可能出现的关系组合列一遍，然后分情况讨论。这种方法可以做本题，但是容易出错且很麻烦。

        网上多数方法(我的第2份AC代码也是)是希望通过找出固定的公式来实现findset和bind的关系合并推断的代码，但是找公式你必须列出所有可能结果并验证你的公式，需要做的工作量同样很多(很有可能其他路径压缩并查集的题目并不存在对应公式)。

        我下面的AC代码(新)是用过实现3个关系推导函数来完成findset和bind中的关系合并推断的代码。

        首先是rev函数，它返回一个关系的逆关系值。比如A->B==1，那么rev(1)等于2,。说明B->A==2.

        其次是rela_2函数，它由两个连续的间接关系推断出一个直接的关系，比如A->B==1，B->C==1，所以rela_2(1,1)会得到2。事实上A->C确实==2。

        最后是rela_3函数，它由3个连续的间接关系推断出一个直接的关系，比如A->B==1，B->C==1，C->D==1，所以rela_3(1，1，1)会得到0。事实上A与D确实同类为0。

        那么我们如果想合并u与v所属分量的根fu与fv时，让fu接在fv根下面。我们应该写出如下代码(想想是不是)：

    r[fu]=rela_3(rev(r[u]), relation, r[v]);

        上面代码的含义就是 fu->u->v->fv 通过这三个关系间接推出fu->fv。

       综述：上述介绍的3种方法都能做这种基于关系的状态压缩并查集问题，但是第3种方法通用性好，且不用复杂的分析，不容易出错。

AC代码(新)：250ms

#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=50000+5;

int fa[maxn];
int r[maxn];//与父的关系
int rev(int val)//返回逆向关系
{
    return (3-val)%3;
}
int rela_2(int v1,int v2)//由两个连续关系推出1个直接关系
{
    if(v1==0) return v2;
    if(v2==0) return v1;
    if(v1==1 && v2==1) return 2;
    if(v1==1 && v2==2) return 0;
    if(v1==2 && v2==1) return 0;
    if(v1==2 && v2==2) return 1;
}
int rela_3(int v1,int v2,int v3)//3间接关系推1直接关系
{
    return rela_2(rela_2(v1,v2),v3);
}
int findset(int x)
{
    if(fa[x]==-1) return x;

    int root=findset(fa[x]);
    r[x] = rela_2(r[x],r[fa[x]]);
    return fa[x]=root;
}
int bind(int u,int v,int relation)
{
    int fu=findset(u);
    int fv=findset(v);
    if(fu!=fv)
    {
        r[fu]=rela_3(rev(r[u]), relation, r[v]);
        fa[fu]=fv;
        return 0;
    }
    else//u与v在同一连通分量
    {
        if(rela_2(r[u], rev( r[v] ) ) != relation) return 1;
        return 0;
    }
}

int main()
{
    int n,k;
    int cnt=0;//假话数
    scanf("%d%d",&n,&k);
    memset(fa,-1,sizeof(fa));
    memset(r,0,sizeof(r));

    while(k--)
    {
        int relation,x,y;
        scanf("%d%d%d",&relation,&x,&y);
        relation--;//这里记得减1

        if(x>n || y>n || (relation==2 && x==y) )
        {
            ++cnt;
            continue;
        }

        cnt += bind(x,y,relation);
    }

    printf("%d\n",cnt);
    return 0;
}

AC代码：235ms

#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=50000+100;
int pa[MAXN];
int v[MAXN];
int findset(int x)
{
    if(pa[x]==-1)return x;
    int temp=findset(pa[x]);
    v[x] =(v[x]+v[pa[x]] )%3;
    return pa[x]=temp;
}

int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    memset(pa,-1,sizeof(pa));
    memset(v,0,sizeof(v));
    int ans=0;
    while(k--)
    {
        int d,x,y;
        scanf("%d%d%d",&d,&x,&y);
        int fx=findset(x);
        int fy=findset(y);
        if(x>n||y>n)
        {
            ans++;
            continue;
        }
        if(fx==fy)//同类则在一棵树上,不用合并
        {
            if(d==1 && v[x]!=v[y]) ans++;
            if(d==2 && ( (v[x]+1)%3 ) !=v[y] ) ans ++;
        }
        else
        {
            if(d==1)
            {
                pa[fy]=fx;
                v[fy]=(v[x]-v[y]+3)%3;
            }
            else if(d==2)
            {
                pa[fy]=fx;
                v[fy]=(v[x]-v[y]+1+3)%3;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}