Ural(Timus) 1003 Parity

并查集

题意：题意比较好懂简单说一下。一个序列，只有0，1；输入n，表示序列长度（从1到n标号），输入m，下面m个更新，每行都是a，b，string，表示说序列中下标a到下标b的元素中有偶数个或奇数个1.没得到一个更新就更新序列的信息，知道读入第k个信息，和已建立的信息矛盾，那么结束，输出k-1，表示前面k-1个更新不矛盾，如果m个更新都成立，那么输出m

这题要转化一下，一转化就比较明显了。我们定义前缀和为sum[i]表示1到i的和，那么sum[b]-sum[a-1]=c[a]+c[a+1]+c[a+2]……c[b] ， 即序列的[a,b]区间和

因为序列中只有0,1所以区间和的奇偶性就是该区间拥有1的奇偶数，即[a,b]有偶数个1的话[a,b]区间和为偶数，同时也可知sum[b]和sum[a-1]同偶或同奇，即奇偶性相同

如果[a,b]中有奇数个1，那么sum[b]和sum[a-1]奇偶性不同

所以这个转化关系就出来了：[a,b]有偶数个1，那么sum[a-1]和sum[b]的奇偶性相同 ； [a,b]有奇数个1，那么sum[a-1]和sum[b]的奇偶性不同

而无论如何都好，sum[i]的奇偶性只能是两种，或奇或偶，所以其实sum[0],sum[1],sum[2],……sum[n]其实分成了两个阵营，也就是两个集合

如果读入了[a,b]为偶数，sum[a-1]和sum[b]，应该在同一个集合中。如果它们互相在对方的敌对集合中，那么矛盾，跳出，否则的话，记得合并它们为1个集合，并且他们的敌对集合也要合并为1个集合

如果读入[a,b]为奇数，sum[a-1]和sum[b]，应该不在同一个集合中并且应该在对方的敌对集合中。如果它们在同一个集合中，那么矛盾，跳出，否则的话，sum[a-1]合并到sum[b]的敌对集合中，sum[b]合并到sum[i-1]的敌对集合中

 

所以这题其实和经典在“朋友敌人”题目是相同（ab是朋友bc是朋友则ac是朋友，两人又共同敌人则是朋友，其实所有人分成了两个阵营）

所以这种题目都要想方法怎么建立敌人集合

一个比较好的方法是设置“虚拟”的敌人，已知有n个人，那么虚拟设置另外n个人（从n+1到2*n）标号，i+n表示i的敌人，其实i+n并不存在（只有n个人），它只是用了作为一个标志，标杆。这个方法有个好处，就是最初的时候我们什么信息都不知道，并不知道每个元素的敌人和朋友是谁，换言之我们不知道敌人集合是哪个（朋友集合可以初始化为它自己，即一开始自身就是个集合），所以我们用i+n作为i的敌人集合，然后在以后的更新中不断更新即可

这不是唯一的方法但我认为是一个不容易出错，代码少，好理解的方法

 

最后差点忘记了，这题数据太大了，10^9，而更新的次数只有5000，也就是说最坏情况下降产生10000个点，所以我们要离散化，而且可以发现序列的长度n，其实根本就没有用到，不需要它

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 10010 //最多10000个点
#define M 5010
#define min(a,b) a<b?a:b
#define max(a,b) a>b?a:b

int m,np;
struct ran{
    int l,r,v;
}a[M];
struct point{
    int n,m;
}c[N];
int p[2*N];

int cmp(struct point a ,struct point b)
{
    return a.n<b.n;
}

int init() //输入数据和离散化
{
    scanf("%d",&m);
    np=0;
    for(int i=0; i<m; i++)
    {
        int l,r;
        char s[5];
        scanf("%d%d%s",&l,&r,s);
        a[i].v=(s[0]=='o');
        c[np].m=i;   c[np].n=l;
        c[np+1].m=i; c[np+1].n=r;
        np+=2;
    }
    sort(c,c+np,cmp);
    int mm,nn=0;
    for(int i=0; i<np; i++)
    {
        if(i==0 || c[i].n != c[i-1].n) ++nn;
        mm=c[i].m; a[mm].r=a[mm].l; a[mm].l=nn;
    }
//    for(int i=0; i<m; i++) printf("[%d,%d] %d\n",a[i].l,a[i].r,a[i].v);
    //离散化结束
    return nn;
}

int find(int x)
{
    return x==p[x] ? x : p[x]=find(p[x]);
}


void solve(int n)
{
    for(int i=0; i<=2*N+1; i++) p[i]=i;
    int res=m;
    for(int i=0; i<m; i++)
    {
        int l=a[i].l , r=a[i].r , v=a[i].v;
        int t=max(l,r) , tt=min(l,r);
        l=tt-1; r=t;

        int fal,far,eml,emr;
        fal=find(l);
        far=find(r);
        eml=find(l+n+1);
        emr=find(r+n+1);

        if(!v)
        {
            if(fal == emr && far == eml)
            { res=i; break;}
            p[fal]=far;
            p[eml]=emr;
        }
        else
        {
            if(fal == far)
            { res=i; break; }
            p[fal]=emr;
            p[far]=eml;
        }
    }
    printf("%d\n",res);
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF && n!=-1)
    {
        n=init();
        solve(n);
    }
    return 0;
}