奇偶游戏（带权并查集）

题目：

小A和小B在玩一个游戏。

首先，小A写了一个由0和1组成的序列S，长度为N。

然后，小B向小A提出了M个问题。

在每个问题中，小B指定两个数 l 和 r，小A回答 S[l~r] 中有奇数个1还是偶数个1。

机智的小B发现小A有可能在撒谎。

例如，小A曾经回答过 S[1~3] 中有奇数个1， S[4~6] 中有偶数个1，现在又回答 S[1~6] 中有偶数个1，显然这是自相矛盾的。

请你帮助小B检查这M个答案，并指出在至少多少个回答之后可以确定小A一定在撒谎。

即求出一个最小的k，使得01序列S满足第1~k个回答，但不满足第1~k+1个回答。

输入格式

第一行包含一个整数N，表示01序列长度。

第二行包含一个整数M，表示问题数量。

接下来M行，每行包含一组问答：两个整数l和r，以及回答“even”或“odd”，用以描述S[l~r] 中有奇数个1还是偶数个1。

输出格式

输出一个整数k，表示01序列满足第1~k个回答，但不满足第1~k+1个回答，如果01序列满足所有回答，则输出问题总数量。

数据范围

N≤109,M≤10000N≤109,M≤10000

输入样例：

10
5
1 2 even
3 4 odd
5 6 even
1 6 even
7 10 odd

输出样例：

3

解题报告：咱们得到的是某段区间内的奇偶性，所以咱们可以转换一下思想，每个点x的存储就是从1-x的奇偶性，那么给出的区间[l,r]的
奇偶性其实就是[1,l-1],[1,r]的奇偶性的异或，因为第二个区间总是包含前者的，题目给出的l,r,even/odd都是可以去证明的，咱们
一开始根据题目给的信息，维护n个独立的集合，当给定信息后，实现各个集合的连接，在这个过程中判断有没有矛盾。
中间涉及矛盾的判断，咱们维护一个d数组即可，d[x]存放的是x和其节点的奇偶性，当进行路径压缩的时候，d[x]需要异或所有父节点。实现
两棵树的合并的时候，维护的是x以n为根节点的树，和y以m为根节点的树进行合并，d[n]^d[x]^d[y]==result(题目给出的)
因为给定的数的范围比较大，所以要提前进行一下离散化处理。

ac代码：

//from:Onion
//239 奇偶游戏 带权并查集 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;

const int maxn=1e5+100;
int far[maxn];
int d[maxn];
int mp[maxn<<1];
int n,m;
struct node{
    int l,r,result;
}qs[maxn];

void init()
{
    for(int i=0;i<maxn;i++)
    {
        far[i]=i;
        d[i]=0;
    }
}

int find(int x)
{
    if(far[x]==x)
    {
        return far[x];
    }
    int root=find(far[x]);
    d[x]=d[x]^d[far[x]];
    return far[x]=root;
}


int main()
{
    int n,m;
    init();
    scanf("%d%d",&n,&m);
    char op[10];
    int x,y;
    int cnt=0;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%s",&x,&y,op);
        x--;
        if(op[0]=='e')
        {
            qs[i].l=x;
            qs[i].r=y;
            qs[i].result=0;
        }
        else
        {
            qs[i].l=x;
            qs[i].r=y;
            qs[i].result=1;
        }
        mp[cnt++]=x;
        mp[cnt++]=y;
    }    
    int flag=0;
    sort(mp,mp+cnt);
    n=unique(mp,mp+cnt)-mp;
    for(int i=1;i<=m;i++)
    {
        x=lower_bound(mp,mp+n,qs[i].l)-mp;
        y=lower_bound(mp,mp+n,qs[i].r)-mp;
        int res=qs[i].result;
        int a=find(x);
        int b=find(y);
        if(a==b)
        {
            if(d[x]^d[y]==res)
                continue;
            else
            {
                printf("%d\n",i-1);
                flag=1;
                break;
            }
        }
        else
        {
            far[a]=b;
            d[a]=d[x]^d[y]^res;
        }
    }
    if(!flag)
        printf("%d\n",m);
}