bzoj 3589: 动态树 树链剖分+线段树

题意

给出一棵树，要求资瓷两个操作：
操作0:
这棵树长出了一些果子, 即某个子树中的每个节点都会长出K个果子.
操作1:
小明希望你求出几条树枝上的果子数. 一条树枝其实就是一个从某个节点到根的路径的一段. 每次小明会选定一些树枝, 让你求出在这些树枝上的节点的果子数的和. 注意, 树枝之间可能会重合, 这时重合的部分的节点的果子只要算一次.
n,m<=200000，答案模2^31-1输出。

分析

首先这题跟lct一毛钱关系都没有。

看到这题一个很显然的想法就是树链剖分套线段树+容斥原理。虽然是可以过的，但是这样复杂度较大（但实际好像跑的并不慢）。
在网上get到了一个很棒的思路：
这题套上树链剖分后就变成了给你若干条线段，求这几条线段并的权值和。
我们可以先通过树剖把这不超过5logn条线段求出来，排序后求并，再把每段在线段树里面查询就好了。
这样的话总的复杂度就是O(5nlog^2)，而且还不用求lca。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=200005;

int cnt,n,m,last[N],size[N],fa[N],dep[N],top[N],pos[N],sz,tot,mx[N];
struct edge{int to,next;}e[N*2];
struct tree{int s,tag;}t[N*5];
pair<int,int> chain[N];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void dfs1(int x)
{
    dep[x]=dep[fa[x]]+1;size[x]=1;
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x]) continue;
        fa[e[i].to]=x;
        dfs1(e[i].to);
        size[x]+=size[e[i].to];
    }
}

void dfs2(int x,int chain)
{
    pos[x]=mx[x]=++sz;top[x]=chain;int k=0;
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&size[e[i].to]>size[k]) k=e[i].to;
    if (!k) return;
    dfs2(k,chain);
    for (int i=last[x];i;i=e[i].next)
        if (e[i].to!=fa[x]&&e[i].to!=k) dfs2(e[i].to,e[i].to);
    mx[x]=sz;
}

void pushdown(int d,int l,int r)
{
    if (!t[d].tag||l==r) return;
    int w=t[d].tag,mid=(l+r)/2;t[d].tag=0;
    t[d*2].s+=w*(mid-l+1);t[d*2].tag+=w;
    t[d*2+1].s+=w*(r-mid);t[d*2+1].tag+=w;
}

void updata(int d)
{
    t[d].s=t[d*2].s+t[d*2+1].s;
}

void ins(int d,int l,int r,int x,int y,int z)
{
    if (x>y) return;
    pushdown(d,l,r);
    if (l==x&&r==y)
    {
        t[d].s+=z*(r-l+1);t[d].tag+=z;
        return;
    }
    int mid=(l+r)/2;
    ins(d*2,l,mid,x,min(y,mid),z);
    ins(d*2+1,mid+1,r,max(x,mid+1),y,z);
    updata(d);
}

int Sig_query(int d,int l,int r,int x,int y)
{
    if (x>y) return 0;
    pushdown(d,l,r);
    if (l==x&&r==y) return t[d].s;
    int mid=(l+r)/2;
    return Sig_query(d*2,l,mid,x,min(y,mid))+Sig_query(d*2+1,mid+1,r,max(x,mid+1),y);
}

void query(int x,int y)
{
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]]) swap(x,y);
        chain[++tot]=make_pair(pos[top[x]],pos[x]);
        x=fa[top[x]];
    }
    if (dep[x]<dep[y]) swap(x,y);
    chain[++tot]=make_pair(pos[y],pos[x]);
}

bool cmp(pair<int,int> a,pair<int,int> b)
{
    return a.first<b.first;
}

void solve()
{
    sort(chain+1,chain+tot+1,cmp);
    int ans=0,l=1,mx=chain[1].second;
    for (int i=2;i<=tot;i++)
        if (chain[i].first>mx) ans+=Sig_query(1,1,n,chain[l].first,mx),l=i,mx=chain[i].second;
        else mx=max(mx,chain[i].second);
    ans+=Sig_query(1,1,n,chain[l].first,mx);
    printf("%d\n",ans&2147483647);
}

int main()
{
    n=read();
    for (int i=1;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y);
    }
    dfs1(1);
    dfs2(1,1);
    m=read();
    while (m--)
    {
        int op=read();
        if (!op)
        {
            int x=read(),y=read();
            ins(1,1,n,pos[x],mx[x],y);
        }
        else
        {
            tot=0;
            int s=read();
            while (s--) query(read(),read());
            solve();
        }
    }
    return 0;
}