【XSY4746】会议选址（三度化，边分治，点分治）

ez_lcw

于 2022-09-29 09:40:43 发布

阅读量587

点赞数

文章标签：。

本文链接：https://blog.csdn.net/ez_lcw/article/details/127101234

版权

这种关键点的重心问题，一般有两种思路。

一种是合并：对于两个不交的点集 $S, T$ ， $S\cup T$ 的重心必在 $S, T$ 重心间的路径上，二分即可，需要数据结构支持 dfn 区间内 $S\cup T$ 内的点的个数。

使用该做法能将本题做到 $O(n\log^3n+q\log n)$ 。

另一种想法是，对于单次询问点集 $S$ ，先从任意一个点开始，考虑往当前最大的子树走，直到最大的子树大小小于等于 $S /2$ 。

如果用树剖+二分暴躁加速这个过程的话，单次询问还是 $O(\log^3n)$ 的。

优秀的做法是使用三度化和边分治。我们先一一初步介绍。

三度化的具体作用是：将带权树，在不改变任意两点间距离、任意两点间祖先后代关系的情况下，转化成每个点度数至多为 $3$ 的点数至多翻倍的树.

但三度化会改变两点间的直接父子关系，以及新增一些原树没有的虚点，这些都是需要注意的。

三度化有两种方法，如下图：

在这里插入图片描述

称原树中的点为旧点，新增的点为虚点，三度化后的树为新树。

其中使用第一种方法，能让新树的深度不超过 $O(d\log \frac{n}{d})$ ，其中 $d, n$ 是原树的深度和大小。但这个性质和本题没有关系。

边分治是如下的过程：

假设当前树大小为 $n$ ，每个点的度数不超过 $D$ 。找到一条边使得分出来两棵树的大小相差最小，设找到的边是 $(u, v)$ ，且 $u$ 对应的那棵子树的大小更大，设为 $S$ 。

设 $u$ 的各个儿子的子树大小为 $s_1,\cdots,s_{D-1}$ （不足 $D - 1$ 个儿子用 $0$ 补齐），那么显然对于任意 $i$ 满足 $s_i\leq n-s_i$ ，进一步地，应满足 $(n-s_i)-s_i\geq S-(n-S)$ ，得到 $S+s_i\leq n$ 。

将这 $D - 1$ 条不等式加起来，得到 $(D-1)S+\sum s_i\leq (D-1)n$ ，即 $DS-1\leq (D-1)n$ ，那么 $S\leq\frac{D-1}{D}n+1$ 。

从而，在将树三度化的基础上，按上述方法找到的边，能使得分成的两棵子树大小都不超过 $\frac{2}{3}n+1$ 。

于是边分树的深度是 $O(\log_{\frac{3}{2}}n)=O\left(\dfrac{\log n}{\log\frac{3}{2}}\right)=O(\log n)$ 级别的。

具体回到这题。我们考虑用如下的方式找原树上若干关键点的重心：对于每一条边 $(a, b)$ ，若 $a$ 子树内的关键点个数小于 $b$ 子树内的关键点个数，那么令这条边的方向是 $a\to b$ ；否则，若 $b$ 子树内的关键点个数小于 $a$ 子树内的关键点个数，那么令这条边的方向是 $b\to a$ 。若 $a, b$ 子树内的关键点个数相同，那么令这条边无向。

那么可以证明，最后树上肯定形如：存在一个无向边的连通块，然后其余所有边都指向这个连通块。此时连通块内的任意一个点都可以是这些关键点的重心。

考虑将这个方法作用在新树上：那么原树上一条边 $fa_a,a)$ 的指向，和新树上 $fa_a',a)$ 的指向相同。

不妨假设新树上那些关键点的重心在 $r t$ ，注意 $r t$ 可能是虚点。设 $r t$ 在旧点 $u$ 在新树上的子树内，但不在 $u$ 任意一个旧儿子在新树上的子树内。考虑 $fa_u,u)$ 的指向，由于 $fa_u'\to u$ ，那么 $fa_u\to u$ 。对于 $u$ 的任意旧儿子 $v$ ，考虑 $(u, v)$ 的指向，由于 $v\to fa_v'$ ，那么 $v\to u$ 。从而，我们证明了 $u$ 是原树上关键点的重心。

于是我们找出新树上的重心即可。我们从边分树的根开始往下走。每次考虑当前边 $e$ 的指向。考虑直接数出 $e$ 两边的关键点个数。首先要数 $A, B$ 子树内编号在 $[l, r]$ 内的点数，可以通过 dfn 序+可持久化做到 $O(n\log n)-O(\log n)$ 。而对于 $A, B$ 外的那些点，它们在边分树上对应不超过 $O(\log n)$ 棵子树，且这些子树内的关键点个数我们也可以在走下来的过程中顺便记录，于是我们只需要知道当前这些子树每一棵属于 $A$ 还是 $B$ 即可：这其实很简单，因为这些子树肯定整体都在 $e$ 的一边，所以随便选取一个代表点，利用 dfn 序判断它在 $e$ 的哪一边即可。

于是，我们单次可以 $O(\log^2n)$ 找到一个区间的关键点的重心。

再离线下来用点分治求出在原树上对应的重心到所有点的距离，可以做到 $O((n+q)\log n)$ 。

从而，我们在 $O(n\log n+q\log^2n)$ 的时间内解决这个问题。

#include<bits/stdc++.h>

#define N 100010
#define ll long long

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<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}

int n,Q;

vector<int> e[N];

namespace P2
{
	struct query{int u,id,coef;};
	vector<query> q[N];
}

namespace P1
{
	#define lc(u) ch[u][0]
	#define rc(u) ch[u][1]
	const int N1=N<<1,N2=N1<<1;
	int n1,cnt=1,head[N1],to[N1<<1],nxt[N1<<1];
	int dfx,fa[N1],in[N1],out[N1],belong[N1];
	void adde(int u,int v)
	{
		to[++cnt]=v,nxt[cnt]=head[u],head[u]=cnt;
		to[++cnt]=u,nxt[cnt]=head[v],head[v]=cnt;
	}
	void D3(int u,int fa)
	{
		vector<int> son;
		for(int v:e[u]) if(v!=fa) son.push_back(v);
		function<int(int,int)> dfs=[&](int l,int r)
		{
			if(l==r) return son[l];
			int mid=(l+r)>>1;
			int x=(l==0&&r==(int)son.size()-1?u:++n1);
			belong[x]=u;
			adde(x,dfs(l,mid)),adde(x,dfs(mid+1,r));
			return x;
		};
		belong[u]=u;
		if(!son.empty())
		{
			if(son.size()==1) adde(u,son[0]);
			else dfs(0,son.size()-1);
		}
		for(int v:son) D3(v,u);
	}
	void dfs(int u)
	{
		in[u]=++dfx;
		for(int i=head[u];i;i=nxt[i])
		{
			int v=to[i];
			if(v==fa[u]) continue;
			fa[v]=u,dfs(v);
		}
		out[u]=dfx;
	}
	int n2,Rt,ch[N2][2],eid[N2];
	int idx,id[N1],L[N2],R[N2];
	int nrt,maxn,nn,size[N1];
	bool vis[N1<<1];
	void getsize(int u,int fa)
	{
		size[u]=1;
		for(int i=head[u];i;i=nxt[i])
		{
			int v=to[i];
			if(v==fa||vis[i]) continue;
			getsize(v,u),size[u]+=size[v];
		}
	}
	void getroot(int u,int fa)
	{
		for(int i=head[u];i;i=nxt[i])
		{
			int v=to[i];
			if(v==fa||vis[i]) continue;
			int x=abs(nn-size[v]-size[v]);
			if(x<maxn) maxn=x,nrt=i;
			getroot(v,u);
		}
	}
	int build(int u)
	{
		getsize(u,0);
		if(size[u]==1)
		{
			id[u]=L[u]=R[u]=++idx;
			return u;
		}
		int x=++n2;
		nn=size[u],maxn=INT_MAX,getroot(u,0);
		eid[x]=nrt,vis[nrt]=vis[nrt^1]=1;
		int a=to[nrt],b=to[nrt^1];
		lc(x)=build(a),rc(x)=build(b);
		L[x]=L[lc(x)],R[x]=R[rc(x)];
		return x;
	}
	int rt[N];
	namespace Seg
	{
		const int NN=10000000;
		int node,ch[NN][2],sum[NN];
		void update(int &u,int lst,int l,int r,int x)
		{
			u=++node,lc(u)=lc(lst),rc(u)=rc(lst),sum[u]=sum[lst]+1;
			if(l==r) return;
			int mid=(l+r)>>1;
			if(x<=mid) update(lc(u),lc(lst),l,mid,x);
			else update(rc(u),rc(lst),mid+1,r,x);
		}
		int query(int u,int l,int r,int ql,int qr)
		{
			if(!u) return 0;
			if(ql<=l&&r<=qr) return sum[u];
			int mid=(l+r)>>1,ans=0;
			if(ql<=mid) ans+=query(lc(u),l,mid,ql,qr);
			if(qr>mid) ans+=query(rc(u),mid+1,r,ql,qr);
			return ans;
		}
		int query(int pl,int pr,int ql,int qr)
		{
			return query(rt[pr],1,n1,ql,qr)-query(rt[pl-1],1,n1,ql,qr);
		}
	}
	struct data{int kp,s;};
	bool judge(int p,int a,int b)
	{
		if(fa[a]==b) return in[a]<=in[p]&&in[p]<=out[a];
		return !(in[b]<=in[p]&&in[p]<=out[b]);
	}
	int query(int u,int pl,int pr,vector<data> c)
	{
		if(u<=n1) return u;
		int a=to[eid[u]],b=to[eid[u]^1];
		int sa=Seg::query(pl,pr,L[lc(u)],R[lc(u)]),ta=0;
		int sb=Seg::query(pl,pr,L[rc(u)],R[rc(u)]),tb=0;
		for(auto now:c) (judge(now.kp,a,b)?ta:tb)+=now.s;
		if(sa+ta>sb+tb)
		{
			c.push_back(data{b,sb});
			return query(lc(u),pl,pr,c);
		}
		else
		{
			c.push_back(data{a,sa});
			return query(rc(u),pl,pr,c);
		}
	}
	void main()
	{
		n1=n,D3(1,0); dfs(1);
		n2=n1,Rt=build(1);
		for(int i=1;i<=n;i++)
			Seg::update(rt[i],rt[i-1],1,n1,id[i]);
		for(int i=1;i<=Q;i++)
		{
			int l=read(),r=read();
			int u=belong[query(Rt,l,r,vector<data>())];
			P2::q[r].push_back(P2::query{u,i,1});
			P2::q[l-1].push_back(P2::query{u,i,-1});
		}
	}
	#undef lc
	#undef rc
}

namespace P2
{
	int fa[N];
	int rt,maxn,nn,size[N];
	bool vis[N];
	vector<int> dis[N];
	void getsize(int u,int fa)
	{
		size[u]=1;
		for(int v:e[u]) if(v!=fa&&!vis[v])
			getsize(v,u),size[u]+=size[v];
	}
	void getroot(int u,int fa)
	{
		int nmax=nn-size[u];
		for(int v:e[u]) if(v!=fa&&!vis[v])
			getroot(v,u),nmax=max(nmax,size[v]);
		if(nmax<maxn) maxn=nmax,rt=u;
	}
	void getdis(int u,int fa,int dis,vector<int> *D)
	{
		D[u].push_back(dis);
		for(int v:e[u]) if(v!=fa&&!vis[v])
			getdis(v,u,dis+1,D);
	}
	void build(int u)
	{
		vis[u]=1;
		getdis(u,0,0,dis);
		for(int v:e[u])
		{
			if(vis[v]) continue;
			getsize(v,0);
			nn=size[v],maxn=INT_MAX,getroot(v,0);
			fa[rt]=u,build(rt);
		}
	}
	struct data
	{
		ll sd; int sz;
		data(){}
		data(ll a,int b){sd=a,sz=b;}
		void operator += (data b){sd+=b.sd,sz+=b.sz;}
		data operator - (data b){return data(sd-b.sd,sz-b.sz);}
		ll calc(int d){return 1ll*d*sz+sd;}
	}s1[N],s2[N];
	ll ans[N];
	void add(int x)
	{
		int u=x;
		s1[u]+=data(0,1);
		for(int i=(int)dis[x].size()-2;i>=0;i--,u=fa[u])
			s1[fa[u]]+=data(dis[x][i],1),s2[u]+=data(dis[x][i],1);
	}
	ll query(int x)
	{
		int u=x;
		ll ans=s1[u].sd;
		for(int i=(int)dis[x].size()-2;i>=0;i--,u=fa[u])
			ans+=(s1[fa[u]]-s2[u]).calc(dis[x][i]);
		return ans;
	}
	void main()
	{
		getsize(1,0);
		nn=size[1],maxn=INT_MAX,getroot(1,0);
		build(rt);
		for(int i=1;i<=n;i++)
		{
			add(i);
			for(auto now:q[i]) ans[now.id]+=now.coef*query(now.u);
		}
		for(int i=1;i<=Q;i++)
			printf("%lld\n",ans[i]);
	}
}

int main()
{
	n=read(),Q=read();
	for(int i=1;i<n;i++)
	{
		int u=read(),v=read();
		e[u].push_back(v),e[v].push_back(u);
	}
	P1::main();
	P2::main();
	return 0;
}

ez_lcw

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【XSY4746】会议选址（三度化，边分治，点分治）

这种关键点的重心问题，一般有两种思路。一种是合并：对于两个不交的点集 S,TS,TS,T，S∪TS\cup TS∪T 的重心必在 S,TS,TS,T 重心间的路径上，二分即可，需要数据结构支持 dfn 区间内 S∪TS\cup TS∪T 内的点的个数。使用该做法能将本题做到 O(nlog⁡3n+qlog⁡n)O(n\log^3n+q\log n)O(nlog3n+qlogn)。另一种想法是，对于单次询问点集 SSS，先从任意一个点开始，考虑往当前最大的子树走，直到最大的子树大小小于等于 S/2S/2S/2。
复制链接

扫一扫