【BZOJ-3730】震波動態點分治 + 樹狀數組

時間 2019-11-13

原文原文鏈接

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。php

Input

第一行包含兩個正整數N和M。
第二行包含N個正整數，第i個數表示value[i]。
接下來N-1行，每行包含兩個正整數u、v，表示u和v之間有一條無向邊。
接下來M行，每行包含三個數，表示M次操做。ios

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-1ide

Source

Solution

動態點分治裸題...spa

動態點分治就是將點分治中的重心造成的樹形結構（點分樹）利用起來，每層維護對答案的貢獻，而後暴力求解。blog

靜態的點分治問題常見的有兩種統計答案的方法，一種是處理一棵子樹，統計當前子樹與以前子樹共同對答案的貢獻，而後將當前子樹的貢獻加入，重複處理下一棵子樹。ip

另外一種方法就是先處理出全部子樹對答案的貢獻，而後每棵子樹與其餘子樹共同對答案的貢獻就是，當前子樹+（總-當前子樹）。表述有限反正就是那麼個意思...內存

動態點分治維護的信息只適用於第二種方式的信息。get

考慮這種方法的時空複雜度。由於點分樹樹高嚴格$logN$，若是每層統計答案複雜度$logN$，暴力爬樹查詢修改的複雜度是$log^{2}N$的，空間複雜度動態存儲也是$log^{2}N$。string

不只支持修改和查詢，同時能夠支持加葉子操做，由於加葉子操做不會直接影響重心，可是會引發最初構造的點分樹不平衡，複雜度沒法獲得保證，因此能夠利用替罪羊樹的思想，按期進行重建。

對於這道題，詢問距離點距離小於等於$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;
}