POJ - 1733 Parity game（离散化+扩展域并查集）

题目：

Now and then you play the following game with your friend. Your friend writes down a sequence consisting of zeroes and ones. You choose a continuous subsequence (for example the subsequence from the third to the fifth digit inclusively) and ask him, whether this subsequence contains even or odd number of ones. Your friend answers your question and you can ask him about another subsequence and so on. Your task is to guess the entire sequence of numbers. 

You suspect some of your friend's answers may not be correct and you want to convict him of falsehood. Thus you have decided to write a program to help you in this matter. The program will receive a series of your questions together with the answers you have received from your friend. The aim of this program is to find the first answer which is provably wrong, i.e. that there exists a sequence satisfying answers to all the previous questions, but no such sequence satisfies this answer.

Input

The first line of input contains one number, which is the length of the sequence of zeroes and ones. This length is less or equal to 1000000000. In the second line, there is one positive integer which is the number of questions asked and answers to them. The number of questions and answers is less or equal to 5000. The remaining lines specify questions and answers. Each line contains one question and the answer to this question: two integers (the position of the first and last digit in the chosen subsequence) and one word which is either `even' or `odd' (the answer, i.e. the parity of the number of ones in the chosen subsequence, where `even' means an even number of ones and `odd' means an odd number).

Output

There is only one line in output containing one integer X. Number X says that there exists a sequence of zeroes and ones satisfying first X parity conditions, but there exists none satisfying X+1 conditions. If there exists a sequence of zeroes and ones satisfying all the given conditions, then number X should be the number of all the questions asked.

Sample Input

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

Sample Output

3

中文题意：

小明C语言考了99分，想向爸爸要一套算法书作为奖励，但是小明爸爸却一定要带小明出去玩。协商过 后，小明爸爸决定，只要小明能解决小明爸爸的这个问题，小明就不用出去玩，可以宅在家里学习算 法。
小明爸爸写下一串长度为N的01序列，小明可以对其进行M次询问，每次询问 [l, r] 区间(闭区间) 内有奇数个1还是偶数个1，最后给出该序列。
这么简单的问题当然难不倒小明，但是小明担心小明爸爸为了让他出去玩乱给询问答案，想知道小明爸
爸有没有撒谎，你能帮帮小明吗?
注:回答自相矛盾则代表撒谎，反之则认为没有撒谎。

分析：先来思考一个问题，假如[l, r] 区间内有奇数个1，这个条件表示什么含义？是不是说明sum[r]-sum[l-1]是一个奇数，同理[l, r] 区间内有偶数个1，也就说明sum[r]-sum[l-1]是一个偶数。

序列中每个值只能是1或者0两种情况，类似于食物链那道题目中每种动物只能属于三种类别之一。假如当前位置为序列的第i个位置，我们可以将第i个位置与第i+n个位置分别放置在两个不同的集合中，代表以当前序列为结尾的前缀和是奇数还是偶数，每次合并都会将他们两个数分别合并至不同集合，再逐个分析每个条件看是否会出现矛盾。

具体分析条件如下：

假如[l, r] 区间内有奇数个1，那么第l-1个节点与第r个节点一定不会出现在一个集合中，否则就会出现矛盾，判断完这个条件后就把第l-1个节点和第r+n个节点以及第l-1+n个节点和第r个节点合并到一个集合（代表一奇一偶）。

假如[l, r] 区间内有偶数个1，那么第l-1个节点和第r+n个节点或者第l-1+n个节点和第r个节点一定不会出现在一个集合中，否则就会出现矛盾，判断完这个条件后就把第l-1个节点和第r个节点或者第l-1+n个节点和第r个节点合并到一个集合（代表二奇或二偶）。

这就是这道题目的思路了，下面是代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
const int N=50003;
char op[N][10];
int l[N],r[N],fu[N];
vector<int> alls;//离散化数组
int find(int x)
{
	if(fu[x]!=x) fu[x]=find(fu[x]);
	return fu[x];
} 
int f(int x)
{
	return lower_bound(alls.begin(),alls.end(),x)-alls.begin()+1;
}
void Unite(int x,int y)
{
	int f1=find(x),f2=find(y);
	if(f1!=f2) fu[f1]=f2;
}
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%s",&l[i],&r[i],op[i]);
		alls.push_back(l[i]-1);
		alls.push_back(r[i]);
	}
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());
	n=alls.size();//更新n为离散化数组的最大编号
	for(int i=1;i<=2*n;i++) fu[i]=i;
	int ll,rr;
	for(int i=1;i<=m;i++)
	{
		ll=f(l[i]-1),rr=f(r[i]);
		if(op[i][0]=='e')
		{
			if(find(ll)==find(rr+n))
			{
				printf("%d",i-1);
				return 0;
			}
			Unite(ll,rr);
			Unite(ll+n,rr+n);
		}
		else
		{
			if(find(ll)==find(rr))
			{
				printf("%d",i-1);
				return 0;
			}
			Unite(ll,rr+n);
			Unite(ll+n,rr);
		}
	}
	printf("%d",m);
	return 0;
}