POJ-1733 Parity game（带权并查集区间合并）

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

题目描述

　　你和你的朋友玩一个游戏。你的朋友写下来一连串的0或者1。你选择一个连续的子序列然后问他，这个子序列包含1的个数是奇数还是偶数。你的朋友回答完你的问题，接着你问下一个问题。

　　你怀疑你朋友的一些答案可能是错误的，你决定写一个程序来帮忙。程序将接受一系列你的问题及你朋友的回答，程序的目的是找到第一个错误的回答i，也就是存在一个序列满足前i-1个问题的答案，但是不满足前i个问题。

输入

　　第一行有一个整数L（L<=1000000000）,是这个01序列的长度。第二行是一个整数N(N<=5000),是问题及其答案的数目,接下来N行描述问题和答案。每一行包含一个问题和这个问题的答案：两个整数（子序列的起始位置和结束位置）和一个单词‘even’或者‘odd’,‘even’表示这个子序列中的‘1’的个数是偶数，‘odd’则表示是奇数。

输出

　　输出一行一个整数X。表示存在一个01序列满足前面的X个问题，但是不存在一个01序列满足前X+1个问题，如果存在一个序列满足所有问题，则输出N。

样例输入

  even
  odd
  even
  even
  odd

样例输出

数据范围：

序列长度L<=1000000000,询问及回答数N<=5000

给你几个区间的范围以及里面1的个数是奇数还是偶数，然后让你求前多少个描述是对的。

还是区间问题，找和之前的有矛盾的，想到了带权并查集

若[a,b]中出现了偶数个1，则表示[0,a-1]和[0,b]的1的奇偶性相同。
若[a,b]中出现了奇数个1，则表示[0,a-1]和[0,b]的1的奇偶性不同。

因为题目给的数的范围特别大，不得不离散化，这里采用map的方式来离散化。

map离散化是指，比如1~10000，如果采用传统方式，明显是1和10000合并，但是离散化之后，用1代表1，2代表10000，1和2的合并便取代了1和10000的合并。

采用map离散化，将原始值作为key，便能实现快速查找判断是否出现过。

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <string>
 #include <math.h>
 #include <algorithm>
 #include <vector>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <sstream>
 const int INF=0x3f3f3f3f;
 typedef long long LL;
 const int mod=1e9+;
 const int maxn=1e5+;
 using namespace std;

 int fa[];
 int sum[];//sum[i]表示[fa[i],i]区间1的个数的奇偶性，0表示偶数，1表示奇数
 map<int,int> mp;

 void init()
 {
     mp.clear();
     memset(sum,,sizeof(sum));
     for(int i=;i<=;i++) //注意这里因为是离散过后的，故不是<=n
         fa[i]=i;
 }
 int Find(int x)
 {
     if(x!=fa[x])
     {
         int t=fa[x];
         fa[x]=Find(fa[x]);
         sum[x]^=sum[t];
     }
     return fa[x];
 }

 int main()
 {
     #ifdef DEBUG
     freopen("sample.txt","r",stdin);
     #endif
 //    ios_base::sync_with_stdio(false);
 //    cin.tie(NULL);

     int n,k;
     scanf("%d %d",&n,&k);
     init();
     int ans=k;
     int cnt=;//离散化的新序号
     int l,r;
     char op[];
     for(int i=;i<=k;i++)
     {
         scanf("%d %d %s",&l,&r,op);
         if(!mp.count(l-))//离散化
         {
             mp[l-]=++cnt;
         }
         if(!mp.count(r))//离散化
         {
             mp[r]=++cnt;
         }
         int flag;
         if(op[]=='e') flag=;
         else flag=;
         int x=Find(mp[l-]);
         int y=Find(mp[r]);
         if(x!=y)
         {
             fa[y]=x;
             sum[y]=sum[mp[l-]]^sum[mp[r]]^flag;
         }
         else if(sum[mp[l-]]^flag!=sum[mp[r]])
         {
             ans=i-;
             break;
         }
     }
     printf("%d\n",ans);

     return ;
 }

-