[HDOJ3911]Black And White（线段树，区间合并）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3911

题意：一个01串，两种操作：

0 a b：查询[a,b]内连续1的最长长度。

1 a b：翻转[a,b]内的所有数字（0变1，1变0）。

更新操作落实到具体数字，这时候不能莽直接更新数字对吧，我们要考虑翻转这个操作如何跟懒惰标记对上。让我们可以通过懒惰标记间接更新而不是直接每次更新到叶子。

我们知道一个性质：翻转偶数次相当于没有翻转，那么懒惰标记就来标记翻转次数的奇偶吧，假如是偶数次，那么不需要往下更新了。但是这样的话偶数次解决了，奇数次岂不是还要更新。我们要求连续的1的长度，需要维护一组1的长度（从左起最长、从右起最长、区间内最长），那么再对应地维护一组0的长度，反转的时候相当于这两组数字的交换，每次更新再pushup就没有问题了。

 #include <bits/stdc++.h>
 using namespace std;

 #define lrt rt << 1
 #define rrt rt << 1 | 1
 typedef struct Node {
     int l, r, v;
     int lone, sone, rone;
   int lzero, szero, rzero;
 }Node;
 const int maxn = ;
 int cmd;
 int n, q;
 int x[maxn];
 Node seg[maxn<<];

 void pushUP(int rt, int len) {
   seg[rt].lone = seg[lrt].lone; seg[rt].rone = seg[rrt].rone;
   seg[rt].lzero = seg[lrt].lzero; seg[rt].rzero = seg[rrt].rzero;
   if(seg[rt].lone == len-len/) seg[rt].lone += seg[rrt].lone;
   if(seg[rt].rone == len/) seg[rt].rone += seg[lrt].rone;
   if(seg[rt].lzero == len-len/) seg[rt].lzero += seg[rrt].lzero;
   if(seg[rt].rzero == len/) seg[rt].rzero += seg[lrt].rzero;
   seg[rt].sone = max(seg[lrt].sone, seg[rrt].sone);
   seg[rt].sone = max(seg[rt].sone, seg[lrt].rone+seg[rrt].lone);
   seg[rt].szero = max(seg[lrt].szero, seg[rrt].szero);
   seg[rt].szero = max(seg[rt].szero, seg[lrt].rzero+seg[rrt].lzero);
 }

 void pushDOWN(int rt) {
   if(seg[rt].v) {
     seg[rt].v = ;
     seg[lrt].v = !seg[lrt].v;
     seg[rrt].v = !seg[rrt].v;
     swap(seg[lrt].lone, seg[lrt].lzero);
     swap(seg[lrt].rone, seg[lrt].rzero);
     swap(seg[lrt].sone, seg[lrt].szero);
     swap(seg[rrt].lone, seg[rrt].lzero);
     swap(seg[rrt].rone, seg[rrt].rzero);
     swap(seg[rrt].sone, seg[rrt].szero);
   }
 }

 void build(int l, int r, int rt) {
   seg[rt].l = l; seg[rt].r = r; seg[rt].v = ;
   if(l == r) {
     seg[rt].lone = seg[rt].rone = seg[rt].sone = (x[l] == ) ?  : ;
     seg[rt].lzero = seg[rt].rzero = seg[rt].szero = (x[l] == ) ?  : ;
     return;
   }
   int mid = (l + r) >> ;
   build(l, mid, lrt);
   build(mid+, r, rrt);
   pushUP(rt, r-l+);
 }

 void update(int L, int R, int rt) {
   if(L <= seg[rt].l && seg[rt].r <= R) {
     swap(seg[rt].lone, seg[rt].lzero);
     swap(seg[rt].rone, seg[rt].rzero);
     swap(seg[rt].sone, seg[rt].szero);
     seg[rt].v = !seg[rt].v;
     return;
   }
   pushDOWN(rt);
   int mid = (seg[rt].l + seg[rt].r) >> ;
   if(L <= mid) update(L, R, lrt);
   if(mid < R) update(L, R, rrt);
   pushUP(rt, seg[rt].r-seg[rt].l+);
 }

 int query(int L, int R, int rt) {
   if(L == seg[rt].l && R == seg[rt].r) return seg[rt].sone;
   pushDOWN(rt);
   int mid = (seg[rt].l + seg[rt].r) >> ;
   if(mid >= R) return query(L, R, lrt);
   else if(mid +  <= L) return query(L, R, rrt);
   else {
     int tmp = max(query(L, mid, lrt), query(mid+, R, rrt));
     tmp = max(tmp, min(seg[lrt].rone,mid-L+)+min(seg[rrt].lone,R-mid));
     return tmp;
   }
 }

 int main() {
   //freopen("in", "r", stdin);
   int a, b;
   while(~scanf("%d", &n)) {
     for(int i = ; i <= n; i++) scanf("%d", &x[i]);
     build(, n, );
     scanf("%d", &q);
     while(q--) {
       scanf("%d %d %d", &cmd, &a, &b);
       if(cmd == ) printf("%d\n", query(a, b, ));
       else update(a, b, );
     }
   }
   return ;
 }