loj #2322. 「清华集训 2017」Hello world!

题面

题意

给出一棵树，要求支持两种操作：
1.给出u，v，从u开始每次向v条k条边（如果到v的距离小于k则直接到达v），对所有经过的点的权值开根。
2.给出u，v，从u开始每次向v条k条边（如果到v的距离小于k则直接到达v），求所有经过的点的权值和。

做法

根据每次跳的长度k进行分块，令块大小为S。
然后对于1~S中的每一个数i建一个森林，每个点的父亲是这个点在原树上与它深度差i的祖先，并对森林中的每棵树都用树状数组维护其DFS序的前缀点权和，并且用并查集维护每个点在这棵树的所有祖先中（包括自己）点权不为1，深度最大的点（优化开根）。

对于p到q的路径，可以拆成：

其中p->pu和q’->qu上每隔k个就是一个需要处理的点，再对q单独处理，要注意q’->qu这段长度为0和q为lca 的情况。

对于操作1:
对于小于等于S的k，在新建出的树上跳（利用并查集优化），对这些数开根。
对于大于S的k，暴力向上跳并开根。
若开根之后数字为1，修改这个点在所有树上的并查集和树状数组。

对于操作2：
对于小于等于S的k，在新建出的树上树链剖分。
对于大于S的k，暴力向上跳并求和。

需要注意的是如果某个点的点权初始为1则它在并查集中的初始父节点为其父亲。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#define ll long long
#define LG 15
#define MKS 45
#define N 50010
using namespace std;

ll n,m,num[N],first[N],fa[N][20],deep[N],mx[N],sn[N],bb,tt,ans,KS;
struct Bn
{
	ll to,next;
}bn[N<<1];

inline void kg(ll u);
struct Tree
{
	ll fa[N],up[N],in[N],sz[N],top[N];
	vector<ll>son[N],gen;
	
	ll fu(ll u){return u==up[u]?u:up[u]=fu(up[u]);}
	inline ll lb(ll u){return u&(-u);}
	inline void add(ll u,ll v){for(;u<=n;u+=lb(u)) sz[u]+=v;}
	inline ll ask(ll u){ll res=0;for(;u;u-=lb(u)) res+=sz[u];return res;}
	
	inline void insert(ll u,ll v)
	{
		fa[u]=v;
		up[u]=u;
		if(!v) gen.push_back(u);
		else son[v].push_back(u);
	}
	
	inline void chg(ll u)
	{
		up[u]=fu(fa[u]);
	}
	
	ll dfs(ll now)
	{
		ll i,j,res=1,tmp,mx=0;
		sn[now]=0;
		for(i=0;i<son[now].size();i++)
		{
			res+=tmp=dfs(son[now][i]);
			if(tmp>mx)
			{
				mx=tmp;
				sn[now]=son[now][i];
			}
		}
		return res;
	}
	
	void Dfs(ll now)
	{
		in[now]=++tt;
		add(tt,num[now]);
		if(sn[now])
		{
			top[sn[now]]=top[now];
			Dfs(sn[now]);
		}
		else return;
		ll i,j;
		for(i=0;i<son[now].size();i++)
		{
			if(son[now][i]==sn[now]) continue;
			top[son[now][i]]=son[now][i];
			Dfs(son[now][i]);
		}
	}
	
	inline void init()
	{
		ll i,j;
		tt=0;
		for(i=0;i<gen.size();i++)
		{
			top[gen[i]]=gen[i];
			dfs(gen[i]);
			Dfs(gen[i]);
		}
		for(i=1;i<=n;i++) if(num[i]==1) chg(i);
	}
	
	inline void work(ll u,ll v)
	{
		for(u=fu(u);deep[u]>=deep[v];u=fu(fa[u]))
		{
			kg(u);
		}
	}
	
	inline ll sum(ll u,ll v)
	{
		ll res=0;
		for(;top[u]!=top[v];)
		{
			res+=ask(in[u])-ask(in[top[u]]-1);
			u=fa[top[u]];
		}
		res+=ask(in[u])-ask(in[v]-1);
		return res;
	}
}tree[MKS+10];

inline void add(ll u,ll v)
{
	bb++;
	bn[bb].to=v;
	bn[bb].next=first[u];
	first[u]=bb;
}

inline ll get(ll u,ll v)
{
	ll i=mx[v];
	v=deep[u]-v;
	if(v<=0) return 0;
	for(;deep[u]!=v;i--)
	{
		if(deep[fa[u][i]]>=v) u=fa[u][i];
	}
	return u;
}

inline ll lca(ll u,ll v)
{
	if(deep[u]<deep[v]) swap(u,v);
	ll i;
	u=get(u,deep[u]-deep[v]);
	for(i=mx[deep[u]];i>=0;i--)
	{
		if(fa[u][i]!=fa[v][i])
		{
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	if(u!=v) return fa[u][0];
	return u;
}

void dfs(ll now,ll last)
{
	ll p,q;
	for(p=first[now];p!=-1;p=bn[p].next)
	{
		if(bn[p].to==last) continue;
		fa[bn[p].to][0]=now;
		deep[bn[p].to]=deep[now]+1;
		dfs(bn[p].to,now);
	}
}

inline void kg(ll u)
{
	if(num[u]==1) return;
	ll i,j,v,t;
	v=sqrt(num[u]);
	t=v-num[u];
	for(i=1;i<=KS;i++) tree[i].add(tree[i].in[u],t);
	if(v==1)
	{
		for(i=1;i<=KS;i++)
		{
			tree[i].chg(u);
		}
	}
	num[u]=v;
}

int main()
{
	memset(first,-1,sizeof(first));
	ll i,j,p,q,o,z,l,pu,qu,qy,t;
	cin>>n;
	KS=min((ll)sqrt(n),(ll)MKS);
	mx[0]=-1;
	for(i=1;i<=n;i++)
	{
		scanf("%lld",&num[i]);
		mx[i]=mx[i/2]+1;
	}
	for(i=1;i<n;i++)
	{
		scanf("%lld%lld",&p,&q);
		add(p,q);
		add(q,p);
	}
	deep[1]=1;
	dfs(1,-1);
	for(j=1;j<=LG;j++)
	{
		for(i=1;i<=n;i++)
		{
			fa[i][j]=fa[fa[i][j-1]][j-1];
		}
	}
	
	for(i=1;i<=n;i++)
	{
		p=i;
		for(j=1;j<=KS;j++)
		{
			p=fa[p][0];
			tree[j].insert(i,p);
		}
	}
	for(i=1;i<=KS;i++) tree[i].init();
//	return 0;
	
	cin>>m;
	for(i=1;i<=m;i++)
	{
		scanf("%lld%lld%lld%lld",&z,&p,&q,&o);
		qy=q;
		l=lca(p,q);
		t=deep[p]-deep[l];
		t=t/o*o;
		pu=get(p,t);
		t=o-(deep[p]-deep[l]-t);
		qu=t=deep[l]+t;
		if(deep[q]>t)
		{
			t+=(deep[q]-t-1)/o*o;
			q=get(q,deep[q]-t);
			qu=get(q,deep[q]-qu);
		}
		else q=qu=0;
		if(!z)
		{
			if(pu!=qy)
				kg(qy);
			if(o>KS)
			{
				for(;deep[p]>=deep[pu];p=get(p,t))
				{
					kg(p);
					t=tree[1].fu(fa[p][0]);
					t=(deep[p]-deep[t]+o-1)/o*o;
				}
				if(q)
				{
					for(;deep[q]>=deep[qu];q=get(q,t))
					{
						kg(q);
						t=tree[1].fu(fa[q][0]);
						t=(deep[q]-deep[t]+o-1)/o*o;
					}
				}
			}
			else
			{
				tree[o].work(p,pu);
				if(q) tree[o].work(q,qu);
			}
		}
		else
		{
			ans=pu!=qy?num[qy]:0;
			if(o>KS)
			{
				for(;;p=get(p,o))
				{
					ans+=num[p];
					if(p==pu) break;
				}
				if(q)
				{
					for(;;q=get(q,o))
					{
						ans+=num[q];
						if(q==qu) break;
					}
				}
			}
			else
			{
				ans+=tree[o].sum(p,pu);
				if(q)
					ans+=tree[o].sum(q,qu);
			}
			printf("%lld\n",ans);
		}
	}
}