hdu 3234 Exclusive-OR （并查集）

Problem - 3234

　　题意不难理解，就是给出一些断言，以及一些查询，回答查询或者在找到断言矛盾以后沉默不做任何事。

　　这题其实就是一个并查集的距离存储问题，只要记录并查集元素的相对值以及绝对值就可以了。

代码如下：

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 #include <stack>
 #include <set>

 using namespace std;

 const int N = ;
 struct MFS {
     int fa[N], rel[N], val[N];
     void init() { for (int i = ; i < N; i++) fa[i] = i, rel[i] = , val[i] = -;}
     int find(int x) {
         if (fa[x] != x) {
             int fx = find(fa[x]);
             rel[x] ^= rel[fa[x]];
             fa[x] = fx;
             val[x] = val[fx] ^ rel[x];
             return fx;
         } else return x;
     }
     bool merge(int x, int y, int d) {
         int fx = find(x), fy = find(y);
         if (fx == fy) return d == (rel[x] ^ rel[y]);
         int dx = rel[x] ^ rel[fx], dy = rel[y] ^ rel[fy];
         if (~val[fx] && ~val[fy]) return d == (dx ^ dy ^ val[fx] ^ val[fy]);
         d ^= dx ^ dy;
         if (~val[fx]) rel[fy] ^= d, fa[fy] = fx;
         else rel[fx] ^= d, fa[fx] = fy;
         return true;
     }
     bool confirm(int x, int d) {
         int fx = find(x);
         if (~val[fx]) return (rel[x] ^ val[fx]) == d;
         val[fx] = rel[x] ^ d;
         return true;
     }
     int query(int x) {
         int fx = find(x);
         if (~val[x]) return val[x];
         return -;
     }
 } mfs;

 set<int> nsid;
 int ns[N];

 int main() {
 //    freopen("in", "r", stdin);
     char buf[];
     int n, m, val[], cnt, cas = ;
     while (~scanf("%d%d", &n, &m) && (n || m)) {
         mfs.init();
         bool conf = false;
         char *ptr;
         cnt = ;
         printf("Case %d:\n", cas++);
         for (int q = ; q <= m; q++) {
              scanf("%s", buf);
             gets(buf + );
             val[] = ;
             ptr = strtok(buf + , " ");
             while (ptr) {
                 val[]++;
                 sscanf(ptr, "%d", &val[val[]]);
                 ptr = strtok(NULL, " ");
             }
             if (conf) continue;
             if (buf[] == 'I') {
                 cnt++;
                 if (val[] == ) conf = !mfs.merge(val[], val[], val[]);
                 else conf = !mfs.confirm(val[], val[]);
                 if (conf) printf("The first %d facts are conflicting.\n", cnt);
             } else {
                 int ans = , tmp, fa;
                 nsid.clear();
                 for (int i = ; i <= val[]; i++) {
                     tmp = mfs.query(val[i]);
                     fa = mfs.find(val[i]);
 //                    cout << tmp << ' ';
                     if (tmp < ) {
                         if (nsid.find(fa) != nsid.end()) {
                             ans ^= ns[fa] ^ mfs.rel[val[i]];
                             nsid.erase(fa);
                         } else {
                             nsid.insert(fa);
                             ns[mfs.fa[val[i]]] = mfs.rel[val[i]];
                         }
                     } else ans ^= tmp;
                 }
 //                cout << endl;
                 if (!nsid.empty()) puts("I don't know.");
                 else printf("%d\n", ans);
             }
         }
         puts("");
     }
     return ;
 }

——written by Lyon