hdu 3397 线段树~~综合题（区间合并，求和，跟新，查询）

题意：输入 t组数据 n个数 m 次操作。
      0 1 3 将区间1--3置0
      1 1 3 ~~置1
      2 1 3 ~~取反0变1，1边0
      3 1 3 ~~ 区间有多少个1

      4 1 3 ~~区间最多有多少个连续的1

思路：这个题比较综合，有个区间求和，区间合并，区间查询。区间更新当时晚上做的当晚没有改出来，改到12点多。

一个错误硬是没找到，然后第二天打完比赛将比赛没做出的题目掌握
又来看了下思路.发现是思路有些错误 ，这里是有两个延迟标记，一个标记取反，一个标记置1，置0，
我当时想的是 如果延迟标记1来了，就将取反的延迟标记去掉。当然这里是对的，但是，当时我还想~~~~
当取反标记来了，就将置0置1的延迟标记去掉，但是 这样子是错误的，因为取反是的根据你变化后的标记去取反。
所以是思路错误了~。

细心一点~~慢慢来，不要急。

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
//#define MAX 10*10*10*10*10+2//注意~~
#define MAX 100010
int rsum1[MAX*4];//最右边连续1的个数
int lsum1[MAX*4];//最左边
int msum1[MAX*4];//这个区间连续1的个数
int rsum0[MAX*4];
int lsum0[MAX*4];
int msum0[MAX*4];
int sum[MAX*4];//区间求和
int add[MAX*4];//lazy标记，要不要取反，当取反两次，就返回自己了，就不必要取反了
int add1[MAX*4];//置0置1的lazy标记
int array[MAX];
int a,b;
int ma;
int n,m;
int max(int x,int y)
{
    if(x<y) return y;
    return x;
}
void pushup(int rt,int left,int right)//合并
{   int mid=(left+right)/2;
    int ll=mid-left+1;//此区间左子树的叶子节个数
    int rl=right-mid;//右子树~~~~
    lsum1[rt]=lsum1[rt*2];//首先无疑问直接等于他儿子最左边的1的连续个数
    rsum1[rt]=rsum1[rt*2+1];//首先无疑问直接等于他儿子最右边的1的连续个数
    rsum0[rt]=rsum0[rt*2+1];//同理
    lsum0[rt]=lsum0[rt*2];
    if(lsum1[rt]==ll) lsum1[rt]+=lsum1[rt*2+1];//当最左边的个数为满那么就得加上右子树最左边画个图就明白
    if(rsum1[rt]==rl) {rsum1[rt]+=rsum1[rt*2];}//当最右边1的个数为满就得加上左子树的最右边连续1的个数。
    if(lsum0[rt]==ll) lsum0[rt]+=lsum0[rt*2+1];
    if(rsum0[rt]==rl) rsum0[rt]+=rsum0[rt*2];
     msum0[rt]=max(max(msum0[rt*2],msum0[rt*2+1]),rsum0[rt*2]+lsum0[rt*2+1]);//最大值等于 左子树的最大，右字数的最大，左子树最右边连续1的个数+右字数最左边连续1的个数。三者去最大
     msum1[rt]=max(max(msum1[rt*2],msum1[rt*2+1]),rsum1[rt*2]+lsum1[rt*2+1]);//0同理
     sum[rt]=sum[rt*2]+sum[rt*2+1];
}
void build(int rt,int left,int right)//根平常线段树几乎一样
{
   add[rt]=0;
   add1[rt]=-1;
   rsum1[rt]=lsum1[rt]=msum1[rt]=0;
   rsum0[rt]=lsum0[rt]=msum0[rt]=0;
   sum[rt]=0;
   if(left==right)
   {
      if(array[left]) {
                  rsum1[rt]=lsum1[rt]=msum1[rt]=1;
                  rsum0[rt]=lsum0[rt]=msum0[rt]=0;
                  sum[rt]=1;
                }
        else
        {
            rsum1[rt]=lsum1[rt]=msum1[rt]=0;
             rsum0[rt]=lsum0[rt]=msum0[rt]=1;
             sum[rt]=0;
        }
        return ;
   }
   int mid=(left+right)/2;
   build(rt*2,left,mid);
   build(rt*2+1,mid+1,right);
   pushup(rt,left,right);//回溯的时候合并
}
void swa(int rt)
{
        swap(rsum1[rt],rsum0[rt]);
        swap(lsum1[rt],lsum0[rt]);
        swap(msum1[rt],msum0[rt]);

}
void pushdown(int rt,int left,int right)//将lazy标记传递下去
{  
     if(add1[rt]!=-1)
      {
        int mid=(left+right)/2;
        sum[rt*2]=(mid-left+1)*add1[rt];
        sum[rt*2+1]=(right-mid)*add1[rt];
        msum1[rt*2]=lsum1[rt*2]=rsum1[rt*2]=(mid-left+1)*add1[rt];
        msum1[rt*2+1]=lsum1[rt*2+1]=rsum1[rt*2+1]=(right-mid)*add1[rt];
        msum0[rt*2]=lsum0[rt*2]=rsum0[rt*2]=(mid-left+1)*(!add1[rt]);
        msum0[rt*2+1]=lsum0[rt*2+1]=rsum0[rt*2+1]=(right-mid)*(!add1[rt]);
        add1[rt*2]=add1[rt*2+1]=add1[rt];
        add1[rt]=-1;
        add[rt*2]=add[rt*2+1]=0;
      }
    if(add[rt]==1)
      {
       int mid=(left+right)/2;
       add[rt*2]^=1;
       add[rt*2+1]^=1;
       add[rt]=0;
       swa(rt*2);
       swa(rt*2+1);
       sum[rt*2]=(mid-left+1)-sum[rt*2];//取反之后1变0，0，变1，所以拿这个区间的总个数-去1的个数和就取反了。
       sum[rt*2+1]=(right-mid)-sum[rt*2+1];
      //add1[rt*2]=add1[rt*2+1]=-1;
      }
  

}
void update(int rt,int left,int right)//日常更新，更新就交换区间里0和1的个数即可
{   //printf("rt=%d %d %d\n",rt,left,right);
    if(left>=a&&right<=b)
    {
        swa(rt);
        add[rt]^=1;
        sum[rt]=(right-left+1)-sum[rt];
       // printf("%d %d %d\n",sum[rt],right-left+1,sum[rt]);
      //  add1[rt]=-1;
        return ;
    }
    pushdown(rt,left,right);
    int mid=(left+right)/2;
    if(a<=mid) update(rt*2,left,mid);
    if(b>mid)  update(rt*2+1,mid+1,right);
    pushup(rt,left,right);
}
void update1(int rt,int left,int right,int c)
{
    if(left>=a&&right<=b)
    {

        add[rt]=0;
        add1[rt]=c;
        if(c==1)
        {

            sum[rt]=right-left+1;
         //   printf("sum %d %d %d %d\n",rt,sum[rt],right,left);
            rsum1[rt]=lsum1[rt]= msum1[rt]=right-left+1;
            rsum0[rt]=lsum0[rt]= msum0[rt]=0;

        }
        else
        {
           sum[rt]=0;
         //   printf("sum %d %d %d %d\n",rt,sum[rt],right,left);
           rsum1[rt]=lsum1[rt]= msum1[rt]=0;
           rsum0[rt]=lsum0[rt]= msum0[rt]=right-left+1;
        }
        return ;
    }
     pushdown(rt,left,right);
    int mid=(left+right)/2;
    if(a<=mid) update1(rt*2,left,mid,c);
    if(b>mid)  update1(rt*2+1,mid+1,right,c);
    pushup(rt,left,right);
}
int query(int rt,int left,int right)
{
    if(left>=a&&right<=b)//查询到这个区间
    {
        return msum1[rt];

    }
    pushdown(rt,left,right);
    int mid=(left+right)/2;
    if(b<=mid) return query(rt*2,left,mid);
    if(a>mid) return query(rt*2+1,mid+1,right);
    //当要查询的区间既不全在左树，又不全在又树的时候，就得判断，左子树的大，还是右大，还是左子树的最右边连续1的个数+上右子树最左边连续1的个数大，取三者最大。
        int ls=query(rt*2,left,mid);//左子树最大连续1
        int rs=query(rt*2+1,mid+1,right);//右子树最大连续一
        //中间连续1的个数。
        int lll=rsum1[rt*2];//左子树最右边最长连续1的个数，不能大于他要查询的 左区间（a）到左子树最由端点的个数。
        if(lll>mid-a+1) lll=mid-a+1;
        int rrr=lsum1[rt*2+1];//右子树最左边最长的1的个数，不能大于他要查询右子树，的最左侧端点到 右区间（b）。
        if(rrr>b-(mid+1)+1) rrr=b-(mid+1)+1;
        return max(max(ls,rs),lll+rrr);


}
void query1(int rt,int left,int right)
{ // printf("%d %d %d\n",rt,left,right);
    if(left>=a&&right<=b)
    {
        ma+=sum[rt];
      //  printf("%d\n",sum[rt]);
        return ;
    }
     pushdown(rt,left,right);
    int mid=(left+right)/2;
    if(a<=mid) query1(rt*2,left,mid);
    if(b>mid) query1(rt*2+1,mid+1,right);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
   {
       scanf("%d%d",&n,&m);
       for(int i=1;i<=n;i++)
       {
           scanf("%d",&array[i]);
       }
       build(1,1,n);
       int op;
        for(int i=1;i<=m;i++)
        {
           scanf("%d%d%d",&op,&a,&b);
           a++,b++;
            if(op==0)
            {
                update1(1,1,n,0);
            }
            else if(op==1)
            {
                update1(1,1,n,1);
            }
            else if(op==2)
            {
                update(1,1,n);
            }
            else if(op==3)
            {
                ma=0;
                query1(1,1,n);
               printf("%d\n",ma);
            }
            else {
               printf("%d\n",query(1,1,n));
            }

        }
   }
   return 0;
}