【以前的空间】link cut tree

这篇文章讲的很好很详细，但是写了几天后发现似乎是挺残的版本。

2049: [Sdoi2008]Cave 洞穴勘测

3282: Tree

2002: [Hnoi2010]Bounce 弹飞绵羊

1036: [ZJOI2008]树的统计Count

都是基础操作吧

后来发现makeroot这个操作可以用个各个地方，改进了一下愉快的切

2631: tree

结果就是tle

结果就是调了两天用了三种lct中splay写法还是tle

结果就是不明白某大神友情提供的代码到底比我的程序优在哪……！

至今还是tle，但是换了几种写法

写法一（自己的程序+各种奇怪的优化+网上大众版splay)

{$M 1000000000,0,maxlongint}

//{$ inline in}

type

  arr=record

    toward,next:longint;

  end;

const

  maxn=;

  mm=;

var

  a:array[..]of longint;

  st:string;

  fa,q,first,size:array[..maxn]of longint;

  sum,mark1,mark2,value:array[..maxn]of qword;

  c:array[..maxn,..]of longint;

  rev:array[..maxn]of boolean;

  edge:array[..maxn*]of arr;

  n,m,tot,u,v,j,k,i:longint;

procedure prepare;//inline;

  var

    i,j,k:longint;

  begin

    st:=st+' ';

    i:=;

    j:=;

    while i<length(st) do

      begin

      inc(j); k:=i;

      while st[i]<>' ' do inc(i);

      val(copy(st,k,i-k),a[j]);

      inc(i);

      end;

  end;

procedure swap(var x,y:longint);//inline;

var

  i:longint;

begin

  i:=x;

  x:=y;

  y:=i

end;

function isroot(x:longint):boolean;

begin

  if (c[fa[x],]=x) or (c[fa[x],]=x) then exit(True);

  exit(false);

end;       

procedure update(x:longint);//inline;

begin

  sum[x]:=(sum[c[x,]]+sum[c[x,]]+value[x]) mod mm;

  size[x]:=size[c[x,]]+size[c[x,]]+;

end;

procedure maintain(x,y,z:longint);//inline;

begin

  if x= then exit;

  value[x]:=(value[x]*y+z) mod mm;

  sum[x]:=(sum[x]*y+z*size[x])mod mm;

  mark1[x]:=mark1[x]*y mod mm;

  mark2[x]:=(mark2[x]*y+z) mod mm

end;

procedure pushdown(x:longint);//inline;

var

  l,r:longint;

begin

  if x= then exit;

  if rev[x] then begin

    swap(c[x,],c[x,]);

    rev[c[x,]]:=not rev[c[x,]];

    rev[c[x,]]:=not rev[c[x,]];

    rev[x]:=false;

  end;

  if (mark1[x]<>) or (mark2[x]<>) then begin

    maintain(c[x,],mark1[x],mark2[x]);

    maintain(c[x,],mark1[x],mark2[x]);

    mark1[x]:=;

    mark2[x]:=;

  end

end;

procedure rotate(x:longint);//inline;

var

  y,z,l,r:longint;

begin

  y:=fa[x];

  z:=fa[y];

  if c[y,]=x then l:= else l:=;

  r:=l xor ;

  if isroot(y) then

    if c[z,]=y then c[z,]:=x else c[z,]:=x;

  fa[x]:=z;

  fa[y]:=x;

  fa[c[x,r]]:=y;

  c[y,l]:=c[x,r];

  c[x,r]:=y;

  update(y);

  //update(x)

end;

procedure splay(x:longint);//inline;

var

  top,i,y,z:longint;

begin

  top:=;

  q[]:=x;

  i:=x;

  while isroot(i) do begin

    inc(top);

    q[top]:=fa[i];

    i:=fa[i];

  end;

  for i:=top downto  do pushdown(q[i]);

  while isroot(x) do begin

    y:=fa[x];

    z:=fa[y];

    if isroot(y) then

      if (c[y,]=x) xor (c[z,]=y) then rotate(x)

        else rotate(y);

    rotate(x);

  end

end;

function access(x:longint):longint;//inline;

var

  y:longint;

begin

  y:=;

  repeat

    splay(x);

    c[x,]:=y;

    fa[y]:=x;

    update(x);

    y:=x;

    x:=fa[x];

  until x=;

  exit(y);

end;

procedure makeroot(x:longint);//inline;

var

  y:longint;

begin

  y:=access(x);

  //splay(x);

  rev[y]:=not rev[y];

  fa[y]:=;

end;

procedure lct(x1,y1,x2,y2:longint);//inline;

var

  y:longint;

begin

  makeroot(x1);

  access(x1);

  y:=y1;

  while isroot(y) do y:=fa[y];

  fa[y]:=;

  y:=x2;

  while fa[y]<> do y:=fa[y];

  if y<>x1 then swap(x2,y2);

  y:=access(y2);

  rev[y]:=not rev[y];

  fa[y]:=x2

end;

procedure addedge(j,k:longint);//inline;

begin

  inc(tot);

  edge[tot].toward:=k;

  edge[tot].next:=first[j];

  first[j]:=tot

end;

procedure dfs(x:longint);//inline;

var

  i,too:longint;

begin

  i:=first[x];

  value[x]:=;

  sum[x]:=;

  mark1[x]:=;

  size[x]:=;

  while i<> do begin

    too:=edge[i].toward;

    if fa[x]<>too then begin

      fa[too]:=x;

      dfs(too);

    end;

    i:=edge[i].next;

  end

end;

begin

  readln(n,m);

  for i:= to n- do begin

    readln(j,k);

    addedge(j,k);

    addedge(k,j);

  end;

  dfs(n>>);

  while m> do begin

    dec(m);

    readln(st);

    prepare;

    case st[] of

      '*':begin

            //j:=j mod mm;

            makeroot(a[]);

            //maintain1(access(a[]),a[]);

            maintain(access(a[]),a[],);

      end;

      '+':begin

            //j:=j mod mm;

            makeroot(a[]);

            //maintain2(access(a[]),a[]);

            maintain(access(a[]),,a[]);

      end;

      '-':lct(a[],a[],a[],a[]);

      '/':begin

            makeroot(a[]);

            writeln(sum[access(a[])]);

      end;

    end;

  end;

end.

写法二（yangzhe大神写法）

type

  arr=record

    toward,next:longint;

  end;

const

  maxn=;

  mm=;

var

  a:array[..]of longint;

  st:string;

  fa,q,first,size,child:array[..maxn]of longint;

  sum,mark1,mark2,value:array[..maxn]of qword;

  c:array[..maxn,..]of longint;

  rev:array[..maxn]of boolean;

  edge:array[..maxn*]of arr;

  n,m,tot,u,v,j,k,i:longint;

procedure prepare;

  var

    i,j,k:longint;

  begin

    st:=st+' ';

    i:=;

    j:=;

    while i<length(st) do

      begin

      inc(j); k:=i;

      while st[i]<>' ' do inc(i);

      val(copy(st,k,i-k),a[j]);

      inc(i);

      end;

  end;

procedure swap(var x,y:longint);

var

  i:longint;

begin

  i:=x;

  x:=y;

  y:=i;

end;

procedure update(x:longint);

begin

  sum[x]:=(sum[c[x,]]+sum[c[x,]]+value[x]) mod mm;

  size[x]:=size[c[x,]]+size[c[x,]]+;

end;

procedure maintain(x,y,z:longint);

begin

  if x= then exit;

  value[x]:=(value[x]*y+z) mod mm;

  sum[x]:=(sum[x]*y+z*size[x])mod mm;

  mark1[x]:=mark1[x]*y mod mm;

  mark2[x]:=(mark2[x]*y+z) mod mm

end;

procedure pushdown(x:longint);

var

  l,r:longint;

begin

  if x= then exit;

  if rev[x] then begin

    child[c[x,]]:=-child[c[x,]];

    child[c[x,]]:=-child[c[x,]];

    swap(c[x,],c[x,]);

    rev[c[x,]]:=not rev[c[x,]];

    rev[c[x,]]:=not rev[c[x,]];

    rev[x]:=false;

  end;

  if (mark1[x]<>) or (mark2[x]<>) then begin

    maintain(c[x,],mark1[x],mark2[x]);

    maintain(c[x,],mark1[x],mark2[x]);

    mark1[x]:=;

    mark2[x]:=;

  end

end;

procedure rotate(node,x:longint);

var

  p,y,tmp:longint;

begin

  p:=fa[node];

  y:=child[p];

  tmp:=fa[p];

  fa[node]:=tmp;

  child[node]:=y;

  if y<> then c[tmp,y]:=node;

  y:=-x;

  tmp:=c[node,y];

  c[p,x]:=tmp;

  fa[tmp]:=p;

  child[tmp]:=x;

  fa[p]:=node;

  child[p]:=y;

  c[node,y]:=p;

  update(p);

end;

procedure splay(node:longint);

var

  a,p,b,top:longint;

begin

  top:=;

  q[]:=node;

  i:=node;

  while child[i]<> do begin

    inc(top);

    q[top]:=fa[i];

    i:=fa[i];

  end;

  for i:=top downto  do pushdown(q[i]);

  repeat

    a:=child[node];

    if a= then break;

    p:=fa[node];

    b:=child[p];

    if a=b then rotate(p,a)

           else rotate(node,a);

    if b= then break;

    rotate(node,b);

  until false;

  update(node);

end;

function access(x:longint):longint;

var

  y:longint;

begin

  y:=;

  repeat

    splay(x);

    child[c[x,]]:=;

    c[x,]:=y;

    fa[y]:=x;

    child[y]:=;

    update(x);

    y:=x;

    x:=fa[x];

  until x=;

  exit(y);

end;

procedure makeroot(x:longint);

var

  y:longint;

begin

  y:=access(x);

  rev[y]:=not rev[y];

  fa[y]:=;

  child[y]:=;

end;

function getrt(x:longint):longint;

begin

  while child[x]<> do x:=fa[x];

  exit(x);

end;

function getup(x:longint):longint;

begin

  while fa[x]<> do x:=fa[x];

  exit(x);

end;

procedure lct(x1,y1,x2,y2:longint);

var

  y:longint;

begin

  makeroot(y1);

  access(y1);

  y:=getrt(x1);

  fa[y]:=;

  child[y]:=;

  if getup(x2)<>x1 then swap(x2,y2);

  y:=access(y2);

  rev[y]:=not rev[y];

  fa[y]:=x2;

  child[y]:=;

end;

procedure addedge(j,k:longint);

begin

  inc(tot);

  edge[tot].toward:=k;

  edge[tot].next:=first[j];

  first[j]:=tot

end;

procedure dfs(x:longint);

var

  i,too:longint;

begin

  i:=first[x];

  value[x]:=;

  sum[x]:=;

  mark1[x]:=;

  size[x]:=;

  while i<> do begin

    too:=edge[i].toward;

    if fa[x]<>too then begin

      fa[too]:=x;

      child[too]:=;

      dfs(too);

    end;

    i:=edge[i].next;

  end

end;

begin

  readln(n,m);

  for i:= to n- do begin

  readln(j,k);

  addedge(j,k);

  addedge(k,j);

  end;

  child[n>>]:=;

  dfs(n>>);

  while m> do begin

    dec(m);

    readln(st);

    prepare;

    case st[] of

      '*':begin

            //j:=j mod mm;

            makeroot(a[]);

            //maintain1(access(a[]),a[]);

            maintain(access(a[]),a[],);

      end;

      '+':begin

            //j:=j mod mm;

            makeroot(a[]);

            //maintain2(access(a[]),a[]);

            maintain(access(a[]),,a[]);

      end;

      '-':lct(a[],a[],a[],a[]);

      '/':begin

            makeroot(a[]);

            writeln(sum[access(a[])]);

      end;

    end;

  end;

end.