hdu 3911-区间合并、更新和查询Black And White （&& hdu 1199）

http://acm.hdu.edu.cn/showproblem.php?pid=3911

一个序列要么是1，要么是0.

操作：

        修改：修改区间[a,b]，使0变成1，1变成0；

        询问：区间[a,b]最长的连续1有多长？

解：

        线段树。

节点信息：

preb,sufb,prew,sufw,mxb,mxw;分别表示最长1前缀，最长1后缀，最长0前缀，最长0后缀，本区间最长1，本区间最长0.

       之所以这么多个东西，是为了修改的时候方便。只要将带0的和带1的换一下就好了。

        更新的时候不要更新到底，需要lazy操作。

        询问的时候和push_up的时候，需要将情况考虑周全。 

做的时候的问题：

       更新的时候肿么办呢？不能由根再更新叶子啊。-------原来就是一个lazy操作，就是要更新到叶子，用lazy优化。

       之前想的节点少了几个前缀和后缀，然后没想通更新的时候肿么更新。

       查询的时候必须是三段式的。当查询区间在m左右两端的时候，最长可能只在m左边，可能只在m右边，可能包括m。这些都是不能落掉的。

       WA了n次之后觉得，应该是一个细节问题没有处理好。

A之后：

      又WA了有个把小时。关键在于细节。刚开始是真的有些问题没考虑到或者考虑错了（比如query那里和最长子串的维护），但是后面之所以错就是细节。把原本写好的col[] = 0给删了，这样导致每次用的lazy标记混乱。还有就是把sufw写成了sufb，这可完全是细节问题啊！！！不过心里暗示挺重要的，知道是细节问题之后我就写注释什么的，找出来只花了十几分钟。

/*
Pro: 0

Sol:

date:
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <set>
#include <vector>
#define maxn 111111
#define lson l, m , rt << 1
#define rson m + 1, r,rt << 1 | 1
#define ls (rt << 1)
#define rs (rt << 1 | 1)
#define havem int m = (l + r) >> 1
using namespace std;
int n,Q,ax;
int preb[maxn << 2],sufb[maxn << 2],mxb[maxn << 2];
int prew[maxn << 2],sufw[maxn << 2],mxw[maxn << 2],col[maxn << 2];
int num[maxn];
inline int max(int a, int b) {return a > b? a: b;}
inline int min(int a, int b) {return a < b? a: b;}
void push_up(int rt,int m){
//维护前缀
    preb[rt] = preb[ls];//先等于左孩子的前缀
    prew[rt] = prew[ls];
    if(preb[ls] == m - (m >> 1)) preb[rt] += preb[rs];//如果左孩子的前缀长度等于左孩子区间长度，
    if(prew[ls] == m - (m >> 1)) prew[rt] += prew[rs];//那么，加上右孩子的前缀
//维护后缀
    sufb[rt] = sufb[rs];//先等于右孩子的后缀
    sufw[rt] = sufw[rs];//我勒个去，就是这里写成sufb了，WA了n次啊。。。
    if(sufb[rs] == (m >> 1))  sufb[rt] += sufb[ls];//如果右孩子的后缀长度等于右孩子区间长度
    if(sufw[rs] == (m >> 1))  sufw[rt] += sufw[ls];//那么，加上左孩子的后缀
//维护本区间最长的长串
    mxb[rt] = max(mxb[ls],mxb[rs]);//这里也错了。
    mxb[rt] = max(mxb[rt], sufb[ls] + preb[rs]);
    mxw[rt] = max(mxw[ls],mxw[rs]);//最长串要不单独在左孩子，要不在右孩子
    mxw[rt] = max(mxw[rt], sufw[ls] + prew[rs]);//要不同时分布在左孩子、右孩子
}
inline void exchange(int rt){//交换
    swap(preb[rt],prew[rt]);
    swap(sufb[rt],sufw[rt]);
    swap(mxb[rt],mxw[rt]);
}
void push_dn(int rt){
    if(col[rt]){
        col[ls] ^= 1, col[rs] ^= 1, col[rt] = 0;
        exchange(ls);     exchange(rs);//这里错了
    }
}
void build(int l, int r, int rt){
    col[rt] = 0;
    if(l == r){
        scanf("%d",&ax);
        if(ax == 1){//如果是黑色的
            preb[rt] = sufb[rt] = mxb[rt] = 1;
            prew[rt] = sufw[rt] = mxw[rt] = 0;
        }else{//如果是白色的
            preb[rt] = sufb[rt] = mxb[rt] = 0;
            prew[rt] = sufw[rt] = mxw[rt] = 1;
        }
        return ;
    }havem;
    build(lson); build(rson);
    push_up(rt,r - l + 1);
}
void update(int& L, int& R, int l, int r, int rt){//区间更新
    if(L <= l && r <= R){
        col[rt] ^= 1; exchange(rt);//改变自身之后，改变lazy标志
        return ;
    }push_dn(rt);
    havem;
    if(L <= m) update(L,R,lson);
    if(R > m) update(L,R,rson);
    push_up(rt,r - l + 1);
}
int query(int& L, int& R, int l, int r, int rt){
    if(L <= l && r <= R) return mxb[rt];
    push_dn(rt);    havem;
    if(L > m)   return query(L,R,rson);
    if(R <= m) return   query(L,R,lson);
    int t1 = query(L,R,lson);
    int t2 = query(L, R, rson);
    int wa1 = min(m - L + 1, sufb[ls]);//这里又错了两次m - L 才对，我写成L - m了
    int wa2 = min(R - m, preb[rs]);//应该取一个最小值才行。
    return max(max(t1,t2),wa1 + wa2);
}
int main(){
    int op,a,b;
    while(scanf("%d",&n) != EOF){
        build(1,n,1);
        scanf("%d",&Q);
        for(int i = 1;i <= Q; i ++){
            scanf("%d%d%d",&op,&a,&b);
            if(op == 1){
                update(a,b,1,n,1);
            }else{
                int ans = query(a,b,1,n,1);
                printf("%d\n",ans);
            }
        }
    }
	return 0;
}