HNCU专题训练_线段树（2）

1.统计颜色，或运算的运用
2.区间第k大数
3.一个很经典的题
5.求区间相等数字的个数
6.RMQ模板题，区间最大值和最小值的差

1.很好的思路，用或运算来避免左右儿子树总相同颜色的情况。由于
T颜色种类最多30种，__int64 足够用了。
注意初始化就行。

5.关键是写对make_up()这个函数，向上更新需要考虑的问题。经典题型。

1001

 /*

 求区间[l,r]中，颜色的总类。
 如何避免重复？----或运算。

 */

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #define HH 1
 using namespace std;

 struct node
 {
     int l;
     int r;
     int color;
     __int64 num;
 }f[*];

 void build(int l,int r,int n)
 {
     int mid=(l+r)/;
     f[n].l=l;
     f[n].r=r;
     f[n].color=;
     f[n].num=<<;
     if(l==r)
     return ;
     build(l,mid,n*);
     build(mid+,r,n*+);
 }

 void make_down(int n)
 {
     f[n*].color=f[n*+].color=HH;

     f[n*].num=f[n*+].num=f[n].num;

     f[n].color=;
     f[n].num=;
 }

 void update(int l,int r,int num,int n)
 {
     int mid=(f[n].l+f[n].r)/;

     if(f[n].l==l && f[n].r==r)
     {
         f[n].color=HH;
         f[n].num=<<num;
         return;
     }
     if(f[n].color==HH)
     make_down(n);
     if(mid>=r)
     update(l,r,num,n*);
     else if(mid<l)
     update(l,r,num,n*+);
     else
     {
         update(l,mid,num,n*);
         update(mid+,r,num,n*+);
     }
     f[n].num=f[n*].num|f[n*+].num;
 }

 __int64 query(int l,int r,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     __int64 cur=;
     if(f[n].l==l && f[n].r==r)
     {
         return f[n].num;
     }
     if(f[n].color==HH)
     make_down(n);
     if(mid>=r)
     cur=query(l,r,n*);
     else if(mid<l)
     cur=query(l,r,n*+);
     else
     {
         cur=query(l,mid,n*)|query(mid+,r,n*+);
     }
     f[n].num=f[n*].num|f[n*+].num;
     return  cur;

 }

 int Get_num(__int64 num) //得到1的个数  很优化的算法。
 {
     int count=;
     while(num)
     {
         ++count;
         num=(num-)&num;
     }
     return count;
 }

 void make_ini(int L,int T,int O)
 {
     int A,B,num,hxl;
     __int64 tmp;
     char a[];
     while(O--)
     {
         scanf("%s",a);
         if(a[]=='C')
         {
             scanf("%d%d%d",&A,&B,&num);
             if(A>B)
             {
                 hxl=A;
                 A=B;
                 B=hxl;
             }
             if(num<=T)
             update(A,B,num,);
         }
         else if(a[]=='P')
         {
             scanf("%d%d",&A,&B);
             if(A>B)
             {
                 hxl=A;
                 A=B;
                 B=hxl;
             }
             tmp=query(A,B,);
             printf("%d\n",Get_num(tmp));
         }
     }
 }

 int main()
 {
     int L,T,O;
     while(scanf("%d%d%d",&L,&T,&O)>)
     {
         build(,L,);
         make_ini(L,T,O);
     }
     return ;
 }

1002

 /*
 第k小的数

 */

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #define NN 100010
 using namespace std;

 int toleft[][NN];
 int Tree[][NN];
 int Sort[NN];

 void build(int l,int r,int dep)
 {
     int mid=(l+r)/,sum=mid-l+,lpos,rpos,i;
     if(l==r) return ;
     for(i=l;i<=r;i++)
     if(Tree[dep][i]<Sort[mid]) sum--;
     lpos=l;
     rpos=mid+;
     for(i=l;i<=r;i++)
     {
         if(Tree[dep][i]<Sort[mid])
         {
             Tree[dep+][lpos++]=Tree[dep][i];
         }
         else if(Tree[dep][i]==Sort[mid] && sum>)
         {
             Tree[dep+][lpos++]=Tree[dep][i];
             sum--;
         }
         else
         {
             Tree[dep+][rpos++]=Tree[dep][i];
         }
         toleft[dep][i]=toleft[dep][l-]+lpos-l;
     }
     build(l,mid,dep+);
     build(mid+,r,dep+);
 }

 int query(int L,int R,int l,int r,int k,int dep)
 {
     int mid=(L+R)/,newl,newr,cur;
     if(l==r) return Tree[dep][l];
     cur=toleft[dep][r]-toleft[dep][l-];
     if(cur>=k)
     {
         newl=L+toleft[dep][l-]-toleft[dep][L-];
         newr=newl+cur-;
         return query(L,mid,newl,newr,k,dep+);
     }
     else
     {
         newr=r+(toleft[dep][R]-toleft[dep][r]);
         newl=newr-(r-l-cur);
         return query(mid+,R,newl,newr,k-cur,dep+);
     }
 }

 void make_ini(int N,int M)
 {
     int l,r,k;
     while(M--)
     {
         scanf("%d%d%d",&l,&r,&k);
         printf("%d\n",query(,N,l,r,k,));
     }
 }

 int main()
 {
     int N,M,i;
     while(scanf("%d%d",&N,&M)>)
     {
         for(i=;i<=N;i++)
         {
             scanf("%d",&Tree[][i]);
             Sort[i]=Tree[][i];
         }
         sort(Sort+,Sort++N);
         build(,N,);
         make_ini(N,M);
     }
     return ;
 }

1003

 #include<cstdio>
 #include<iostream>
 #include<cstdlib>
 #define HH 1 //纯色
 using namespace std;

 struct st
 {
     __int64 l;
     __int64 r;
     __int64 num;
     __int64 color;
     __int64 max;
 }f[*];
 __int64 date[];

 void build(__int64 l,__int64 r,__int64 n)
 {
     __int64 mid=(l+r)/;
     f[n].l=l;
     f[n].r=r;
     f[n].color=;
     f[n].num=;
     if(l==r)
     {
         f[n].max=date[l];
         return;
     }
     build(l,mid,n*);
     build(mid+,r,n*+);
     f[n].max=f[n*].max+f[n*+].max;
 }

 void make_down(__int64 n)
 {

     f[n*].num+=f[n].num;
     f[n*].color=HH;
     f[n*].max+=f[n].num*(f[n*].r-f[n*].l+);

     f[n*+].num+=f[n].num;
     f[n*+].color=HH;
     f[n*+].max+=f[n].num*(f[n*+].r-f[n*+].l+);

     f[n].color=;f[n].num=;
 }

 void update(__int64 l,__int64 r,__int64 num,__int64 n)
 {
     __int64 mid=(f[n].l+f[n].r)/;
     if(f[n].l==l && f[n].r==r)
     {
         f[n].num+=num;
         f[n].max+=num*(f[n].r-f[n].l+);
         f[n].color=HH;
         return ;
     }
     if(f[n].color==HH)
         make_down(n);
     if(mid>=r)
         update(l,r,num,n*);
     else if(mid<l)
         update(l,r,num,n*+);
     else
     {
         update(l,mid,num,n*);
         update(mid+,r,num,n*+);
     }
     f[n].max=f[n*].max+f[n*+].max;
 }

 __int64 query(__int64 l,__int64 r,__int64 n)
 {
     __int64 mid=(f[n].l+f[n].r)/;
     __int64 cur=;
     if(f[n].l==l && f[n].r==r)
     {
         return f[n].max;
     }
     if(f[n].color==HH)
         make_down(n);
     if(mid>=r)
         cur= query(l,r,n*);
     else if(mid<l)
         cur= query(l,r,n*+);
     else
     {
         cur+= query(l,mid,n*);
         cur+=query(mid+,r,n*+);
     }
     f[n].max=f[n*].max+f[n*+].max;
     return cur;
 }

 int main()
 {
     __int64 n,q,i,l,r,num;
     char a[];
     while(scanf("%I64d%I64d",&n,&q)>)
     {
         for(i=;i<=n;i++)
             scanf("%I64d",&date[i]);
         build(,n,);
         while(q--)
         {
             scanf("%s",a);
             if(a[]=='Q')
             {
                 scanf("%I64d%I64d",&l,&r);
                 printf("%I64d\n",query(l,r,));
             }
             else if(a[]=='C')
             {
                 scanf("%I64d%I64d%I64d",&l,&r,&num);
                 update(l,r,num,);
             }
         }
     }
     return ;
 }

1005

 /*

 求区间[l,r]中，相等数字的最大个数
 试一试能不能A。

 */

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 using namespace std;

 struct node
 {
     int l;
     int r;
     int lmax,rmax,max;
     int lnum,rnum;
     int len;
 }f[*];
 int Date[];

 int hmax(int x,int y)
 {
     return x>y? x: y;
 }

 int hmin(int x,int y)
 {
     return x>y? y:x;
 }

 void make_up(node *father,node *l_child,node *r_child)
 {
     father->lnum=l_child->lnum;
     father->rnum=r_child->rnum;
     if(l_child->rnum!=r_child->lnum)
     {
         father->lmax=l_child->lmax;
         father->rmax=r_child->rmax;
         father->max=hmax(hmax(father->lmax,father->rmax),
                          hmax(l_child->max,r_child->max));
     }
     else
     {
         father->lmax=(l_child->lmax==l_child->len)? l_child->lmax+r_child->lmax:l_child->lmax;
         father->rmax=(r_child->rmax==r_child->len)? r_child->rmax+l_child->rmax:r_child->rmax;
         father->max= hmax(hmax(father->lmax,father->rmax),
                           hmax(l_child->max,
                                hmax(r_child->max,l_child->rmax+r_child->lmax)));
     }
 }

 void build(int l,int r,int n)
 {
     int mid=(l+r)/;
     f[n].l=l;
     f[n].r=r;
     f[n].len=f[n].r-f[n].l+;
     if(l==r)
     {
         f[n].lnum=Date[l];
         f[n].rnum=Date[l];
         f[n].lmax=f[n].rmax=f[n].max=;
         return ;
     }
     build(l,mid,n*);
     build(mid+,r,n*+);
     make_up(&f[n],&f[n*],&f[n*+]);
 }

 int query(int l,int r,int n)
 {
     int mid=(f[n].l+f[n].r)/,cur=,now1=,now2=;

     if(f[n].l==l && f[n].r==r)
     {
         return f[n].max;
     }
     if(mid>=r)
     cur=query(l,r,n*);
     else if(mid<l)
     cur=query(l,r,n*+);
     else
     {
         now1=query(l,mid,n*);
         now2=query(mid+,r,n*+);
         if(f[n*].rnum==f[n*+].lnum)
         {
             cur=hmax(hmax(now1,now2),hmin(mid-l+,f[n*].rmax)+
                      hmin(r-mid,f[n*+].lmax));
         }
         else
         {
             cur=hmax(now1,now2);
         }
     }
     return cur;
 }

 void make_ini(int Q)
 {
     int l,r;
     while(Q--)
     {
         scanf("%d%d",&l,&r);
         printf("%d\n",query(l,r,));
     }
 }

 int main()
 {
     int N,Q,i;
     while(scanf("%d",&N)>)
     {
         if(N==)break;
         scanf("%d",&Q);
         for(i=;i<=N;i++)
         scanf("%d",&Date[i]);
         build(,N,);
         make_ini(Q);
     }
 }

1006

 /*
 求区间[l,r],最大值和最小值的差值。
 */

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #define MAX 1000010
 using namespace std;

 struct node
 {
     int l;
     int r;
     int min;
     int max;
 }f[*];
 int Date[];

 int hmax(int x,int y)
 {
     return x>y? x:y;
 }

 int hmin(int x,int y)
 {
     return x>y? y:x;
 }

 void build(int l,int r,int n)
 {
     int mid=(l+r)/;
     f[n].l=l;
     f[n].r=r;
     if(l==r)
     {
         f[n].max=Date[l];
         f[n].min=Date[l];
         return;
     }
     build(l,mid,n*);
     build(mid+,r,n*+);
     f[n].max=hmax(f[n*].max,f[n*+].max);
     f[n].min=hmin(f[n*].min,f[n*+].min);
 }

 void query(int l,int r,int *a,int *b,int n)
 {
     int mid=(f[n].l+f[n].r)/;
     if(f[n].l==l && f[n].r==r)
     {
         if(f[n].min<*a)
         *a=f[n].min;
         if(f[n].max>*b)
         *b=f[n].max;
         return;
     }
     if(mid>=r)
     query(l,r,a,b,n*);
     else if(mid<l)
     query(l,r,a,b,n*+);
     else
     {
         query(l,mid,a,b,n*);
         query(mid+,r,a,b,n*+);
     }
 }

 int main()
 {
     int N,Q,i;
     int a,b,l,r;
     while(scanf("%d%d",&N,&Q)>)
     {
         for(i=;i<=N;i++)
         scanf("%d",&Date[i]);
         build(,N,);
         while(Q--)
         {
             scanf("%d%d",&l,&r);
             a=MAX;b=-;
             query(l,r,&a,&b,);
             printf("%d\n",b-a);
         }
     }
     return ;
 }