【点分治】的学习笔记和众多例题

最新推荐文章于 2026-03-27 04:16:55 发布
原创 最新推荐文章于 2026-03-27 04:16:55 发布 · 置顶 · 4.6k 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#点分治

【前言】

　　最近一段时间变成了通过题目学习算法，似乎整个人都乱套了（反思ing）

　　不过还好，现在又调整为了学算法后做题。（唉，最近一段时间有点急躁，要记住万事不能速成啊）

【正题】点分治

　　一句话：点分治主要用于树上路径点权统计问题。

一、【具体流程】

1，选取一个点，将无根树变成有根树
　为了使每次的处理最优，我们通常要选取树的重心。
　何为“重心”，就是要保证与此点连接的子树的节点数最大值最小，可以防止被卡。
　重心求法：
　　１。dfs一次，算出以每个点为根的子树大小。
　　２。记录以每个节点为根的最大子树大小
　　３。判断：如果以当前节点为根更优，就更新当前根。

void getroot(int v,int fa)
{
    son[v] = 1; f[v] = 0;//f记录以v为根的最大子树的大小 
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            getroot(e[i].to,v);//递归更新 
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);//比较每个子树 
        }
    f[v] = max(f[v],sum-son[v]);//别忘了以v父节点为根的子树 
    if(f[v] < f[root]) root = v;//更新当前根 
}

2、处理连通块中通过根节点的路径。
　　（注意，是通过根节点的路径，所以后面要去掉同一子树内部的路径，即去重）
3、标记根节点（相当于处理后，将根节点从子树中删除）。
4、递归处理当前点为根的每棵子树。

int solve(int v)
{
    vis[v] = 1;//标记 
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            root = 0;
            sum = son[e[i].to];
            getroot(e[i].to,v);
            solve(root);//递归处理下一个连通块 
        }
}
int main()
{
    sum = f[0] = n;//初始化 
    root = 0;
    getroot(1,0);//找重心 
    solve(root);//点分治 
}

【注释】：作者是用 son[] 来表示节点x为根的子树大小，可能他人更多地是用size[]来表示，二者同意。

二、【POJ 1741 & BZOJ 1468 & BZOJ 3365】

给你一棵TREE,以及这棵树上边的距离.问有多少对点它们两者间的距离小于等于K。
【题解】：
　　我们找到树的重心，然后dfs，求出每个点到root的距离deep，然后对deep排序，扫描哪些点对是符合的。
　　但是，点分治要求处理的路径是经过root，所以如果一条路径是在同一个子树之内的就不符合要求，所以还要对子树dfs一下，然后去重。
　　接下来处理好root后，就可以处理其他连通块了，即递归其子树。
【代码】：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 10010
#define inf 1e9+10
struct node{int to,c,next;}g[N*2];
int head[N],m;
int son[N],f[N];
bool vis[N];
int d[N],deep[N];
int n,sum,root,k,ans;

void add_edge(int from,int to,int cost)
{
    g[++m].next = head[from];
    head[from] = m;
    g[m].to = to; g[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1; f[v] = 0;
    for(int i = head[v];i;i=g[i].next)
        if(g[i].to != fa && !vis[g[i].to])
        {
            getroot(g[i].to,v);
            son[v] += son[g[i].to];
            f[v] = max(f[v],son[g[i].to]);
        }
    f[v] = max(f[v],sum - son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    deep[++deep[0]] = d[v];
    for(int i = head[v];i;i=g[i].next)
        if(g[i].to != fa && !vis[g[i].to])
        {
            d[g[i].to] = d[v] + g[i].c;
            getdeep(g[i].to,v);
        }
}

int cal(int v,int cost)
{
    d[v] = cost; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int l = 1,r = deep[0],sum = 0;
    while(l < r) {
        if(deep[l]+deep[r] <= k) {
            sum += r-l;
            l++;
        } else r--;
    }
    return sum;
}

void solve(int v)
{
    ans += cal(v,0);
    vis[v] = 1;
    for(int i = head[v];i;i=g[i].next)
        if(!vis[g[i].to])
        {
            ans -= cal(g[i].to,g[i].c);
            sum = son[g[i].to];
            root = 0;
            getroot(g[i].to,0);
            solve(root);
        }
}

int main()
{
    int u,v,w;
    while(scanf("%d%d",&n,&k) && n && k)
    {
        ans = root = m = 0;
        memset(vis,0,sizeof(vis));
        memset(head,0,sizeof(head));
        for(int i = 1;i < n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        f[0] = inf;
        sum = n;
        getroot(1,0);
        solve(root);
        printf("%d\n",ans);
    }
    return 0;
}

【补】：若是距离等于k，cal可以改成：

int cal(int v,int cost)
{
    d[v] = cost; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int r = deep[0],res = 0;
    for(int l = 1;l < r;l++)
        while(deep[l]+deep[r] >= k) {
            if(deep[l] + deep[r] == k) res++;
            r--;
        }
    return res;
}

三、【BZOJ 2152】

由爸爸在纸上画n个“点”，并用n-1条“边”把这n个“点”恰好连通（其实这就是一棵树）。并且每条“边”上都有一个数。接下来由聪聪和可可分别随即选一个点（当然他们选点时是看不到这棵树的），如果两个点之间所有边上数的和加起来恰好是3的倍数，则判聪聪赢，否则可可赢。聪聪非常爱思考问题，在每次游戏后都会仔细研究这棵树，希望知道对于这张图自己的获胜概率是多少。现请你帮忙求出这个值以验证聪聪的答案是否正确。
【题解】：
　　感觉这道更好处理，不用快排，也不用去重。我们对于当前的树，直接找到重心V，然后从V出发，搜索与V相邻的点，计算边长的余数分别是是0,1,2的情况数，用t[0],t[1],t[2]分别表示。
　　显然答案就是 t[1]*t[2]*2+t[0]*t[0]。
【代码】：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 20010
struct node{int to,c,next;}e[N*2];
int head[N],m;
int ans,root,t[4],d[N],son[N],f[N],sum;
bool vis[N];

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] = m;
    e[m].to = to; e[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i = e[i].next)
        if(!vis[e[i].to] && e[i].to != fa)
        {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    t[d[v]]++;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to] && e[i].to != fa)
        {
            d[e[i].to] = (d[v] + e[i].c)%3;
            getdeep(e[i].to,v);
        }
}

int cal(int v,int w)
{
    t[0] = t[1] = t[2] = 0;
    d[v] = w;
    getdeep(v,0);
    return t[1]*t[2]*2+t[0]*t[0];
}

void solve(int v)
{
    ans += cal(v,0); vis[v] = 1;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to])
        {
            ans -= cal(e[i].to,e[i].c);
            root = 0; sum = son[e[i].to];
            getroot(e[i].to,0);
            solve(root);
        }
}

inline int gcd(int a,int b){return b == 0 ? a : gcd(b,a%b);}
int main()
{
    int n,u,v,w;
    scanf("%d",&n);
    for(int i = 1;i < n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        w %= 3;
        add_edge(u,v,w); add_edge(v,u,w);
    }
    sum = n;f[0] = n;
    root = ans = 0;
    getroot(1,0);
    solve(root);
    int x = gcd(ans,n*n);
    printf("%d/%d\n",ans/x,n*n/x);
    return 0;
}

先到这里，我下去逛逛。未完待续……

好了，我又回来了

四、【BZOJ 2599】

给一棵树,每条边有权.求一条简单路径,权值和等于K,且边的数量最小.N <= 200000, K <= 1000000
【题解】：
参考黄学长的题解啊。
　　开一个100W的数组t,t[i]表示权值为i的路径最少边数
　　找到重心分成若干子树后， 得出一棵子树的所有点到根的权值和x，到根a条边，用t[k-x]+a更新答案，全部查询完后，再用所有a更新t[x]，这样可以保证不出现点分治中的不合法情况。
　　把一棵树的所有子树搞完后再遍历所有子树恢复T数组，如果用memset应该会比较慢
　　
看的稀里糊涂的，但还是好像懂了一点啊。
　　d数组 表示已经有几条边
　　dis数组 表示子树中的点到根的距离
　　add函数用于更新和初始化（好像有这个功能吧）
【代码】：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 200010
#define inf 1000000000
struct node{int to,c,next;}e[N*2];
int head[N],m,k;
bool vis[N];
int t[1000010];
int sum,f[N],dis[N],d[N],son[N],root,ans;

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] = m;
    e[m].to = to;e[m].c = cost;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void cal(int v,int fa)
{
    if(dis[v] <= k) ans = min(ans,d[v]+t[k-dis[v]]);
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            d[e[i].to] = d[v] + 1;
            dis[e[i].to] = dis[v] + e[i].c;
            cal(e[i].to,v);
        }
}

void add(int v,int fa,bool flag)
{
    if(dis[v] <= k) {
        if(flag) t[dis[v]] = min(t[dis[v]],d[v]);
        else t[dis[v]] = inf;
    }
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to])
            add(e[i].to,v,flag);
}

void solve(int v)
{
    vis[v] = 1;t[0] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            d[e[i].to] = 1;
            dis[e[i].to] = e[i].c;
            cal(e[i].to,0);
            add(e[i].to,0,1);
        }
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) add(e[i].to,0,0);
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            root = 0;
            sum = son[e[i].to];
            getroot(e[i].to,0);
            solve(root);
        }
}

int main()
{
    int n,u,v,w;;
    scanf("%d%d",&n,&k);
    for(int i = 1;i <= k;i++) t[i] = n;
    for(int i = 1;i < n;i++) {
        scanf("%d%d%d",&u,&v,&w);
        u++; v++;
        add_edge(u,v,w); add_edge(v,u,w);
    }
    ans = sum = f[0] = n;
    root = 0;
    getroot(1,0);
    solve(root);
    if(ans != n) printf("%d\n",ans);
        else puts("-1");
    return 0;
}

啊！
今天对点分治的学习差不多就到这里了。
笔记结束，开始刷水题玩喽。

补：

五、【BZOJ 1316】

一棵n个点的带权有根树，有p个询问，每次询问树中是否存在一条长度为Len的路径，如果是，输出Yes否输出No.
【题解】：
　　运用点分治统计点到重心的距离，再两次二分查找距离，判断有多少条路径长度为k（这样为了方便去重）。
　　听说点分治的常数比较大，所以将所有询问在一次点分治中一起做。
【代码】：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 10010
struct node{int to,w,next;}e[N*2];
int head[N],m,p;
int q[110],f[N],son[N],sum,root,d[N],deep[N];
bool vis[N];

void add_edge(int from,int to,int cost)
{
    e[++m].next = head[from];
    head[from] =m;
    e[m].w = cost; e[m].to = to;
}

void getroot(int v,int fa)
{
    son[v] = 1;f[v] = 0;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to] && e[i].to != fa) {
            getroot(e[i].to,v);
            son[v] += son[e[i].to];
            f[v] = max(f[v],son[e[i].to]);
        }
    f[v] = max(f[v],sum-son[v]);
    if(f[v] < f[root]) root = v;
}

void getdeep(int v,int fa)
{
    deep[++deep[0]] = d[v];
    for(int i = head[v];i;i=e[i].next)
        if(e[i].to != fa && !vis[e[i].to]) {
            d[e[i].to] = d[v] + e[i].w;
            getdeep(e[i].to,v);
        }
}

int findl(int L,int R,int k)
{
    int ans = 0;
    while(L <= R){
        int mid = (L+R)>>1;
        if(deep[mid] == k){ans = mid;R = mid-1;}
        else if(deep[mid] < k) L = mid + 1;
                else R = mid - 1;
    }
    return ans;
}

int findr(int L,int R,int k)
{
    int ans = -1;
    while(L <= R) {
        int mid = (L+R)>>1;
        if(deep[mid] == k){ans = mid;L = mid+1;}
        else if(deep[mid] < k) L = mid+1;
                else R = mid - 1;
    }
    return ans;
}

int cal(int v,int now,int k)
{
    d[v] = now; deep[0] = 0;
    getdeep(v,0);
    sort(deep+1,deep+deep[0]+1);
    int t = 0;
    for(int i = 1;i <= deep[0];i++) {
        if(deep[i] + deep[i] > k) break;
        int l = findl(i,deep[0],k-deep[i]);
        int r = findr(i,deep[0],k-deep[i]);
        t += r-l+1;
    }
    return t;
}

int ans[110];
void solve(int v)
{
    for(int i = 1;i <= p;i++) ans[i] += cal(v,0,q[i]);
    vis[v] = 1;
    for(int i = head[v];i;i=e[i].next)
        if(!vis[e[i].to]) {
            for(int j = 1;j <= p;j++)
                ans[j] -= cal(e[i].to,e[i].w,q[j]);
            sum = son[e[i].to];
            root = 0;
            getroot(e[i].to,0);
            solve(root);
        }
}

int main()
{
    int n,u,v,w;
    scanf("%d%d",&n,&p);
    m = 0;
    for(int i = 1;i < n;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w); add_edge(v,u,w);
    }
    for(int i = 1;i <= p;i++) scanf("%d",&q[i]);
    sum = f[0] = n;
    root = 0;
    getroot(1,0);
    solve(root);
    for(int i = 1;i <= p;i++)
        if(ans[i]) puts("Yes"); else puts("No");
    return 0;
}

吾 点分治 之道路大概结束于此。

PS：4月3日，第四次更新。

点分治详解 ( 数据结构 )
qq_62539009的博客
04-27 4028
啦啦啦，更新啦~ 学习笔记： 前置知识：树的重心、线段树等类似数据结构。 点分治是一种十分高效的树上路径查询的数据结构，能在复杂度内查询所有路径信息。 它与线段树和分块的思想十分相似，用已求出的信息来帮助处理之后需要求的信息。 那么在树上呢，我们就可以先dfs一遍，然后用求出的dis信息来求解路径信息。 那么我们把所有的路径分为两种：经过当前根节点的和不经过当前根节点的。后者可以递归根节点转化为前者。 具体语境下求的东西不一样，这里介绍模板中距离小于k和等于k的做法。 算法流程： ...
数据结构——点分治
weixin_55851276的博客
06-03 1166
点分治即是在使用以更高效的求解类问题。基本的时间复杂度为Onlogn​。对于一棵已经的树， 那么所有的路径即分为两类:。对于这些 不经过根 的路径， 显然 是在当前树的子树中， 我们需要做的只是。
3DGS不止于重建：手把手教你用GaussianEditor实现物体移除与场景编辑（附代码）
最新发布
weixin_30555125的博客
03-27 412
本文详细介绍了如何利用3D高斯泼溅（3DGS）技术和GaussianEditor工具实现3D场景中的物体移除与实时编辑。通过显式表示的高斯椭球体，用户可以像操作2D图像一样直观地修改3D场景，大幅提升游戏开发和数字艺术创作的工作效率。文章包含完整的代码示例和实战教程，特别适合需要快速迭代3D场景的开发者。
点分治 & 点分树 学习笔记
RabbieWjy的博客
05-01 437
至此，我们已经了解了这道题中的点分治做法，可以归纳成下面几步：找重心，作为根；树形 dp+ 双指针求解每个询问；递归求解每个子树。而点分治的大多数问题，只是把第222步改一改，总体思路都是一样的。
点分治详细解析
热门推荐
Guess_Ha的博客
08-24 2万+
点分治，是处理树上路径的一个极好的工具。 一般如果需要大规模处理树上路径，点分治是一个不错的选择。 这里我就来讲一讲我自己对于点分治的一点理解和感悟（帮助新手入坑……） 现在就开始吧！1.点分治的基本思想 点分治，顾名思义就是基于树上的节点进行分治。 如果我们在深入一点呢？对于点的拆开其实就是对于树的拆开。 所以我认为点分治的本质其实是将一棵树拆分成许多棵子树处理，并不断进行。 这应该
数据结构——点分治（树分治）总结
x052xiao的博客
07-14 496
点分治总结
点分治学习/模板（5道例题）
平凡人Kalzn的博客
10-01 837
感谢b站up大佬：不分解的AgOH。 点分治用于树上的大规模路径操作、统计。它的灵活性高，适用范围广。很多树形dp也可以用点分治搞。其实，树分治中，还有一个边分治，不过没有点分治常用。 基本步骤： 第一步 找树的重心。我们重心为根节点，然后按题目的不同情况统计树各个点到根节点的路径信息。 第二步 递归至每一个子树，重复第一步，直到分割至叶子节点。 非常简洁。 下面看一看具体的实现： 找重心函数： ...
点分治模板
Maxwell_Newton的博客
03-01 1279
点分治的关键是：经过的根节点的我们可以树形dp求一下，一般就是dp求一下到根节点的距离为x的点数，然后处理一下。那么应该选重心作为子树的根，这样每个子树的大小都不会超过原树的一半，也就是子树大小会以折半的方式减小，这类似二分的思想，最多递归。所以我们可以处理完一个根节点的情况后，对各个子树再找一个点为根节点，继续处理。点分治一般用来处理树上路径问题，其实思想并不难理解，树型dp做多应该或多或少接触过：我们问树上某种路径的条数，那我们可以确定一个根节点，然后把所有路径分为经过这个根节点的，和不经过的。
点分治学习笔记
llmmkk的尘歌壶
06-03 190
点分治： 前言： 我太菜了。 前置需要： 分治思想 树的重心 心 用途： 点分治用于静态树上统计路径一类的问题。 如查询边带边权的树上是否存在长度为 kkk 的点对等。 算法： 由于只有统计路径的操作，所以这棵树的根是任意取的，先假设树根为1。 那么对于所有路径，只有 经过树根。（图中红色） 不经过树根。（图中蓝色） 对于情况1，我们当然可以从根遍历整棵树，从而根据每个节点到根的距离等数据得出1的答案。 对于情况2，发现不经过树根的路径必然在根节点的某一棵子树内，所以可以递归树根的每一
数据结构：点分治学习笔记
m0_72410588的博客
05-10 622
点分治（Point Divide and Conquer）是一种基于分治思想的算法，能够有效地解决与树相关的复杂问题。本文将为大家介绍点分治算法的基本概念、实现方法、时间复杂度和应用场景，并给出相应的示例代码。
点分治解析
梅子酒的博客
08-31 662
点分治详解 初学者写了两篇模板题后略有心得，故写此篇博客帮助和我一样的初学者理解，本博客会结合两道模板题来进行解释点分治。若有错误的理解和解释希望大佬们指出。 点分治，是处理树上路径的一个极好的工具。 一般如果需要大规模处理树上路径，点分治是一个不错的选择。 一.点分治的基本思想 点分治，顾名思义就是基于树上的节点进行拆分。对于点的拆开其实就是对于树的拆开。所以我认为点分治的本质其实是将一棵树拆分成许多棵子树处理，并不断进行。这应该也是点分治的精髓。 对于树上路径而言，所有路径都可以由两个点的最近路径来表示
点分治(树分治)详解
yyh_getAC的博客
09-07 1579
点分治，又叫树分治，顾名思义，点分治就是在树上进行分治并统计答案的一种方式。此前我们就有涉及过分治的思想：将原问题分解成若干相同形式、相互独立的子问题，并逐个干掉。
树结构算法精讲：点分治原理
xiaoyu❅的博客
03-19 1253
点分治（Vertex Divide and Conquer）是处理树上路径问题的经典分治算法，主要解决以下类型问题：统计满足特定条件的路径数量（如路径长度等于K）查找树中最长合法路径检测特定路径特征（如包含特定颜色节点）时间复杂度优异：O(NlogN)处理大多数路径问题适用性强：可扩展处理各种路径统计问题代码模式统一：相似结构可套用解决不同问题LeetCode 437（路径总和III）
【数据结构】点分治
SY奇星的OI博客
10-06 498
点分治（Centroid Decomposition）是一种树分治的技术，主要用于解决树上路径问题。在树结构中，点分治的目标是将原树分解为若干棵子树，使得每个子树的大小都不超过原树大小的一半。这样的分解可以有效地减小问题的规模，从而提高算法的效率。点分治的基本思想是选择一个合适的树节点作为"重心"（Centroid），然后以该节点为根进行递归处理。选取重心的方法是找到使得删除该节点后最大子树的大小最小的节点，这样可以保证分解后的子树规模较为平衡。
点分治 学习笔记
qq_14886903的博客
08-11 362
0. 点分治的用途 点分治可以解决树上的关于路径的问题，例如 洛谷P4178 Tree。(题目大意：给定一棵 \(n\) 个节点的树，每条边有边权，求出树上两点距离小于等于 \(k\) 的点对数量)这道题如果使用 \(O(n^2)\) 的暴力算法 显然 会T飞 ，然而之后您就会看到，点分治算法可以在 \(O(n\log^2 n)\) 的时间复杂度内解决它。 1.思想 顾名思义，点分治使用了分治的...
点分治（树分治）
2301_80402575的博客
09-10 790
d[to]=val;for(auto [to,val] : mp[u]) // 遍历当前节点的所有邻居。for(auto [to,val] : mp[u]) // 遍历当前节点的所有邻居。for(auto [to,val] : mp[u]) // 遍历重心的所有邻居子树。for(auto [to,val] : mp[u]) // 遍历当前重心的所有邻居。
点分治详解
aiweiluan5095的博客
06-29 520
点分治详解 点分治是一个需要自己推导的算法，但是有板子，但是Cal这个函数根据不同题目是会变的。 点分治是解决树上求值的一种算法，比如说一棵树上路径距离(u,v)距离<=K距离(u,v)距离<=K的点对数量。 我们首先思考最笨的想法： 我们可以先求出所以路径长度，然后减去不满足的路径长度(也就是最近公共祖先不是跟的路径长度)。 DF...
点分治 (Centroid Decomposition)
lifallen的博客
02-17 1067
本文介绍了点分治（Centroid Decomposition）算法及其应用。点分治通过递归选择树的重心（使删除后最大连通块不超过原大小一半的点），将树分解为规模减半的子问题。重点包括：重心存在性证明、点分治过程（计算子树大小、寻找重心、递归处理子块）以及O(n log n)复杂度的推导。文章以Codeforces 321C为例，展示了如何利用重心分解树深度给节点标记字母，并提供了Java实现代码。最后介绍了动态维护最近红点距离的问题（Codeforces 342E），通过维护重心祖先链上的最优解来高效处理
算法笔记——点分治
m0_67142204的博客
07-27 498
点分治
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值