Pascal 线段树 lazy-tag 模板

　先说下我的代码风格（很丑，勿喷）

    maxn表示最大空间的四倍

    tree数组表示求和的线段树

    delta表示增减的增量标记

    sign表示覆盖的标记

    delta,sign实际上都是lazy标志

    pushdown表示标记下传

    pushup表示标记上传（即求和，区间最值）

    update表示数据更新

       线段树(segment tree)是一种特别有用的数据结构，我们在维护区间各种信息的时候它就是利器。可能读者嫌线段树代码太长，不想写，而树状数组代码简洁易于便携，但是我在这里想说，线段树能做到的很多东西树状数组无法做到，而若掌握了线段树的基本框架，再去写熟练的话，基本上能够做到较短的时间内DEBUG完。

      我们来介绍一下什么是线段树。

      问题1：

　　　　我们拥有一个数列，需要维护三个操作

                       1.单点修改，把a[i]的值改成v

                       2.区间修改，把a[i]~a[j]的值改成v

　　　　　　  3.区间求和，求出a[i]~a[j]的和

      我们不难想到使用数组存储这些东西，对于每个询问我们暴力修改，可这样的话，对于每一段区间，我们需要耗费的时间是r-l+1，当Q特别大、或者区间长度特别大的时候，时间无法忍受。这时候线段树的应用便出来了。

　　何谓线段树？我们把线段存储在树形结构中，利用树形结构维护线段信息的数据结构，就是线段树。

　　我们利用二分建树，建立一颗二叉树。为什么是二叉树呢？我个人理解是，这方便我们二分查找，二分递归，大大减少编程复杂度

　　而，我们每次需要的线段信息，只需要在线段树中检索， 线段树的实质是，一颗存储着线段信息的二叉搜索树。

       我们把一个长的线段（区间），不断的二分划分，即[a,b]划分成[a,(a+b)>>1](leftchild),[(a+b)>>1+1,b](rightchild); 直到a=b为止。

       我们把a=b的这个线段称为叶子节点。在某些题内，叶子节点存储的就是该点在线性结构所对应的信息。

　　由上可知，我们不断划分着[a,b]那么对于每一个[a,(a+b)>>1],[(a+b)>>1+1,b]它的左儿子和右儿子也是满足"线段树"性质

　　

         上图是我们划分[1,10]区间的过程。现在我们回到问题1

         我们发现如果是一个一个叶子结点访问，那么每次访问的时间甚至比O(n)的数组模拟要长。

　　  那么我们再看一个简单版的问题1

            问题2：

　　　　　　给定一个序列

　　　　　　1.修改其中一个点

　　　　　　　　Sub:单点减小某值

　　　　　　　　Add:单点增加某值

　　　　　　2.询问区间和

　　　　　　　　Query:询问区间和

　　　　

　　　现在我们可以通过每次查找到叶子节点，暴力修改。

    　   然后再递归求解区间和。

　　　具体代码如下：　　　

　　

const maxn=300001;

var tree:packed array [0..maxn] of longint;

procedure pushup(now:longint);
begin
  tree[now]:=tree[now<<1]+tree[now<<1+1]; //区间求和
end;

procedure build(l,r,now:longint);
var mid:longint;
begin
  if l=r then
     begin
       read(tree[now]); //到叶子节点时输入信息并退出
       exit;
     end;
  mid:=(l+r) shr 1;
  build(l,mid,now<<1);
  build(mid+1,r,now<<1+1);
  pushup(now);
end;

procedure update(p,add,l,r,now:longint); //更新数据
var mid:longint;
begin
  if l=r then
    begin
      inc(tree[now],add);
      exit;
    end;
  mid:=(l+r) shr 1;
  if p<=mid then update(p,add,l,mid,now<<1) //递归求解
  else update(p,add,mid+1,r,now<<1+1);
  pushup(now);
end;

function query(left,right,l,r,now:longint):longint; //询问和
var mid,ans:longint;
begin
  if (left<=l) and (r<=right) then exit(tree[now]);
  mid:=(l+r) shr 1;
  ans:=0;
  if left<=mid then inc(ans,query(left,right,l,mid,now<<1));
  if right>mid then inc(ans,query(left,right,mid+1,r,now<<1+1));
  exit(ans);
end;

procedure ques(n:longint);
var ch:char; a,b:longint;  temp:string;
begin
  while true do
    begin
      temp:='';
      ch:='1';
        while ch<>' ' do
          begin
            read(ch);
            temp:=temp+ch;
          end;
      delete(temp,length(temp),1);
      if temp='End' then exit;
      readln(a,b);
      case temp of
         'Add':update(a,b,1,n,1);
         'Query':writeln(query(a,b,1,n,1));
         'Sub':update(a,-b,1,n,1);
      end;
    end;
end;

procedure main;
var i,t,n:longint;
begin
  readln(t);
  for i:=1 to t do
     begin
        readln(n);
        build(1,n,1);
        readln;
        ques(n);
     end;
end;

begin
  main;
end.

　　　但是，我们如果对于区间有修改的话，这样就太慢了，O(Qnlogn)，甚至比朴素算法都慢

　　　那么，线段树的精华出现了，lazy-tag技术

　　　　Lazy-Tag 顾名思义，懒惰标记。我们每当要对一个区间进行修改时，

　　　　我们只需要访问到这个区间所包含的最大区间，然后对这个区间记一个lazy-tag

　　　　我们如此做的动机是：没有必要更新到叶子节点，而是在一个合适的范围内，上一个tag

　　　　而我们在询问的时候，每询问一个区间，查询其tag,若存在tag,则把tag下传到该区间的左儿子与右儿子，并把该区间的tag信息上传，且清空当前Tag。

　　　　这样我们能大大的增加效率。

　　　　pushdown应该如何写呢？

　　　　　　大概的结构是这样

　　　　　　　　if lazy[now]<>0 then 

　　　　　　　　　　begin

　　　　　　　　　　　　do something;

　　　　　　　　　　end;

　　　　我们给出区间修改的问题3

　　　　　　维护一个数列，支持如下操作：

　　　　　　　　1.把区间[l,r]全部增加v

　　　　　　　　2.修改k点值为r

　　　　　　　　3.询问区间[l,r]的和

　　　　代码如下：(未写main函数)

//区间增减 区间求和
const maxn=600001;

var lazy,tree:array [0..maxn] of longint;

procedure pushup(now:longint);
var left,right:longint;
begin
    left:=now<<1; right:=left+1;
    tree[now]:=tree[left]+tree[right];
end;

procedure pushdown(now,l,r:longint);
var len,left,right,delta:longint;
begin
    left:=now<<1;  right:=left+1;  delta:=lazy[now]; len:=r-l+1;
    if lazy[now]<>0 then
        begin
            inc(tree[now],delta*len);
            inc(lazy[left],delta);
            inc(lazy[right],delta);
            lazy[now]:=0;
        end;
end;

procedure build(l,r,now:longint);
var mid,left,right:longint;
begin
    mid:=(l+r)>>1; left:=now<<1; right:=left+1;
    lazy[now]:=0;
    if l=r then
        begin
            read(tree[now]);
            exit;
        end;
    build(l,mid,left);
    build(mid+1,r,right);
    pushup(now);
end;

procedure update(now,l,r:longint);
var mid,left,right:longint;
begin
    mid:=(l+r)>>1; left:=now<<1; right:=left+1;
    pushdown(left,l,mid);
    pushdown(right,mid+1,r);
    pushup(now);
end;

procedure insert(left,right,c,l,r,now:longint);
var mid,leftch,rightch:longint;
begin
    mid:=(l+r)>>1; leftch:=now<<1; rightch:=leftch+1;
    pushdown(now,l,r);
    if (left<=l) and (r<=right) then
        begin
            inc(lazy[now],c);
            exit;
        end;
    if left<=mid then insert(left,right,c,l,mid,leftch);
    if mid<right then insert(left,right,c,mid+1,r,rightch);
    update(now,l,r);
end;

function querysum(left,right,l,r,now:longint):longint;
var leftch,rightch,mid,ans:longint;
begin
    pushdown(now,l,r);
    if (left<=l) and (r<=right) then exit(tree[now]);
    mid:=(l+r) shr 1;
    leftch:=now<<1;
    rightch:=leftch+1;
    ans:=0;
    if left<=mid then inc(ans,querysum(left,right,l,mid,leftch));
    if mid<right then inc(ans,querysum(left,right,mid+1,r,rightch));
    exit(ans);
end;

　　　我们再升级一下问题

　　　　　　维护一个数列，支持如下操作：

　　　　　　　　0.询问区间[l,r]的和

　　　　　　　　1.修改单点l值为r

　　　　　　　　2.把区间[l,r]全部置为v

　　　　　　　　3.把区间[l,r]全部增加v

　　看上去很麻烦，我们不知道区间覆盖和区间增减的顺序的话，可能标记会出错。

　　但是我们只需要再维护一个sign域即可，而我们也不必在意区间覆盖和区间增减的顺序

　　因为：当区间覆盖与区间增量tag同时存在时，我们优先区间覆盖标记，在清空区间覆盖标记时，把区间增量标记清空

　　　　为什么呢？很显然，我们先进行区间增减，再进行区间覆盖，那么显然区间增减无意义。

　　　　但是问题来了，若我们先进行的区间覆盖，再进行区间增减，那么区间增减也会被覆盖掉，这样显然会WA.

　　　　怎么解决呢？我们在下tag时，都查询一次当前结点的tag,若当前结点存在tag,那么我们清空tag,使该层tag传递到下一层，

　　　　即当前更新不影响历史记录。

　　　　这样，我们能保持标记总是sign在上，不影响delta的传递，即覆盖标记永远优先于增量标记，且传递深度总是较增量标记传递深度大一层。

　　　　代码如下：（不支持全部覆盖为0，若要全部覆盖为0则需重新初始化sign的值）

{$inline on}
const maxn=800001;

var tree,sign,delta:array [0..maxn] of int64;

procedure pushup(now:longint); inline;
var left,right:longint;
begin
  left:=now<<1; right:=left+1;
  tree[now]:=tree[left]+tree[right];
end;

procedure pushdown(now,l,r:longint); inline;
var left,right,len:longint;
begin
  left:=now<<1; right:=left+1;
  len:=r-l+1;
  if sign[now]<>0 then
    begin
      sign[left]:=sign[now];
      sign[right]:=sign[now];
      delta[left]:=0;
      delta[right]:=0;
      tree[now]:=len*sign[now];
      sign[now]:=0;
    end;
  if delta[now]<>0 then
    begin
      inc(delta[left],delta[now]);
      inc(delta[right],delta[now]);
      inc(tree[now],delta[now]*len);
      delta[now]:=0;
    end;
end;

procedure build(now,l,r:longint); inline;
var mid,left,right:longint;
begin
  mid:=(l+r)>>1; left:=now<<1; right:=left+1;
  delta[now]:=0; sign[now]:=0;
  if l=r then
     begin
       read(tree[now]);
       exit;
     end;
  build(left,l,mid);
  build(right,mid+1,r);
  pushup(now);
end;

procedure update(now,l,r:longint); inline;
var mid,left,right:longint;
begin
  mid:=(l+r)>>1; left:=now<<1; right:=left+1;
  pushdown(left,l,mid);
  pushdown(right,mid+1,r);
  pushup(now);
end;

procedure changepoint(pos,v,l,r,now:longint); inline;
var mid,left,right:longint;
begin
        mid:=(l+r)>>1; left:=now<<1; right:=left+1;
        pushdown(now,l,r);
        if l=r then
          begin
              tree[now]:=v;
              exit;
          end;
        if pos<=mid then changepoint(pos,v,l,mid,left)
        else changepoint(pos,v,mid+1,r,right);
        update(now,l,r);
end;

procedure change(left,right,v,l,r,now:longint); inline;
var mid,leftch,rightch:longint;
begin
  pushdown(now,l,r);
  mid:=(l+r)>>1; leftch:=now<<1; rightch:=leftch+1;
  if (left<=l) and (r<=right) then
    begin
      sign[now]:=v;
      delta[now]:=0;
      exit;
    end;
  if left<=mid then change(left,right,v,l,mid,leftch);
  if mid<right then change(left,right,v,mid+1,r,rightch);
  update(now,l,r);
end;

procedure insert(left,right,v,l,r,now:longint); inline;
var mid,leftch,rightch:longint;
begin
        mid:=(l+r)>>1; leftch:=now<<1; rightch:=leftch+1;
        pushdown(now,l,r);
          if (left<=l) and (r<=right) then
              begin
                    inc(delta[now],v);
                    exit;
              end;
        if left<=mid then insert(left,right,v,l,mid,leftch);
        if mid<right then insert(left,right,v,mid+1,r,rightch);
        update(now,l,r);
end;

function querysum(left,right,l,r,now:longint):int64; inline;
var leftch,rightch,mid:longint; ans:int64;
begin
        pushdown(now,l,r);
        if (left<=l) and (r<=right) then exit(tree[now]);
        mid:=(l+r)>>1;
        leftch:=now<<1;
        rightch:=leftch+1;
        ans:=0;
        if left<=mid then inc(ans,querysum(left,right,l,mid,leftch));
        if mid<right then inc(ans,querysum(left,right,mid+1,r,rightch));
        update(now,l,r);
        exit(ans);
end;

procedure swap(var l,r:longint); inline;
begin
  l:=l xor r;
  r:=l xor r;
  l:=l xor r;
end;

procedure main;
var i,n,m,que,l,r,a:longint;
begin
  read(n,m);
  build(1,1,n);
  for i:=1 to m do
     begin
       read(que,l,r);
       if l>r then swap(l,r);
       case que of
         0:writeln(querysum(l,r,1,n,1));
         1:changepoint(l,r,1,n,1);
         2:
           begin
             read(a);
             change(l,r,a,1,n,1);
           end;
         3:
           begin
             read(a);
             insert(l,r,a,1,n,1);
           end;
       end;
     end;
end;

begin
    main;
end.

　　　　另外：

　　　　线段树一定要用数组，指针常数巨大。

　　　　下面是指针与数组版本的耗时比较

　　　　　

 　　　　　　　　此为指针版，耗时耗空间都相当大（不排除本人蒟蒻原因写丑了）

　　　　　

　　　　　　　　此为数组版，常数还是比较小的。