bzoj3589 动态树 树链剖分

Description

---

别忘了这是一棵动态树, 每时每刻都是动态的. 小明要求你在这棵树上维护两种事件
事件0:
这棵树长出了一些果子, 即某个子树中的每个节点都会长出K个果子.
事件1:
小明希望你求出几条树枝上的果子数. 一条树枝其实就是一个从某个节点到根的路径的一段. 每次小明会选定一些树枝, 让你求出在这些树枝上的节点的果子数的和. 注意, 树枝之间可能会重合, 这时重合的部分的节点的果子只要算一次.

1 <= n <= 200,000, 1 <= nQ <= 200,000, K = 5.

Solution

---

显然一个可行的做法就是lct每次求相邻两点lca然后减去重复部分，而且似乎能跑过的样子，然而我并不会lct上维护子树信息

注意到k很小可以先轻重链剖分求出klogn条链，然后对它们的并求和即可，这个随便写写就行了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define fi first
#define se second

typedef std:: pair <int,int> pair;
const int N=400005;
const int E=400005;

struct edge {int y,next;} e[E];

std:: vector <pair> vec;

int bl[N],fa[N],size[N];
int pos[N],dep[N],tot;
int sum[N*4],tag[N*4];
int ls[N],edCnt;

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void add_edge(int x,int y) {
    e[++edCnt]=(edge) {y,ls[x]}; ls[x]=edCnt;
    e[++edCnt]=(edge) {x,ls[y]}; ls[y]=edCnt;
}

void push_down(int now,int l,int r,int mid) {
    if (!tag[now]) return ;
    int w=tag[now]; tag[now]=0;
    tag[now<<1]+=w;
    tag[now<<1|1]+=w;
    sum[now<<1]+=w*(mid-l+1);
    sum[now<<1|1]+=w*(r-mid);
}

int query(int now,int tl,int tr,int l,int r) {
    if (tl==l&&tr==r) return sum[now];
    int mid=(tl+tr)>>1;
    push_down(now,tl,tr,mid);
    if (r<=mid) return query(now<<1,tl,mid,l,r);
    if (l>mid) return query(now<<1|1,mid+1,tr,l,r);
    int qx=query(now<<1,tl,mid,l,mid);
    int qy=query(now<<1|1,mid+1,tr,mid+1,r);
    return qx+qy;
}

void modify(int now,int tl,int tr,int l,int r,int v) {
    if (tl==l&&tr==r) {
        sum[now]+=(r-l+1)*v;
        tag[now]+=v;
        return ;
    }
    int mid=(tl+tr)>>1;
    push_down(now,tl,tr,mid);
    if (r<=mid) modify(now<<1,tl,mid,l,r,v);
    else if (l>mid) modify(now<<1|1,mid+1,tr,l,r,v);
    else {
        modify(now<<1,tl,mid,l,mid,v);
        modify(now<<1|1,mid+1,tr,mid+1,r,v);
    }
    sum[now]=sum[now<<1]+sum[now<<1|1];
}

void dfs1(int now) {
    size[now]=1;
    for (int i=ls[now];i;i=e[i].next) {
        if (fa[now]==e[i].y) continue;
        fa[e[i].y]=now;
        dep[e[i].y]=dep[now]+1;
        dfs1(e[i].y);
        size[now]+=size[e[i].y];
    }
}

void dfs2(int now,int up) {
    bl[now]=up; pos[now]=++pos[0];
    int mx=0;
    for (int i=ls[now];i;i=e[i].next) {
        if (size[e[i].y]>size[mx]&&e[i].y!=fa[now]) mx=e[i].y;
    }
    if (!mx) return ;
    dfs2(mx,up);
    for (int i=ls[now];i;i=e[i].next) {
        if (e[i].y!=fa[now]&&e[i].y!=mx) dfs2(e[i].y,e[i].y);
    }
}

void ask(int x,int y) {
    for (;bl[x]!=bl[y];) {
        if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
        vec.push_back(pair(pos[bl[x]],pos[x]));
        x=fa[bl[x]];
    }
    if (pos[x]>pos[y]) std:: swap(x,y);
    vec.push_back(pair(pos[x],pos[y]));
}

void solve() {
    std:: sort(vec.begin(),vec.end());
    int rig=vec[0].se,lef=vec[0].fi,ans=0;
    rep(i,1,vec.size()-1) {
        if (vec[i].fi>rig) {
            ans+=query(1,1,pos[0],lef,rig);
            lef=vec[i].fi; rig=vec[i].se;
        } else rig=std:: max(rig,vec[i].se);
    }
    ans+=query(1,1,pos[0],lef,rig);
    printf("%d\n", ans&2147483647);
    vec.clear();
}

int main(void) {
    int n=read();
    rep(i,2,n) add_edge(read(),read());
    dep[1]=1; dfs1(1); dfs2(1,1);
    for (int T=read();T--;) {
        if (read()) {
            for (int i=read();i--;) {
                int x=read(),y=read();
                ask(x,y);
            }
            solve();
        } else {
            int x=read(),v=read();
            modify(1,1,n,pos[x],pos[x]+size[x]-1,v);
        }
    }
    return 0;
}