BZOJ 3091 城市旅行 (LCT)

题目大意：

 

很显然是一个$LCT$题= =

操作1,2都是$LCT$基本操作，操作3打个标记即可

重点就是操作4该如何在$LCT$里维护，我们先不管期望的问题，只需要把总和$/(sum*(sum+1)/2)$即可

我们把链拎出来，摊平

每个节点的答案，就是它(左侧节点数+1)*(右侧节点数+1)*它的权值

我们在用$splay$维护动态链时，$splay$树中，我们每个节点为根的子树都能表示一条链

一个节点$x$连接了左右子节点$ls,rs$，那么，$x$子树表示的链，相当于把$ls$的链，$x$节点，$rs$的链的接在了一起

我们需要把它们的信息进行合并

发现这其实是一个卷积的形式

$splay$中，每个节点维护，子树中节点数量$sz$，子树中节点权值总和$sum$，以及$lx,rx$表示它子树中所有节点的权值*(这些节点左/右侧节点数量+1)，最后一个答案数组$tx$

这几个数组在$pushup$里很好处理，建议自己推式子

关键是在$update$后，下推标记时该如何处理。我们必须保证下推标记后，子节点的$lx,rx,tx$数组能$O(1)$更新

设增加的权值是$tag$

显然$lx,rx$都会增加$tag*sz_{x}*(sz_{x}+1)/2$，把链摊开，$tag$对每个节点的贡献是一个等差数列

$tag$对答案$tx$的更新值是$\sum i\cdot(sz-i+1)$ 其中$i$表示它在摊开链中的位置

展开，再用$1~n$平方和公式，可得$tag$对答案的贡献是$tag*sz*(sz+1)*(sz+2)/6$

注意！$revers$操作需要把$lx$和$rx$交换！

另外由于操作中可能有一部分边不能连，每次都$findroot$会消耗大量时间

所以每次$findroot$后，把根转上去能大幅优化常数

还有，$namespace$跑得是真的慢..$struct$就飞快

#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 50100
#define M1 2010
#define S1 (N1<<1)
#define T1 (N1<<2)
#define ll long long
#define uint unsigned int
#define rint register int 
#define ull unsigned long long
#define dd double
#define il inline 
#define inf 1000000000
using namespace std;

int gint()
{
    int ret=0,fh=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=ret*10+c-'0';c=getchar();}
    return ret*fh;
}
int n,m,T,type;
int tot;
struct LCT{
int ch[N1][2],fa[N1],rev[N1],val[N1],tag[N1];
ll lx[N1],rx[N1],tx[N1],sum[N1],sz[N1];
inline int idf(int x){return ch[fa[x]][0]==x?0:1;}
inline int isroot(int x){return (ch[fa[x]][0]==x||ch[fa[x]][1]==x)?0:1;}
void revers(int x)
{
    swap(ch[x][0],ch[x][1]);
    swap(lx[ch[x][0]],rx[ch[x][0]]);
    swap(lx[ch[x][1]],rx[ch[x][1]]);
    rev[x]^=1;
}
void pushup(int x)
{
    int ls=ch[x][0],rs=ch[x][1];
    sz[x]=sz[ls]+sz[rs]+1;
    sum[x]=sum[ls]+sum[rs]+val[x];
    lx[x]=lx[ls]+lx[rs]+1ll*(sum[ls]+val[x])*(sz[rs]+1);
    rx[x]=rx[ls]+rx[rs]+1ll*(sum[rs]+val[x])*(sz[ls]+1);
    tx[x]=tx[ls]+tx[rs]+1ll*rx[ls]*(sz[rs]+1)+1ll*lx[rs]*(sz[ls]+1)+1ll*val[x]*(sz[ls]+1)*(sz[rs]+1);
}
void pushdown(int x)
{
    if(rev[x])
    {
        if(ch[x][0]) revers(ch[x][0]);
        if(ch[x][1]) revers(ch[x][1]);
        rev[x]^=1;
    }
    if(tag[x])
    {
        int ls=ch[x][0],rs=ch[x][1]; ll w=tag[x];
        if(ls)
        {
            tag[ls]+=w,val[ls]+=w,sum[ls]+=1ll*sz[ls]*w;
            lx[ls]+=1ll*w*(sz[ls]+1)*sz[ls]/2;
            rx[ls]+=1ll*w*(sz[ls]+1)*sz[ls]/2;
            tx[ls]+=1ll*sz[ls]*(sz[ls]+1)*(sz[ls]+2)/6*w;
        }
        if(rs)
        {
            tag[rs]+=w,val[rs]+=w,sum[rs]+=1ll*sz[rs]*w;
            lx[rs]+=1ll*(sz[rs]+1)*sz[rs]/2*w;
            rx[rs]+=1ll*(sz[rs]+1)*sz[rs]/2*w;
            tx[rs]+=1ll*sz[rs]*(sz[rs]+1)*(sz[rs]+2)/6*w;
        }
        tag[x]=0;
    }
}
void rot(int x)
{
    int y=fa[x],ff=fa[y],px=idf(x),py=idf(y);
    if(!isroot(y)) ch[ff][py]=x; fa[x]=ff;
    fa[ch[x][px^1]]=y,ch[y][px]=ch[x][px^1];
    ch[x][px^1]=y,fa[y]=x;
    pushup(y),pushup(x);
}
int stk[N1],tp;
void splay(int x)
{
    int y=x; stk[++tp]=x;
    while(!isroot(y)){stk[++tp]=fa[y],y=fa[y];}
    while(tp){pushdown(stk[tp--]);}
    while(!isroot(x))
    {
        y=fa[x];
        if(isroot(y)) rot(x);
        else if(idf(y)==idf(x)) rot(y),rot(x);
        else rot(x),rot(x);
    }
}
void access(int x)
{
    for(int y=0;x;y=x,x=fa[x]) 
        splay(x),ch[x][1]=y,pushup(x);
}
void mkroot(int x)
{
    access(x),splay(x),revers(x);
    swap(lx[x],rx[x]);
}
int fdroot(int x)
{
    access(x),splay(x); 
    while(ch[x][0]) x=ch[x][0],pushdown(x);
    splay(x); return x;
}
void split(int x,int y){mkroot(x),access(y),splay(y);}
void link(int x,int y)
{
    mkroot(x);
    if(fdroot(y)!=x) fa[x]=y;
}
void cut(int x,int y)
{
    split(x,y);
    if(!ch[x][1]&&fa[x]==y&&ch[y][0]==x) 
        ch[y][0]=fa[x]=0,pushup(y);
}
ll query(int x,int y)
{
    split(x,y);
    if(fdroot(y)!=x) return -1; 
    return tx[x];
}
void update(int x,int y,int w)
{
    split(x,y);
    if(fdroot(y)!=x) return;
    tag[x]+=w,val[x]+=w,sum[x]+=1ll*w*sz[x];
    lx[x]+=1ll*w*(sz[x]+1)*sz[x]/2;
    rx[x]+=1ll*w*(sz[x]+1)*sz[x]/2;
    tx[x]+=1ll*sz[x]*(sz[x]+1)*(sz[x]+2)/6*w;
}
void init(){for(int i=1;i<=n;i++) sz[i]=1,pushup(i);}
}lct;
ll gcd(ll x,ll y){if(!y) return x; return gcd(y,x%y);}

int main()
{
    int i,j,x,y,w,fl;ll ans,g,nn;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++) lct.val[i]=gint();
    lct.init();
    for(j=1;j<n;j++) x=gint(), y=gint(), lct.link(x,y);
    for(j=1;j<=m;j++)    
    {
        fl=gint(); x=gint(); y=gint();
        if(fl==1) lct.cut(x,y);
        if(fl==2) lct.link(x,y);
        if(fl==3) w=gint(),lct.update(x,y,w);
        if(fl==4)
        {
            ans=lct.query(x,y);
            if(ans==-1) {puts("-1");continue;}
            nn=1ll*(lct.sz[x])*(lct.sz[x]+1)/2;
            g=gcd(ans,nn);
            printf("%lld/%lld\n",ans/g,nn/g);
        }
    }
    return 0;
}