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 + ;
 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 ;
         return ;
     }
     if(fx == n) fx ^= fy ^= fx ^= fy;      //为了使得 n 成为 根节点
     pre[fx] = fy;
     weight[fx] = weight[x] ^ weight[y] ^ z;    //fx 的父节点设为 fy(新的根节点)后维护weight[fx]的值
     return ;
 }

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

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