UVALive（LA） 4487 Exclusive-OR（带权并查集）

题意：对于n个数X[0]~X[n-1]，但你不知道它们的值，通过逐步提供给你的信息，你的任务是根据这些信息回答问题，有三种信息如下：

I p  v ： Xp = v;    Xp 的值为v

I p q v :  Xp ^ Xq = v;   Xp 异或Xq的值为v

Q k X1 X2 X3 ..... Xk  : 问X1异或X2异或X3....异或Xk的值为多少？

解题思路：先看处理部分（I），有两种 I 一种 是后面有两个整数的，一种是后面有三个整数的，（这里的输入要注意整数有可能是好几个字符）。先看三个整数的，Xp ^ Xq = v;那么我们可以利用并查集把 使 p 的父节点 为 q,再建立一个数组w[]，代表Xp 异或 根节点的值，我们对于每次给出的两个数，p 和 q，把它们并到集合里面，利用路径压缩使得w[p]和w[q]都是和根节点异或的值，在压缩的时候维护这个数组就好。

首先我们需要知道几个公式  a ^ b= c, 那么   a = b ^ c  b = a ^ c;

异或运算有结合律，交换律。

a ^ a = 0;

a ^ 0 = a;

对于 I p q v :   p ^ q = v；

假设：

fp  是  p 的根节点，那么 fp = p ^ w[p];     1

fq  是  q 的根节点，那么 fq = q ^ w[q];     2

                                            p ^ q = v ;          3

我们把 fp 的父节点设为 fq(新的根节点) 那么  w[fp] = fp ^ fq;   4

把 1 2 3 式带到 4  式的  w[fp] = w[p] ^ w[q] ^ v;

这样就解决了路径压缩过程中的维护数组问题。对于 I  后面仅有 二个整数的情况，I  p v   p = v；我们可以变形一下   p ^ 0 = v;这样是不是就和上面那种情况很像了呢，即令 q = 0，就好了，因为 我们的编号是  0 ~ N- 1，为了不和其他节点弄混，那么我们可以把这个节点用编号 n 来表示，只不过已知 n 的值为 0 就好了~~~~，然后处理数据这部分就解决了~~~~

紧接着我们看询问部分（Q），询问的时候 假设 询问的是 X1，X2，X3..........Xn,

我们先看 w[X1] ^ w[X2]^w[X3]^....w[Xn],假设他们的根节点是  R(他们在一个集合里面),

那么w[X1] ^ w[X2]^w[X3]^....w[Xn]

   =  X1 ^R ^  X2 ^R ^ X3  ^ R ^ ......... ^ Xn ^ R

这里一共有 N 个 R  ，由公式  a ^ a= 0;  a ^ 0 = a;而且异或具有交换律，那么 这里的 N 如果是 偶数 我们 就可以求得X1 ^R ^  X2 ^R ^ X3  ^ R ^ ......... ^ Xn ^ R = X1 ^ X2 ^ X3 ^ ......^Xn,如果是奇数那么最后就会剩下一个单独的R。。。这里这个 R 是已知的话那么也可以求出来 ，怎么会是已知的呢？我们可以想想有一个特殊的  ，就是那个编号为 N 的节点，他的值是 0 ，所以就要分情况了 

if（R是N）

{

   X1 ^ X2 ^ X3 ^ ......^Xn =w[X1] ^ w[X2] ^ w[X3] ^....w[Xn]；

}

else

{

   if（R的数量是奇数）

   {

         不知道值；

   }

  else

  {

        X1 ^ X2 ^ X3 ^ ......^Xn =w[X1] ^ w[X2] ^ w[X3] ^....w[Xn]；

  }

}

这样整个过程就结束了。。。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;

const int MAXN = 2e4 + 3;
int pre[MAXN];       //存放的是父节点
int weight[MAXN];    //存放是与根节点的异或值
int xp[MAXN];       //询问时的数
int n;

int Find(int x)       //带路径压缩的查找
{
   // printf("1");
    if(x != pre[x])
    {
        int fx = pre[x];
        pre[x] = Find(pre[x]);
        weight[x] ^= weight[fx];        //维护数组
        //printf("2");
    }
    return pre[x];
}

int mix(int x, int y, int z)
{
    int fx = Find(x);
    int fy = Find(y);
    //printf("x = %d y = %d z = %d fx = %d fy = %d\n",x,y,z,fx,fy);
    if(fx  == fy)            //如果给出的两个数已经出现过。判断现在给出的这个 I  是不是和以前的冲突（矛盾）
    {
        if((weight[x] ^ weight[y]) != z)      //（出现了矛盾）
            return 0;
        return 1;
    }
    if(fx == n) fx ^= fy ^= fx ^= fy;      //为了使得 n 成为 根节点
    pre[fx] = fy;
    weight[fx] = weight[x] ^ weight[y] ^ z;    //fx 的父节点设为 fy(新的根节点)后维护weight[fx]的值
    return 1;
}

int solv(int key)
{
    int index[MAXN]={0};
    int ans = 0;
    for(int i = 0; i < key ; i++)    //查找森林中的每个树，统计 根节点被异或的次数
    {
        if(index[i]) continue;
        int fi = Find(xp[i]);
        int cnt = 0;
        for(int j = i ; j < key; j++)
        {
            int fj = Find(xp[j]);
            if(index[j] == 0 && fi == fj)
            {
                cnt++;
                index[j] = 1;
                ans ^= weight[xp[j]];
            }
        }
        if((cnt&1) && fi != n)     //根节点被异或的次数是奇数  而且不是那个特殊的根节点
            return -1;
    }
    return ans;
}

int main()
{
    //freopen("in.cpp","r",stdin);
    int Q;
    int kas = 1;
    while(scanf("%d%d",&n,&Q) && (n || Q))
    {
        printf("Case %d:\n",kas++);
        for(int i = 0; i <= MAXN; i++)   //初始化 开始每个点都是一棵树，自身异或自身是 0 ，
        {
            pre[i] = i;
            weight[i] = 0;
        }
        int facts = 0;
        int flag = 0;
        while(Q--)
        {
            char order[2]={0};
            scanf("%s",order);
            int p,q,v;
            if(order[0] == 'I')
            {
                facts++;
                getchar();
                char str[7]={0};
                gets(str);
                int k = 0;
                for(int i = 0; str[i] != '\0'; i++)
                    if(str[i] == ' ') k++;
                if(k == 1)
                {
                    sscanf(str,"%d%d",&p,&v);     //I  后面只有两个数
                    q = n;
                }
                else
                {
                    sscanf(str,"%d%d%d",&p,&q,&v);//I  后面只有三个数
                }
                if(flag) continue;   //矛盾
                if(mix(p,q,v) == 0) //矛盾了
                {
                    printf("The first %d facts are conflicting.\n",facts);
                    flag = 1;
                }
                /*for(int i = 0; i < 10; i++)
                    cout << pre[i] <<" ";
                cout << endl;*/
                //printf("%d %d %d\n",p,q,v);
            }
            else if(order[0] == 'Q')
            {
                int k;
                scanf("%d",&k);
                memset(xp,0,sizeof(xp));
                for(int i = 0; i < k; i++)
                {
                    scanf("%d",&xp[i]);
                }
                if(flag) continue;//矛盾
                int ans = solv(k);
                if(ans == -1)
                {
                    printf("I don't know.\n");
                }
                else
                    printf("%d\n",ans);
            }
        }
        printf("\n");
    }
    return 0;
}