hdu1199 线段树

这题说的是给了 n 个操作。 每个操作会把 【a,b】 之间的球 涂为黑色或者 白色， 然后最后问 最长的连续的白色的 球有多少个，初始的时候全是黑的。

我们将所有的点离散化， 记得离散 a-1, b+1, 因为如果你不离散 a-1 那么 在区间间隔时 间隔是黑色的 没有操作的你会计算成白色的， 然后如果不加b+1 会使得同起点的区间白色的部分会被后来比他小的黑色区间覆盖， 导致最后 白色的少了

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <string.h>
using namespace std;
typedef long long ll;
const int maxn = ;
ll X[maxn],Y[maxn];
int op[maxn];
ll Loc[maxn*];
int cL, cR ,V,tim;
ll ansL,ansR,preL,preR;
struct Itree{
    int color[maxn*];
    void build(int o, int L, int R){
         color[o]=;
    }
    void pushdown(int o){
         color[o*]=color[o];
         color[o*+]=color[o];
         color[o]=-;
    }
    void update(int o, int L , int R){
             if(cL<=L && R<=cR ){
                   color[o]=V; return;
             }
             int mid=(L+R)/;
             if(color[o]!=-) pushdown(o);
             if(cL<=mid) update(o*, L, mid);
             if(cR>mid) update(o*+, mid+, R);
    }
    void endop(int o, int L, int R){
         if(color[o]!=-){
            if(color[o]==){
                if(tim==){
                     tim=; preL=Loc[L-]; preR=Loc[R-];
                     if(preR-preL>ansR-ansL){
                         ansL=preL; ansR=preR;
                     }
                }else{
                     preR=Loc[R-];
                     if(preR-preL>ansR-ansL){
                         ansL=preL; ansR=preR;
                     }
                }
            }else
                tim=;
            return ;
         }
         if(L==R) return ;
         int mid=(L+R)/;
         endop(o*,L, mid);
         endop(o*+, mid+,R);
    }
}T;
int main()
{
    int n;
    char st[];
    while(scanf("%d",&n)==){
        int ge=;
        for(int i=; i<n; ++i ){
             scanf("%I64d%I64d%s",&X[i],&Y[i],st);
           /*  ll a = X[i] ,b =Y[i];
             X[i]=min(a,b);
             Y[i]=max(a,b);*/
             if(st[]=='b') op[i]=;
             else op[i]=;
            Loc[ge++]=X[i]; Loc[ge++]=Y[i];
            Loc[ge++]=X[i]-; Loc[ge++]=Y[i]+;
        }
        sort(Loc,Loc+ge);
        ge = unique(Loc,Loc+ge)-Loc;
        T.build(,,ge);
        for(int i=; i<n; ++i){
              cL =lower_bound(Loc,Loc+ge,X[i])-Loc+;
              cR =lower_bound(Loc, Loc+ge, Y[i])-Loc+;
              V=op[i];
              T.update(,,ge);
        }
       ansL=; ansR=-;tim=;
       T.endop(,,ge);
       if(ansL>ansR){
        puts("Oh, my god");
       }else{
         printf("%I64d %I64d\n",ansL, ansR);
      }
    }
    return ;
}