【BZOJ-3730】震波 动态点分治 + 树状数组

3730: 震波

Time Limit: 15 Sec  Memory Limit: 256 MB
Submit: 626  Solved: 149
[Submit][Status][Discuss]

Description

在一片土地上有N个城市，通过N-1条无向边互相连接，形成一棵树的结构，相邻两个城市的距离为1，其中第i个城市的价值为value[i]。
不幸的是，这片土地常常发生地震，并且随着时代的发展，城市的价值也往往会发生变动。
接下来你需要在线处理M次操作：
0 x k 表示发生了一次地震，震中城市为x，影响范围为k，所有与x距离不超过k的城市都将受到影响，该次地震造成的经济损失为所有受影响城市的价值和。
1 x y 表示第x个城市的价值变成了y。
为了体现程序的在线性，操作中的x、y、k都需要异或你程序上一次的输出来解密，如果之前没有输出，则默认上一次的输出为0。

Input

第一行包含两个正整数N和M。
第二行包含N个正整数，第i个数表示value[i]。
接下来N-1行，每行包含两个正整数u、v，表示u和v之间有一条无向边。
接下来M行，每行包含三个数，表示M次操作。

Output

包含若干行，对于每个询问输出一行一个正整数表示答案。

Sample Input

8 1
1 10 100 1000 10000 100000 1000000 10000000
1 2
1 3
2 4
2 5
3 6
3 7
3 8
0 3 1

Sample Output

11100101

HINT

1<=N,M<=100000
1<=u,v,x<=N
1<=value[i],y<=10000
0<=k<=N-1

Source

Solution

动态点分治裸题...

动态点分治就是将点分治中的重心形成的树形结构（点分树）利用起来，每层维护对答案的贡献，然后暴力求解。

静态的点分治问题常见的有两种统计答案的方法，一种是处理一棵子树，统计当前子树与之前子树共同对答案的贡献，然后将当前子树的贡献加入，重复处理下一棵子树。

另一种方法就是先处理出所有子树对答案的贡献，然后每棵子树与其他子树共同对答案的贡献就是，当前子树+（总-当前子树）。表述有限反正就是那么个意思...

动态点分治维护的信息只适用于第二种方式的信息。

考虑这种方法的时空复杂度。因为点分树树高严格$logN$，如果每层统计答案复杂度$logN$，暴力爬树查询修改的复杂度是$log^{2}N$的，空间复杂度动态存储也是$log^{2}N$。

不仅支持修改和查询，同时可以支持加叶子操作，因为加叶子操作不会直接影响重心，但是会引起最初构造的点分树不平衡，复杂度无法得到保证，所以可以利用替罪羊树的思想，定期进行重建。

对于这道题，询问距离点距离小于等于$K$的点权和，支持修改。

建出点分树，考虑每个点维护两个树状数组$f,g$，分别表示 距离该点距离为$k$的点权和 距离该点点分树上父亲的距离为$k$的点权和 ，距离为下标，额外进行一遍dfs即可预处理得到。

查询，从查询点开始沿着点分树向上爬，按照做差去重的方式统计答案，修改同理。

显然树状数组要动态内存，所以要vector....谢谢Yveh大爷对萌新的指导QwQ

Code

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
inline 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;
}
#define MAXN 100010
int N,M,val[MAXN],lastans;

namespace Tree{
    struct EdgeNode{
        int next,to;
    }edge[MAXN<<1];
    int head[MAXN],cnt=1;
    inline void AddEdge(int u,int v) {cnt++; edge[cnt].next=head[u]; head[u]=cnt; edge[cnt].to=v;}
    inline void InsertEdge(int u,int v) {AddEdge(u,v); AddEdge(v,u);}

    int deep[MAXN],dist[MAXN],father[18][MAXN];
    inline void DFS(int now,int last)
    {
        for (int i=1; i<=17; i++)
            if (deep[now]>=(1<<i))
                father[i][now]=father[i-1][father[i-1][now]];
            else
                break;
        for (int i=head[now]; i; i=edge[i].next)
            if (edge[i].to!=last) {
                deep[edge[i].to]=deep[now]+1;
                dist[edge[i].to]=dist[now]+1;
                father[0][edge[i].to]=now;
                DFS(edge[i].to,now);
            }
    }

    inline int LCA(int x,int y)
    {
        if (deep[x]<deep[y]) swap(x,y);
        int dd=deep[x]-deep[y];
        for (int i=0; i<=17; i++)
            if (dd&(1<<i)) x=father[i][x];
        for (int i=17; i>=0; i--)
            if (father[i][x]!=father[i][y])
                x=father[i][x],y=father[i][y];
        return x==y? x:father[0][x];
    }

    inline int Dist(int x,int y)
    {
        int z=LCA(x,y);
        return deep[x]+deep[y]-deep[z]-deep[z];
    }
}using namespace Tree;

namespace BIT{
    typedef vector<int> vec;
    struct BIT{
        vec tree; int n;
        inline void init(int size) {tree.resize(size+2); n=size+1;}
        inline int lowbit(int x) {return x&-x;}
        inline void Modify(int x,int d) {if (x<=0) return; for (int i=x; i<=n; i+=lowbit(i)) tree[i]+=d;}
        inline int Query(int x) {int re=0; if (x>n) x=n; for (int i=x; i>0; i-=lowbit(i)) re+=tree[i]; return re;}
    }f[MAXN],g[MAXN];
}using namespace BIT;

namespace TreeDivide{

    int size[MAXN],mx[MAXN],root,Sz,par[MAXN];
    bool visit[MAXN];

    inline void Getroot(int now,int last)
    {
        size[now]=1,mx[now]=0;
        for (int i=head[now]; i; i=edge[i].next)
            if (edge[i].to!=last && !visit[edge[i].to]) {
                Getroot(edge[i].to,now);
                size[now]+=size[edge[i].to];
                mx[now]=max(mx[now],size[edge[i].to]);
            }
        mx[now]=max(mx[now],Sz-size[now]);
        if (mx[now]<mx[root]) root=now;
    }

    inline void DFS(int now,int last,int dep)
    {
        f[root].Modify(dep+1,val[now]);
        g[par[root]].Modify(dep+1,val[now]);
        for (int i=head[now]; i; i=edge[i].next)
            if (edge[i].to!=last && !visit[edge[i].to]) {
                DFS(edge[i].to,now,dep+1);
            }
    }

    inline void Divide(int now)
    {
//      printf("Divide = %d\n",now);

        visit[now]=1;

        g[now].Modify(1,val[now]);

        for (int i=head[now]; i; i=edge[i].next)
            if (!visit[edge[i].to]) {
                root=0;
                Sz=size[edge[i].to];
                Getroot(edge[i].to,now);
                par[root]=now;
                f[root].init(Sz),g[root].init(Sz);
                DFS(edge[i].to,now,1);
                Divide(root);
            }
    }

    inline void Modify(int x,int y)
    {
        for (int i=x; i; i=par[i]) {
            int dep=Tree::Dist(x,i)+1;
            g[i].Modify(dep,y-val[x]);
            if (par[i])
                dep=Tree::Dist(par[i],x)+1,f[i].Modify(dep,y-val[x]);
        }
        val[x]=y;
    }

    inline int Query(int x,int k)
    {
        int ans=0;
        for (int i=x; i; i=par[i]) {
            int dep=k-Tree::Dist(x,i)+1;
            ans+=g[i].Query(dep);
            if (par[i])
                dep=k-Tree::Dist(x,par[i])+1,ans-=f[i].Query(dep);
        }
        return ans;
    }
}using namespace TreeDivide;

int main()
{
    N=read(),M=read();
    for (int i=1; i<=N; i++) val[i]=read();
    for (int i=1,x,y; i<=N-1; i++) x=read(),y=read(),Tree::InsertEdge(x,y);

    Tree::DFS(1,0);

    Sz=mx[root=0]=N;
    Getroot(1,0);
    f[root].init(Sz),g[root].init(Sz);
    Divide(root);

    while (M--) {
        int opt=read(),x=read(),y=read();
        x^=lastans,y^=lastans;
        if (opt==1) {
            TreeDivide::Modify(x,y);
        } else {
            printf("%d\n",lastans=TreeDivide::Query(x,y));
        }
    }
    return 0;
}