POJ 3468

POJ 3468

题目之前的吐槽：最近记忆力真的差很多了，刚刚做完来写解题报告，题目编号已然不记得….

题目大意:给出n个数，我们有两个操作，q,x,y:询问区间[x,y]的和，c,x,y,z:区间[x,y]里的每一个数+z。

解:树状数组，线段树，以及discuss里说splay可做。做这题目前用的线段树。线段树的常数真心恶心，递归就算了，而且clear操作写成函数那个常数大得我不敢看了，可是不写成函数又会把自己恶心到。

主要是靠一个lazy操作，有一个tag域，如果这个区间在增加的区间内，tag累加，tag表示这个区间要加的数，然后每进入一条线段，clear，更新sum，tag直0，并且把tag传递给子节点（线段）（因为自线段的sum域没有更新）。本体wa点也是很多，首先每看清题目，数据范围超过maxlongint，然后也没想到增加的数可能为负，然后我写的条件是tag>0 then…,然后在累加数的时候，从子节点返回时，需要clear一次，然后 sum := _sum(sons.sum)，累加的时候退出不用clear了，进入的时候clear就行（毕竟不像_addnum，他是改变了值的了），然后自己的函数命名的习惯还是改不太过来…

//poj 3468
const
        inf='1.txt';
        maxn=111111;
type
        data=record
          mid, l, r, st, ed: longint;
          sum, tag: int64;
        end;
var
        tree: array[0..maxn*4]of data;
        a: array[0..maxn]of int64;
        n, q: longint;
        ans: int64;
procedure _clear(k: longint);
begin
  with tree[k] do if tag <> 0 then begin
    sum := sum + tag*(ed-st+1);
    if (st<>ed) then begin
      tree[l].tag := tree[l].tag + tag;
      tree[r].tag := tree[r].tag + tag;
    end;
    tag := 0;
  end;
end;

procedure _build(s, e, k: longint);
begin
  with tree[k] do begin
    st := s; ed := e; mid := (st+ed)>>1;
    if s=e then begin
      sum := a[s]; exit;
    end;
    l := k << 1; _build(s, mid, l);
    r := l + 1; _build(mid+1, e, r);
    sum := tree[l].sum + tree[r].sum;
  end;
end;

procedure _init;
var
        i: longint;
begin
  fillchar(tree, sizeof(tree), 0);
  readln(n, q);
  for i := 1 to n do read(a[i]);
  readln;
  _build(1, n, 1);
end;

procedure _count(s, e, k: longint);
begin
  with tree[k] do begin
    _clear(k);
    if (s<=st)and(ed<=e) then begin
      ans := ans + sum; exit;
    end;
    if s<=mid then _count(s, e, l);
    if e>mid then _count(s, e, r);
    if (l>0) then _clear(l);
    if (r>0) then _clear(r);
  end;
end;

procedure _addnum(s, e, k: longint; num: int64);
begin
  with tree[k] do begin
    _clear(k);
    if (s<=st)and(ed<=e) then begin
      tag := tag + num; exit;
    end;
    if s<=mid then _addnum(s, e, l, num);
    if e>mid then _addnum(s, e, r, num);
    if (l>0) then _clear(l);
    if (r>0) then _clear(r);
    sum := tree[l].sum + tree[r].sum;
  end;
end;

procedure _main;
var
        i, x, y, z: longint;
        c: char;
begin
  for i := 1 to q do begin
    read(c);
    if c='Q' then begin
      readln(x, y);
      ans := 0;
      _count(x, y, 1);
      writeln(ans);
    end
    else begin
      readln(x, y, z);
      _addnum(x, y, 1, z);
    end;
  end;
end;

begin
  assign(input,inf); reset(input);
  _init;
  _main;
end.

新增加一个splay版本

//orzorzorz
const
        maxn=100011;
        inf='1.txt';
        null=maxn;
type
        node=record
          tag, key, sum: int64; {sb= =}
          father, size: longint;
          son: array[0..1]of longint;
        end;
var
        tree: array[0..maxn]of node;
        root, n, q, tot: longint;
procedure clear(x: longint);
begin
  if (tree[x].tag<>0)and(x<>null) then
  with tree[x] do begin
    key := key + tag;
    inc(tree[son[0]].tag, tag);
    inc(tree[son[1]].tag, tag);
    tree[son[0]].sum := tree[son[0]].sum + tag * tree[son[0]].size;
    tree[son[1]].sum := tree[son[1]].sum + tag * tree[son[1]].size;
    tag := 0;
  end;
end;

procedure updata(x: longint);
begin
  with tree[x] do begin
    sum := tree[son[0]].sum + key + tree[son[1]].sum;
    size := tree[son[0]].size + 1 + tree[son[1]].size;
  end;
end;

function find(x: longint): longint;
var
        i : longint;
begin
  i := root;
  while true do with tree[i] do begin
    clear(x);
    if tree[son[0]].size + 1 = x then exit(i);
    if tree[son[0]].size + 1 > x then i := son[0]
    else begin
      x := x - tree[son[0]].size - 1;
      i := son[1];
    end;
  end;
end;

procedure rotate(x: longint);
var
        isr, y, z: longint;
begin
  with tree[x] do begin
    y := father; if y=root then root := x;
    if tree[y].son[1] = x then isr := 1 else isr := 0;
    {clear son}    //clear(tree[y].son[0]); clear(tree[y].son[1]); clear(son[0]); clear(son[1]);
    clear(y); clear(x);
    tree[y].son[isr] := son[isr xor 1];
    if son[isr xor 1]<>null then tree[son[isr xor 1]].father := y;
    z := tree[y].father; father := z;
    if z<>null then begin
      if y=tree[z].son[0] then tree[z].son[0] := x
        else tree[z].son[1] := x;
    end;
    tree[y].father := x;
    tree[x].son[isr xor 1] := y;
  end;
  updata(y);
end;

procedure splay(x, goal: longint);
var
        u, v, y, z: longint;
begin
  while tree[x].father<>goal do with tree[x] do begin
    y := father; if tree[y].father=goal then begin
      rotate(x); continue;
    end;
    z := tree[y].father;
    if tree[y].son[0]=x then u := 0 else u := 1;
    if tree[z].son[0]=y then v := 0 else v := 1;
    if (u xor v=0) then begin
      rotate(y); rotate(x);
    end
    else begin
      rotate(x); rotate(x);
    end;
  end;
  updata(x);
end;

procedure change(x, y, number: longint);
var
        l, r : longint;
begin
  l := find(x-1);
  splay(l, null);
  r := find(y+1);
  splay(r, root);
  r := tree[r].son[0];
  with tree[r] do begin
    inc(tag, number);
    clear(r);
  end;
  updata(r);
  updata(tree[root].son[1]);
  updata(root);
end;

function query(x, y: longint): int64;
var
        l, r: longint;
begin
  l := find(x-1);
  splay(l, null);
  r := find(y+1);
  splay(r, root);
  r := tree[r].son[0];
  query := tree[r].sum;
end;


procedure main;
var
        i, a, b, c: longint;
        ask: char;
begin
  for i := 1 to q do begin
    read(ask);
    if ask='Q' then begin
      readln(a, b); inc(a); inc(b);
      writeln(query(a, b));
    end
    else begin
      readln(a, b, c); inc(a); inc(b);
      change(a, b, c);
    end;
  end;
end;

procedure init;
var
        i: longint;
begin
  readln(n, q);
  fillchar(tree[null], sizeof(tree[null]), 0);
  fillchar(tree[0], sizeof(tree[0]), 0);
  with tree[0] do begin
    size := 1; son[0] := null; son[1] := null; father := 1;
  end;
  fillchar(tree[n+1], sizeof(tree[n+1]), 0);
  with tree[(n+1)] do begin
    size := 1; son[0] := null; son[1] := null; father := n;
  end;
  for i := 1 to n do with tree[i] do begin
    son[0] := i-1; son[1] := null; father := i+1; tag := 0;
    if i=n then son[1] := n+1;
    read(key);
    updata(i);
  end; readln;
  root := n;
  tree[root].father := null;
end;

begin
  assign(input,inf); reset(input);   assign(output,'2.txt'); rewrite(output);
  init;
  main;
end.