hdu3397 Sequence operation

　　　　　感觉自己好像搞定了一个不得了得题呢。。

　　　　对于这种区间性质合并的线段树，对于每个节点保存一下当前区间内1的个数，左右边界相邻的1个的个数与0的个数，还有当前区间最大连续的1和0的个数.

　　　　合并的时候的细节：

　　　　1.如果lson的右边界是1并且rson的左边界是1，那么当前节点的最大连续1的值应该更新为tr[n].res=max(tr[n].res,tr[LL].r+tr[RR].l);

　　　　2.如果lson的连续1的个数等于它所表示的区间大小（这段区间的值全为1），那么当前节点的左区间连续1的个数应该更新为tr[n].l+=tr[RR].l;对于右区间的连续1的个数更新也一样。

　　　　3.对于区间中0的性质更新与1一样

　　　　更新时候的细节

　　　　1.如果当前进行的是区间覆盖，那么是需要吧区间翻转的标记置0的。

　　　　2.如果当前既需要更新区间覆盖与区间翻转，这时候只有一种可能情况就是区间覆盖是先进行赋值过的，所以在pushdown的时候区间覆盖应该先进行。

 #include<bits/stdc++.h>
 using namespace std;
 #define LL n<<1
 #define RR n<<1|1
 #define lson l,mid,LL
 #define rson mid+1,r,RR
 #define mid ((l+r)/2)
 const int maxn=;
 struct node{
     int res,ret,num,l,r,ll,rr;//最长连续1的长度,最长连续0的长度，区间内1的个数，区间内左右边界连续1的个数，0的个数
 };
 node tr[maxn<<];
 int lazy[maxn<<];//区间覆盖懒惰标记
 int chan[maxn<<];//区间翻转懒惰标记
 int a[maxn];
 void up(int l,int r,int n){
     tr[n].num=tr[LL].num+tr[RR].num;
     tr[n].res=max(tr[LL].res,tr[RR].res);
     tr[n].ret=max(tr[LL].ret,tr[RR].ret);
     tr[n].l=tr[LL].l;
     tr[n].ll=tr[LL].ll;
     tr[n].r=tr[RR].r;
     tr[n].rr=tr[RR].rr;
     if(tr[LL].r&&tr[RR].l)
     {
         tr[n].res=max(tr[n].res,tr[LL].r+tr[RR].l);
         if(mid-l+==tr[LL].res)
         tr[n].l+=tr[RR].l;
         if(r-mid==tr[RR].res)
         tr[n].r+=tr[LL].r;
     }
     if(tr[LL].rr&&tr[RR].ll)
     {
         tr[n].ret=max(tr[n].ret,tr[LL].rr+tr[RR].ll);
         if(mid-l+==tr[LL].ret)
         tr[n].ll+=tr[RR].ll;
         if(r-mid==tr[RR].ret)
         tr[n].rr+=tr[LL].rr;
     }
 }
 void built(int l,int r,int n){
     lazy[n]=-;
     chan[n]=;
     if(l==r)
     {
         tr[n].l=tr[n].r=tr[n].res=tr[n].num=a[l];
         tr[n].ret=tr[n].ll=tr[n].rr=!a[l];
         return;
     }
     built(lson);
     built(rson);
     up(l,r,n);
 }
 void pushdown(int l,int r,int n){
     if(lazy[n]!=-)
     {
         chan[LL]=chan[RR]=;
         tr[LL].num=tr[LL].l=tr[LL].r=tr[LL].res=(mid-l+)*lazy[n];
         tr[LL].ll=tr[LL].rr=tr[LL].ret=(mid-l+)*(!lazy[n]);
         tr[RR].num=tr[RR].l=tr[RR].r=tr[RR].res=(r-mid)*lazy[n];
         tr[RR].ll=tr[RR].rr=tr[RR].ret=(r-mid)*(!lazy[n]);
         lazy[LL]=lazy[RR]=lazy[n];
         lazy[n]=-;
     }
     if(chan[n])
     {
         chan[LL]^=;
         chan[RR]^=;
         tr[LL].num=mid-l+-tr[LL].num;
         tr[RR].num=r-mid-tr[RR].num;
         swap(tr[LL].res,tr[LL].ret);
         swap(tr[LL].ll,tr[LL].l);
         swap(tr[LL].rr,tr[LL].r);
         swap(tr[RR].res,tr[RR].ret);
         swap(tr[RR].ll,tr[RR].l);
         swap(tr[RR].rr,tr[RR].r);
         chan[n]=;
     }
 }
 void update(int l,int r,int n,int left,int right,int num){
     if(l>=left&&right>=r)
     {
         lazy[n]=num;
         tr[n].num=num*(r-l+);
         chan[n]=;
         tr[n].l=tr[n].r=tr[n].res=(r-l+)*num;
         tr[n].ll=tr[n].rr=tr[n].ret=(r-l+)*(!num);
         return;
     }
     pushdown(l,r,n);
     if(left<=mid)
     update(lson,left,right,num);
     if(right>mid)
     update(rson,left,right,num);
     up(l,r,n);
 }
 void change(int l,int r,int n,int left,int right){
     if(l>=left&&right>=r)
     {
         chan[n]^=;
         tr[n].num=(r-l+-tr[n].num);
         swap(tr[n].res,tr[n].ret);
         swap(tr[n].ll,tr[n].l);
         swap(tr[n].rr,tr[n].r);
         return;
     }
     pushdown(l,r,n);
     if(left<=mid)
     change(lson,left,right);
     if(right>mid)
     change(rson,left,right);
     up(l,r,n);
 }
 int out1(int l,int r,int n,int left,int right){
     if(l>=left&&right>=r)
     return tr[n].num;
     pushdown(l,r,n);
     int res=;
     if(left<=mid)
     res+=out1(lson,left,right);
     if(right>mid)
     res+=out1(rson,left,right);
     return res;
 }
 int out2(int l,int r,int n,int left,int right){
     if(l>=left&&right>=r)
     return tr[n].res;
     pushdown(l,r,n);
     int res=;
     if(left<=mid)
     res=max(res,out2(lson,left,right));
     if(right>mid)
     res=max(res,out2(rson,left,right));
     if(tr[LL].r&&tr[RR].l&&mid>=left&&mid<right)
     res=max(res,min(tr[LL].r,mid-left+)+min(tr[RR].l,right-mid));
     return res;
 }
 int main(){
     int t;
     scanf("%d",&t);
     while(t--)
     {
         int n,m;
         scanf("%d%d",&n,&m);
         for(int i=;i<=n;i++)
             scanf("%d",&a[i]);
         built(,n,);
         for(int i=;i<=m;i++)
         {

             int x,y,z;
             scanf("%d%d%d",&x,&y,&z);
             y++;
             z++;
             if(x==)
             update(,n,,y,z,);
             else
             if(x==)
             update(,n,,y,z,);
             else
             if(x==)
             change(,n,,y,z);
             if(x==)
             printf("%d\n",out1(,n,,y,z));
             else
                if(x==)
             printf("%d\n",out2(,n,,y,z));
         }
     }
     return ;
 }