H - Parity game-poj1733（需要离散化）

题意：给一个序列这个序列都是由0和1组成，现在随意拿出来一个序列，然后说出他的和是奇数还是偶数，因为有可能存在假话，让你判断前多少条没有假话，也就是查找第一个假话的位置-1

//////////////////////////////////////////////////

这道题很像D题，都是线段区间，不过数据比较大，需要离散化一下。

 

 

#include <stdio.h>
#include<algorithm>
using  namespace std;

const  int maxn =  100005;

int f[maxn], val[maxn]; // val记录区间奇偶值
int p[maxn]; // p数组保存需要离散化的数据

struct node{ int u, v, sum;}a[maxn]; // 保存输入

int Find( int x)
{
     int k = f[x];

     if(f[x] != x)
    {
        f[x] = Find(f[x]);
        val[x] = (val[x]+val[k])% 2;
    }

     return f[x];
}

int main()
{
     int N;

     while(scanf( " %d ", &N) != EOF)
    {
         int i, M, k= 0;
         char s[ 10];

        scanf( " %d ", &M);

         for(i= 0; i<M; i++)
        {
            scanf( " %d%d%s ", &a[i].u, &a[i].v, s);
            a[i].sum = (s[ 0] ==  ' e ' ?  0 :  1);
             // 为防止不在两个不相邻的数离散化后相邻，在他们中间加一个数
            p[k++] = a[i].u, p[k++] = a[i].u- 1;
            p[k++] = a[i].v, p[k++] = a[i].v- 1;
        }
        p[k++] = N, p[k++] = N- 1;
        sort(p, p+k);
        N = unique(p, p+k) - p; // 去重复函数

         for(i= 0; i<N; i++)
            f[i] = i, val[i] =  0;

         for(i= 0; i<M; i++)
        {
             int u = lower_bound(p, p+N, a[i].u- 1) - p; // 二分查询
             int v = lower_bound(p, p+N, a[i].v) - p;

             int ru = Find(u), rv = Find(v);

             if(ru == rv && (val[u]+a[i].sum)% 2 != val[v])
                 break;
             if(ru < rv)
            {
                f[rv] = ru;
                val[rv] = (val[u]+a[i].sum-val[v]+ 2)% 2;
            }
             else  if(ru > rv)
            {
                f[ru] = rv;
                val[ru] = (val[v]-a[i].sum-val[u]+ 2)% 2; // 注意别写错val里面的参数
            }
        }

        printf( " %d\n ", i);
    }

     return  0;
}