bzoj 1251: 序列终结者 2011-12-20

1251: 序列终结者Time Limit: 20 Sec  Memory Limit: 162 MB
Submit: 650  Solved: 277
[Submit][Status][Discuss]Description 网上有许多题，就是给定一个序列，要你支持几种操作：A、B、C、D。一看另一道题，又是一个序列 要支持几种操作：D、C、B、A。尤其是我们这里的某人，出模拟试题，居然还出了一道这样的，真是没技术含量……这样 我也出一道题，我出这一道的目的是为了让大家以后做这种题目有一个“库”可以依靠，没有什么其他的意思。这道题目 就叫序列终结者吧。 【问题描述】 给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作： 1. 将[L,R]这个区间内的所有数加上V。 2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。 3. 求[L,R]这个区间中的最大值。 最开始所有元素都是0。Input第一行两个整数N，M。M为操作个数。 以下M行，每行最多四个整数，依次为K，L，R，V。K表示是第几种操作，如果不是第1种操作则K后面只有两个数。Output对于每个第3种操作，给出 正确的回答。Sample Input4 4
1 1 3 2
1 2 4 -1
2 1 3
3 2 4

Sample Output2
【数据范围】
N<=50000，M<=100000。

 

___________________________________________

那个，八中，有点坑，程序也有点坑，所以只好把外挂都开启了。

 

___________________________________________

Program Stone;

{$inline on}

{$A+,B-,D-,E-,F-,G+,I-,L-,N+,O-,P+,Q-,R-,S-,T-,V-,X+,Y-}

{$M 65520,0,655360}

var i,j,k,n,m,root,lx,rx,v,qu:longint;

    a,lc,rc,f,o,bi,q:array[0..100000]of longint;

    c:array[0..100000]of boolean; //是否翻转，即是否交换左右孩子

 

 Procedure built(x,y:longint);inline;//先建树，一棵比较平衡的树！

 var i,k:longint;

  begin

    k:=(x+y)div 2; //k为根节点，小于k的为左子树，大于k的为右子树。

    q[k]:=y-x+1;

    if y=x then exit;

    if x<=k-1 then begin

                    built(x,k-1);

                    i:=(x+k-1)div 2;

                    f[i]:=k;lc[k]:=i;

                   end;

    if y>=k+1 then begin

                    built(k+1,y);

                    i:=(y+k+1)div 2;

                    f[i]:=k;rc[k]:=i;

                   end;

  end;

 procedure Tonext(x:longint);inline; //将节点的状态传递给子节点

 var i,j:longint;

  begin

   inc(a[x],o[x]);

   if (lc[x]>1)and(lc[x]<n+2) then begin //判断孩子节点是否在整段序列中

                                      inc(o[lc[x]],o[x]);

                                      inc(bi[lc[x]],o[x]);

                                      c[lc[x]]:=c[lc[x]]xor c[x];

                                   end;

   if (rc[x]>1)and(rc[x]<n+2) then begin

                                      inc(o[rc[x]],o[x]);

                                      inc(bi[rc[x]],o[x]);

                                      c[rc[x]]:=c[rc[x]]xor c[x];

                                   end;

   if c[x] then begin //如果需要翻转，就交换左右孩子。

                 i:=lc[x];lc[x]:=rc[x];rc[x]:=i;

                end;

   o[x]:=0; //修改状态

   c[x]:=false;

  end;

 

 function max(a,b,c:longint):longint;inline;

  begin

   if a>b then max:=a else max:=b;

   if c>max then max:=c;

  end;

 

 procedure change(x:longint);inline; //旋转时改变记录，q为以该节点为根的树有多少个节点。bi为这棵树中的最大值。

  begin

    q[x]:=q[lc[x]]+q[rc[x]]+1;

    bi[x]:=max(bi[lc[x]],bi[rc[x]],a[x])+o[x];

  end;

 

 procedure rightturn(x:longint);inline; //右旋

 var i,j,k:longint;

  begin

    k:=f[x];

    if k=lc[f[k]] then lc[f[k]]:=x else rc[f[k]]:=x;

    f[x]:=f[k];

    lc[k]:=rc[x];f[lc[k]]:=k;

    rc[x]:=k;f[k]:=x;

    change(k);

  end;

 

 procedure leftturn(x:longint); inline; //左旋

 var i,j,k:longint;

  begin

    k:=f[x];

    if k=lc[f[k]] then lc[f[k]]:=x else rc[f[k]]:=x;

    f[x]:=f[k];

    rc[k]:=lc[x];f[rc[k]]:=k;

    lc[x]:=k;f[k]:=x;

    change(k);

  end;

 

 Procedure splay(x,root:longint);inline; //splay

 var i,j,k:longint;

  begin

   if x=root then exit;

   while f[x]<>root do

    begin

      k:=f[x];

      if x=lc[k] then begin

                        if f[k]=root then rightturn(x)

                                     else if k=lc[f[k]] then begin

                                                               rightturn(k);

                                                               rightturn(x);

                                                             end

                                                        else begin

                                                               rightturn(x);

                                                               leftturn(x);

                                                             end;

                      end

                 else begin

                        if f[k]=root then leftturn(x)

                                     else if k=rc[f[k]] then begin

                                                               leftturn(k);

                                                               leftturn(x);

                                                             end

                                                        else begin

                                                               leftturn(x);

                                                               rightturn(x);

                                                             end;

                      end;

    end;

   change(x);

  end;

 

 procedure toroot(x:longint);inline; //更新父亲节点，直到根为止

  begin

   if x=0 then exit;

   bi[x]:=max(bi[lc[x]],bi[rc[x]],a[x])+o[x];

   toroot(f[x]);

  end;

 

 procedure findk(s,x:longint);inline; //寻找

  begin

    tonext(x);

    if q[lc[x]]+1=s then qu:=x;

    if q[lc[x]]+1<s then findk(s-q[lc[x]]-1,rc[x]);

    if q[lc[x]]+1>s then findk(s,lc[x]);

  end;

 

 procedure init; inline;

 var i,j,k:longint;

  begin

    readln(n,m);

    a[1]:=-maxlongint;a[n+2]:=-maxlongint;a[0]:=-maxlongint;bi[0]:=-maxlongint;

//在序列左边插入一个节点，右边也插入一个节点，作为边界。注意0节点的初始化。

    built(1,n+2);root:=(1+n+2)div 2;

    fillchar(c,sizeof(c),false);

    for i:=1 to m do

     begin

      read(k,lx,rx);

      inc(lx);inc(rx);

      findk(lx-1,root);lx:=qu; //寻找询问区间左边界，边界即为询问区间最左边的节点-1

      findk(rx+1,root);rx:=qu;//寻找询问区间右边界，..........最右边的节点+1

      splay(lx,0);root:=lx; //将lx旋转到根节点，rx旋转到根节点的右孩子节点，这样rx的左孩子即为询问区间。

      splay(rx,root);

      case k of //3种操作

       1:begin

           read(v);

           inc(o[lc[rx]],v); //修改状态

           inc(bi[lc[rx]],v);

           toroot(rx); //更新父亲节点的最大值记录

         end;

       2:begin

           c[lc[rx]]:=not(c[lc[rx]]); //翻转，改变翻转记录

         end;

       3:begin

           writeln(bi[lc[rx]]);

         end;

      end;

     end;

  end;

Begin

 assign(input,'input.in');reset(input);

 assign(output,'output1.out');rewrite(Output);

   init;

 close(output);

end.