bzoj3091

最近屯题都忘了把解题报告写上了
这道题是一道比较烦的LCT，我们先考虑每个点上到底要维护什么
我们设路径上有n个点，从起点到终点编号为1~n
显然期望=S/[(n+1)n div 2]
S=∑a[i]*i*(n-i+1) //这里理解一下
=∑a[i]*[i*(n+1)-i*i]=(n+1)*∑a[i]*i-∑a[i]*i*i;
考虑到找出x,y之间的路径就是把x,y路径上的点弄到一棵Auxiliary tree上
对于每个点x，我们显然要维护以x为根的子树对应的序列的∑a[i]*i和∑a[i]*i*i,记为s2[x],s3[x]
对于上面表达式的i，就是每个点在树（子树）上的名次
下面的关键就是我们如何用其左右孩子的信息来维护父亲x，设l为x左孩子，r为x右孩子
这里主要的影响在于对右孩子，原来右孩子的维护的是编号为1~size[r]的序列的s2[],s3[]
现在我们加上去的是编号为size[l]+2~size[x]序列的s2[],s3[]
我们考虑会会增加多少,对于s2 ∑a[i]*(i+p)-∑a[i]*i=p*∑a[i]
对于s3 有∑a[i]*(i+p)^2-∑a[i]*i^2=∑a[i]*(2*p*i+p*p)=p*p*∑a[i]+2*p*∑a[i]*i
这里维护就很显然了，我们还要再维护一个s1[]记录∑a[i]
而修改相对比较简单，其实就是对s1,s2,s3分别加上d*n,d*∑i,d*∑i*i 这个直接上公式
但这里还并没有完，我们用的LCT有个操作叫换根，而换根要翻转左右子树
而这样左右子树的编号就反过来了，从而节点上记录s2[],s3[]就不正确了
我的解决方法是再维护ss2[],ss3[]，记录倒序编号时∑a[i]*i和∑a[i]*i*i
然后要左右子树交换时，就交换ss2[]，s2[]和ss3[]和s3[]
具体实现细节见程序

type node=record
       po,next:longint;
     end;

var son:array[0..50010,1..2] of longint;
    p,a,q,fa,add,size:array[0..50010] of longint;
    s1,ss2,ss3,s2,s3:array[0..50010] of int64;
    rev:array[0..50010] of boolean;
    e:array[0..100010] of node;
    cc,t,len,ch,n,m,x,y,z,i:longint;

function gcd(a,b:int64):int64;
  begin
    if b=0 then exit(a)
    else exit(gcd(b,a mod b));
  end;

procedure build(x,y:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].next:=p[x];
    p[x]:=len;
  end;

procedure dfs(x:longint);
  var i,y:longint;
  begin
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if fa[x]<>y then
      begin
        fa[y]:=x;
        dfs(y);
      end;
      i:=e[i].next;
    end;
  end;

procedure swap(var a,b:int64);
  var c:int64;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

procedure reverse(x:longint);  //如上述
  var p:longint;
  begin
    swap(ss2[x],s2[x]);
    swap(ss3[x],s3[x]);
    rev[x]:=not rev[x];
  end;

function root(x:longint):boolean;
  begin
    exit((son[fa[x],1]<>x) and (son[fa[x],2]<>x));
  end;

procedure calc(x,z:longint);
  var p,c,d:int64;
  begin
    inc(add[x],z);
    inc(a[x],z);
    p:=size[x];
    c:=int64(z)*(p+1)*p div 2;
    d:=int64(z)*(p+1)*p*(2*p+1) div 6;  //平方和公式
    s1[x]:=s1[x]+int64(z)*p;
    s2[x]:=s2[x]+c;
    s3[x]:=s3[x]+d;
    ss2[x]:=ss2[x]+c;
    ss3[x]:=ss3[x]+d;
  end;

procedure update(x:longint);
  var l,r:longint;
      p,q:int64;
  begin
    l:=son[x,1];
    r:=son[x,2];
    size[x]:=size[l]+size[r]+1;
    p:=size[l]+1;  //正序编号
    q:=size[r]+1;  //反序标号
    s1[x]:=s1[l]+s1[r]+a[x];
    s2[x]:=s2[l]+int64(a[x])*p+s2[r]+s1[r]*p;
    s3[x]:=s3[l]+int64(a[x])*p*p+s3[r]+p*p*s1[r]+2*p*s2[r];
    ss2[x]:=ss2[r]+int64(a[x])*q+ss2[l]+s1[l]*q;
    ss3[x]:=ss3[r]+int64(a[x])*q*q+ss3[l]+q*q*s1[l]+2*q*ss2[l];
  end;

procedure push(x:longint);
  var r:longint;
  begin
    if rev[x] then
    begin
      r:=son[x,1]; son[x,1]:=son[x,2]; son[x,2]:=r;
      if son[x,1]<>0 then reverse(son[x,1]);
      if son[x,2]<>0 then reverse(son[x,2]);
      rev[x]:=false;
    end;
    if add[x]<>0 then
    begin
      if son[x,1]<>0 then calc(son[x,1],add[x]);
      if son[x,2]<>0 then calc(son[x,2],add[x]);
      add[x]:=0;
    end;
  end;

procedure rotate(x,w:longint);
  var y:longint;
  begin
    y:=fa[x];
    if not root(y) then
    begin
      if son[fa[y],1]=y then son[fa[y],1]:=x
      else son[fa[y],2]:=x;
    end;
    fa[x]:=fa[y];
    son[y,3-w]:=son[x,w];
    fa[son[x,w]]:=y;
    son[x,w]:=y;
    fa[y]:=x;
    update(y);
  end;

procedure splay(x:longint);
  var i,y:longint;
      fl:boolean;
  begin
    t:=0;
    i:=x;
    while not root(i) do
    begin
      inc(t);
      q[t]:=i;
      i:=fa[i];
    end;
    inc(t);
    q[t]:=i;
    for i:=t downto 1 do
      push(q[i]);
    if t=1 then exit;
    fl:=true;
    while fl do
    begin
      y:=fa[x];
      if y=q[t] then
      begin
        if son[y,1]=x then rotate(x,2)
        else rotate(x,1);
        fl:=false;
      end
      else begin
        if fa[y]=q[t] then fl:=false;
        if son[fa[y],1]=y then
        begin
          if son[y,1]=x then rotate(y,2)
          else rotate(x,1);
          rotate(x,2);
        end
        else begin
          if son[y,1]=x then rotate(x,2)
          else rotate(y,1);
          rotate(x,1);
        end;
      end;
    end;
    update(x);
  end;

procedure access(x:longint);
  var y:longint;
  begin
    y:=0;
    repeat
      splay(x);
      son[x,2]:=y;
      update(x);
      y:=x;
      x:=fa[x];
    until x=0;
  end;

function find(x,y:longint):boolean;
  begin
    while son[y,1]<>0 do y:=son[y,1];  //Auxiliary tree最左的点即为所在树的根节点
    if y=x then exit(true) else exit(false);
  end;

procedure makeroot(x:longint);
  begin
    access(x);
    splay(x);
    reverse(x);  //注意，在这WA了几次
  end;

procedure path(x,y:longint);
  begin
    makeroot(x);
    access(y);
    splay(y);
  end;

procedure link(x,y:longint);
  begin
    if cc=0 then exit;  //一点小优化，cc记录删掉的边数
    path(x,y);
    if not find(x,y) then
    begin
      fa[x]:=y;
      dec(cc);
    end;
  end;

procedure cut(x,y:longint);
  begin
    path(x,y);
    if (son[y,1]=x) and (son[x,2]=0) then  //注意两点间有边的判定
    begin
      inc(cc);
      fa[x]:=0;
      son[y,1]:=0;
    end;
  end;

procedure change(x,y,z:longint);
  begin
    path(x,y);
    if (cc=0) or find(x,y) then calc(y,z);
  end;

procedure ask(x,y:longint);
  var a,b,c:int64;
  begin
    path(x,y);
    if (cc=0) or find(x,y) then
    begin
      c:=size[y];
      a:=(c+1)*s2[y]-s3[y];
      b:=c*(c+1) div 2;
      c:=gcd(a,b);
      writeln(a div c,'/',b div c);
    end
    else writeln(-1);
  end;

begin
  readln(n,m);
  for i:=1 to n do
  begin
    read(a[i]);
    size[i]:=1;
  end;
  for i:=1 to n-1 do
  begin
    readln(x,y);
    build(x,y);
    build(y,x);
  end;
  dfs(1);  //这里先dfs构造树，如果直接link的话会TLE目测
  for i:=1 to m do
  begin
    read(ch,x,y);
    if ch=1 then
      cut(x,y)
    else if ch=2 then
      link(x,y)
    else if ch=4 then
      ask(x,y)
    else begin
      read(z);
      change(x,y,z);
    end;
    readln;
  end;
end.