BZOJ 3730: 震波 动态树分治 线段树 lca

3730: 震波

Time Limit: 15 Sec  Memory Limit: 256 MB
Submit: 1202  Solved: 288
[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

我们要询问和一个点距离<=k的所有点权和 并且支持修改

又要求强制在线

怎么搞呢？

动态点分治

搞出点分树 利用点分树log层的优势来搞事

考虑我们要维护什么

对于每个分治根，与其子树中的距离就是深度

所以考虑对于每个分治根，在子树中，利用其深度进行信息的维护

怎么搞呢~开线段树

每个分治根都开 以深度为下标 权值插入就行了

还有一个东西要注意下

每次由分治根向上爬 去更新答案

但是会出现算重的情况啊

所以每个点开两个线段树，一个表示以它为分治根，其子树的信息

一个表示它的分治父亲中，它的子树中的信息

搞的时候剪掉就行了

这里有图和样例解释

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<complex>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

typedef long long ll;

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

const int N=500100,inf=0X3f3f3f3f;

int last[N],ecnt;
struct EDGE{int to,nt;}e[N<<1];
inline void add(int u,int v)
{e[++ecnt]=(EDGE){v,last[u]};last[u]=ecnt;}

int root,n,sum,ans,f[N],size[N];
int V[N];

//ancestor
int anc[N][20],dep[N];

void dfs(int u)
{
	for(int i=1;(1<<i)<=dep[u];++i)anc[u][i]=anc[anc[u][i-1]][i-1];
	for(int i=last[u];i;i=e[i].nt)if(e[i].to^anc[u][0])
	{dep[e[i].to]=dep[u]+1;anc[e[i].to][0]=u;dfs(e[i].to);}
}

inline int getlca(int u,int v)
{
	if(dep[u]<dep[v])swap(u,v);
	int len=dep[u]-dep[v];
	for(int i=0;(1<<i)<=len;++i)if(len&(1<<i))u=anc[u][i];
	if(u==v)return u;
	for(int i=17;~i;i--)if(anc[u][i]^anc[v][i])
	u=anc[u][i],v=anc[v][i];
	return anc[u][0];
}

inline int getdis(int u,int v)
{int lca=getlca(u,v);return dep[u]+dep[v]-(dep[lca]<<1);}

bool vis[N];

void getroot(int u,int fa)
{
	size[u]=1;f[u]=0;
	for(int i=last[u];i;i=e[i].nt)
	if(e[i].to^fa&&!vis[e[i].to])
	{
		getroot(e[i].to,u);size[u]+=size[e[i].to];
		f[u]=max(f[u],size[e[i].to]);
	}
	f[u]=max(f[u],sum-size[u]);
	if(f[u]<f[root])root=u;
}

int rt[N][2];

struct seg_tree{int ls,rs,sum;}tr[N<<4];
int sz=0;

void insert(int &k,int l,int r,int x,int val)
{
	if(!k)k=++sz;tr[k].sum+=val;
	if(l==r)return ;int mid=(l+r)>>1;
	x<=mid?insert(tr[k].ls,l,mid,x,val):insert(tr[k].rs,mid+1,r,x,val);
}

int query_seg(int k,int l,int r,int x,int y)
{
	if(!k)return 0;
	if(l>=x&&r<=y)return tr[k].sum;
	int mid=(l+r)>>1;
	if(y<=mid)return query_seg(tr[k].ls,l,mid,x,y);
	if(x>mid)return query_seg(tr[k].rs,mid+1,r,x,y);
	return query_seg(tr[k].ls,l,mid,x,y)+query_seg(tr[k].rs,mid+1,r,x,y);
}

// source destination
void seek(int u,int ffa,int d,int dest,int p)
{
	insert(rt[dest][p],0,n,d,V[u]);
	for(int i=last[u];i;i=e[i].nt)
	if(ffa^e[i].to&&!vis[e[i].to])
	seek(e[i].to,u,d+1,dest,p);
}

int fa[N];

void init(int u,int ffa)
{
	vis[u]=1;fa[u]=ffa;
	seek(u,0,0,u,0);
	for(int i=last[u];i;i=e[i].nt)
	if(!vis[e[i].to])
	{
		sum=size[e[i].to];root=0;getroot(e[i].to,u);
		seek(e[i].to,u,1,root,1);
		init(root,u);
	}
}

void modify(int u,int val)
{
	val=val-query_seg(rt[u][0],0,n,0,0);
	insert(rt[u][0],0,n,0,val);
	for(int dis,v=u;fa[v];v=fa[v])
	{
		dis=getdis(fa[v],u);
		insert(rt[v][1],0,n,dis,val);
		insert(rt[fa[v]][0],0,n,dis,val);
	}
}

void query(int u,int k)
{
	int res=query_seg(rt[u][0],0,n,0,k);
	for(int dis,v=u;fa[v];v=fa[v])
	{
		dis=getdis(fa[v],u);
		res-=query_seg(rt[v][1],0,n,0,k-dis);
		res+=query_seg(rt[fa[v]][0],0,n,0,k-dis);
	}
	print(res);ans=res;puts("");
}

int main()
{
	n=sum=read();
	int Q=read();
	register int i,opt,u,v;
	for(i=1;i<=n;++i)V[i]=read();
	for(i=1;i<n;++i){u=read();v=read();add(u,v);add(v,u);}
	dfs(1);
	f[0]=inf;getroot(1,0);init(root,0);
	while(Q--)
	{
		opt=read();u=read()^ans;v=read()^ans;
		opt?modify(u,v):query(u,v);
	}
	return 0;
}
/*
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

11100101
*/