本文详细介绍了点分治算法的基本思想及其在解决特定树形结构问题中的应用，通过实例讲解了如何利用点分治求解树上两点间距离小于等于K的点对数量。
我们直接引入这样问题
给你一棵TREE（n<=40000），以及这棵树上边的距离.问有多少对点它们两者间的距离小于等于K
(来自Tree的问题描述)
看到数据范围就知道这肯定是不能暴力的了
n^2的枚举加路径长度计算，都不知道被人家甩了几条街
所以我们便有了优雅的暴力—点分治
我们先随意指定一个根rt，将这棵树转化成有根树
不难发现树上的路径分为两类，
经过根节点rt的路径和包含于rt的某棵子树里(不经过rt)的
对于前者，
我们用
d
i
s
[
u
]
dis[u]
dis[u]表示结点
u
u
u到根节点
r
t
rt
rt的路径长度，
则u到v的路径长即为
d
i
s
[
u
]
+
d
i
s
[
v
]
dis[u]+dis[v]
dis[u]+dis[v]
对于后者，
既然
u
u
u到
v
v
v的路径包含在
r
t
rt
rt的某个子树内，
那么我们就找到这棵子树的根，再对他求一次第一类路径
这样分治的思想就很明显了
就是把原来的树分成很多小的子树，并对每个子树分别求解第一类路径
点分治过程中，每一层的所有递归过程合计对每个点处理一次
假设共递归T层，则总时间复杂度为
O
(
T
∗
N
)
O(T*N)
O(T∗N)
然而，如果树退化成一条链
那么递归层数就是
T
=
n
T=n
T=n，总时间复杂度为
O
(
N
2
)
O(N^2)
O(N2)
这样显然不能承受，所以我们要让树的层数经量少
这里就要找树的重心
maxp[u] (max_part的简写)表示删除结点u后产生的子树中，最大的那棵的大小
则树的重心就是maxp[]值最小的那个节点
//sum是当前子树的总结点数，size[u]是以u为根的子树大小
void getrt(int u,int fa)
{
size[u]=1; maxp[u]=0;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==fa||vis[v])continue;
getrt(v,u);//先递归得到子树大小
size[u]+=size[v];
maxp[u]=max(maxp[u],size[v]);//更新u结点的maxp
}
maxp[u]=max(maxp[u],sum-size[u]);
if(maxp[u]<maxp[rt]) rt=u;//更新当前子树的重心
}
我们在点分治过程中每次选取子树的重心为子树的树根进行处理
这样总的递归深度不会超过
l
o
g
N
logN
logN层
整个点分治的时间复杂度也就保证了
O
(
N
l
o
g
N
)
O(NlogN)
O(NlogN)
点分治题的思想大都如上
对于不同的题要设计不同的calc函数
接下来直接进入例题
洛谷P3806 【模板】点分治1
给定一棵有n个点的树
询问树上距离为k的点对是否存在。
n<=10000,m<=100,c<=1000,K<=10000000
分析
回到本题，询问可以离线记录并直接在分治过程中处理
设当前根为
r
t
rt
rt，他的子树为
v
1
,
v
2
…
…
v
t
v_1,v_2……v_t
v1,v2……vt，
假设当前处理的子树为
v
i
v_i
vi，求出
v
i
v_i
vi中每个结点到
r
t
rt
rt的距离
d
i
s
dis
dis并保存于
r
e
m
rem
rem数组
并令
j
u
d
g
e
[
d
i
s
]
judge[dis]
judge[dis]表示在子树
v
1
v_1
v1~
v
i
−
1
v_{i-1}
vi−1中是否存在某个节点到
r
t
rt
rt距离为
d
i
s
dis
dis
遍历每个离线记录的询问，对每个询问遍历一次当前子树的
r
e
m
rem
rem
若当前询问距离为
q
u
e
r
y
[
k
]
query[k]
query[k]，遍历到的子树
v
i
v_i
vi中某个结点到
r
t
rt
rt距离为
r
e
m
[
j
]
rem[j]
rem[j]
如果
j
u
d
g
e
[
q
u
e
r
y
[
k
]
−
r
e
m
[
j
]
]
=
=
1
judge[query[k]-rem[j]]==1
judge[query[k]−rem[j]]==1，则代表此询问的路径存在
再具体点解释这段话操作的含义
就是用子树
v
i
v_i
vi中某个结点与子树
v
1
v_1
v1~
v
i
−
1
v_{i-1}
vi−1中某个节点两两配对，检查是否存在长度为
q
u
e
r
y
[
k
]
query[k]
query[k]的路径
像这样配对完后将这棵子树的 r e m rem rem(即子树 v i v_i vi中每个节点到 r t rt rt的 d i s dis dis)一起保存进 j u d g e judge judge数组，继续下一个子树 v i + 1 v_{i+1} vi+1的处理
当以rt为根的树查询完后清空judge数组
然后对其他子树进行分治
//niiick
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
return f*x;
}
const int inf=10000000;
const int maxn=100010;
int n,m;
struct node{int v,dis,nxt;}E[maxn<<1];
int tot,head[maxn];
int maxp[maxn],size[maxn],dis[maxn],rem[maxn];
int vis[maxn],test[inf],judge[inf],q[maxn];
int query[1010];
int sum,rt;
int ans;
void add(int u,int v,int dis)
{
E[++tot].nxt=head[u];
E[tot].v=v;
E[tot].dis=dis;
head[u]=tot;
}
void getrt(int u,int pa)
{
size[u]=1; maxp[u]=0;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==pa||vis[v]) continue;
getrt(v,u);
size[u]+=size[v];
maxp[u]=max(maxp[u],size[v]);
}
maxp[u]=max(maxp[u],sum-size[u]);
if(maxp[u]<maxp[rt]) rt=u;
}
void getdis(int u,int fa)
{
rem[++rem[0]]=dis[u];
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==fa||vis[v])continue;
dis[v]=dis[u]+E[i].dis;
getdis(v,u);
}
}
void calc(int u)
{
int p=0;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(vis[v])continue;
rem[0]=0; dis[v]=E[i].dis;
getdis(v,u);//处理u的每个子树的dis
for(int j=rem[0];j;--j)//遍历当前子树的dis
for(int k=1;k<=m;++k)//遍历每个询问
if(query[k]>=rem[j])
test[k]|=judge[query[k]-rem[j]];
//如果query[k]-rem[j]d的路径存在就标记第k个询问
for(int j=rem[0];j;--j)//保存出现过的dis于judge
q[++p]=rem[j],judge[rem[j]]=1;
}
for(int i=1;i<=p;++i)//处理完这个子树就清空judge
judge[q[i]]=0;//特别注意一定不要用memeset，会T
}
void solve(int u)
{
//judge[i]表示到根距离为i的路径是否存在
vis[u]=judge[0]=1; calc(u);//处理以u为根的子树
for(int i=head[u];i;i=E[i].nxt)//对每个子树进行分治
{
int v=E[i].v;
if(vis[v])continue;
sum=size[v]; maxp[rt=0]=inf;
getrt(v,0); solve(rt);//在子树中找重心并递归处理
}
}
int main()
{
n=read();m=read();
for(int i=1;i<n;++i)
{
int u=read(),v=read(),dis=read();
add(u,v,dis);add(v,u,dis);
}
for(int i=1;i<=m;++i)
query[i]=read();//先记录每个询问以离线处理
maxp[rt]=sum=n;//第一次先找整棵树的重心
getrt(1,0);
solve(rt);//对树进行点分治
for(int i=1;i<=m;++i)
{
if(test[i]) printf("AYE\n");
else printf("NAY\n");
}
return 0;
}
POJ - 1741 Tree
楼教主男人八题之一
给定一棵N个节点的树，树上边有边权，求有多少点对
(
u
,
v
)
(u,v)
(u,v)最短距离小于等于K
（n<=10000多组询问）
分析：
这题数据范围大了很多，不能像上面那题那样直接每个暴力配对
设当前子树树根为rt
先求出这棵子树所有孩子到rt的dis
然后将这些dis 从小到大排序
维护两个指针
l
l
ll
ll和
r
r
rr
rr，分别从头和从尾扫描所有dis
不难发现，若
d
i
s
[
l
l
]
+
d
i
s
[
r
r
]
<
=
k
dis[ll]+dis[rr]<=k
dis[ll]+dis[rr]<=k
那么对于所有
l
l
<
i
<
=
r
r
ll < i <=rr
ll<i<=rr 都有
d
i
s
[
l
l
]
+
d
i
s
[
i
]
<
=
k
dis[ll]+dis[i]<=k
dis[ll]+dis[i]<=k
所以直接
a
n
s
+
=
r
r
−
l
l
ans+=rr-ll
ans+=rr−ll再移动左指针
l
l
+
+
ll++
ll++
否则直接移动右指针
r
r
−
−
rr- -
rr−−
这里利用了单调性思想
特别的这样配对完后
我们发现没有经过rt的路径也统计了
所以要让ans减去rt的所有儿子为根的子树的按上述求出的路径总数
这里利用了容斥思想
最后最所有子树进行上述calc过程即可
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
int read()
{
int f=1,x=0;
char ss=getchar();
while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
return f*x;
}
const int inf=10000010;
const int maxn=200010;
int n,k;
struct node{int v,dis,nxt;}E[maxn<<1];
int tot,head[maxn];
int maxp[maxn],size[maxn],dis[maxn],rem[maxn];
int vis[maxn],q[maxn];
int num[inf];
int sum,rt,ans;
void add(int u,int v,int dis)
{
E[++tot].nxt=head[u];
E[tot].v=v;
E[tot].dis=dis;
head[u]=tot;
}
void getrt(int u,int pa)
{
size[u]=1; maxp[u]=0;
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==pa||vis[v]) continue;
getrt(v,u);
size[u]+=size[v];
maxp[u]=max(maxp[u],size[v]);
}
maxp[u]=max(maxp[u],sum-size[u]);
if(maxp[u]<maxp[rt]) rt=u;
}
void getdis(int u,int fa)
{
rem[++rem[0]]=dis[u];
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(v==fa||vis[v])continue;
dis[v]=dis[u]+E[i].dis;
getdis(v,u);
}
}
int calc(int u,int len)
{
dis[u]=len; rem[0]=0;
getdis(u,0);
sort(rem+1,rem+rem[0]+1);
int ll=1,rr=rem[0],cnt=0;
while(ll<rr)
{
if(rem[ll]+rem[rr]<=k) cnt+=rr-ll,ll++;
else rr--;
}
return cnt;
}
void solve(int u)
{
vis[u]=1; ans+=calc(u,0);
for(int i=head[u];i;i=E[i].nxt)
{
int v=E[i].v;
if(vis[v])continue;
ans-=calc(v,E[i].dis);
sum=size[v]; maxp[rt=0]=inf;
getrt(v,0); solve(rt);
}
}
void init()
{
memset(vis,0,sizeof(vis)); ans=0;
memset(head,0,sizeof(head)); tot=0;
}
int main()
{
while(scanf("%d%d",&n,&k)!=EOF)
{
if(n==0&&k==0) break; init();
for(int i=1;i<n;++i)
{
int u=read(),v=read(),dis=read();
add(u,v,dis);add(v,u,dis);
}
maxp[rt=0]=sum=n;
getrt(1,0); solve(rt);
printf("%d\n",ans);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
