点分治——学习笔记

最新推荐文章于 2021-08-19 23:25:50 发布
最新推荐文章于 2021-08-19 23:25:50 发布
阅读量143 收藏
点赞数
分类专栏： 学习计划 点分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zenith_Habitant/article/details/109801059
版权

点分治

  • 点分治基础框架（常用于树上路径问题）
    1. 找1个合适的分治中心rt
    2. 统计答案ans += solve(T,rt)
    3. 对所有rt的子节点v，递归调用work(v)
int work(u){//统计sub(u)中的合法路径
    rt = find_rt();//找重心
    ans = solve(rt);
    for v∈son[rt]:
        ans += work(v)
    return ans;
}
  • 模板例题：

一.

  • 题目链接： https://www.luogu.com.cn/problem/P4178
  • 解题思路： 本题很常见的套路题，以每个点为LCA求出经过该点并且距离小于等于 K K K的数量，然后再加上一每个点为根距离小于等于 K K K的数量就是最终结果。然后利用点分治框架将时间复杂度降低为 O ( N ) O(N) O(N)

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 5e4 + 5;
ll ans = 0;
int n, head[N], cnt, k;
struct BIT
{
    int tree[1000005] , ed = 4e5 + 5;
    void init()
    {
        mem(tree,0) ;
    }
    int lowbit(int k)
    {
        return k & -k;
    }
    void add(int x , int k)
    {
        while(x <= ed)
        {
            tree[x] += k ;
            x += lowbit(x) ;
        }
    }
    int sum(int x)
    {
        int ans = 0 ;
        while(x != 0)
        {
            ans += tree[x] ;
            x -= lowbit(x) ;
        }
        return ans ;
    }
    int query(int l , int r)
    {
        return sum(r) - sum(l - 1) ;
    }
} bit ;
struct node {
    int t, next, w;
}edge[N << 1];
void add (int f, int t, int w)
{
    edge[cnt].w = w;
    edge[cnt].t = t;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
int rt, siz[N], vis[N];
int dis[N], tot;
void dfs_rt (int u , int fa, int s)
{
    siz[u] = 1;
    int RtCnt = 0;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa && !vis[v])
        {
            dfs_rt(v, u, s);
            siz[u] += siz[v];
            RtCnt = max (RtCnt, siz[v]);
        }
    }
    RtCnt = max (RtCnt, s - siz[u]);
    if (2 * RtCnt <= s) rt = u;
}
void dfs1 (int u , int fa)
{
    ++tot;
    if (dis[u] <= k)
    {
        ans ++;
        ans += bit.sum (max(0,k - dis[u]));
    }
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t, w = edge[i].w;
        if (v != fa && !vis[v])
        {
            dis[v] = dis[u] + w;
            dfs1 (v, u);
        }
    }
}
void dfs2 (int u, int fa, int p)
{
    if (dis[u] != 0)
        bit.add (dis[u],p);
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa && !vis[v])
            dfs2 (v, u, p);
    }
}
void solve (int u)
{
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t , w = edge[i].w;
        if (!vis[v])
        {
            tot = 0;
            dis[v] = w;
            dfs1 (v, u);
            siz[v] = tot;
            dfs2 (v, u , 1);
        }
    }
    dfs2 (u, 0 , -1);
}
void work (int u , int fa, int s)
{
    dfs_rt (u , fa, s);
    int now = rt;
    dis[now] = 0;
    vis[now] = 1;
    solve (now);
    for (int i = head[now] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (!vis[v])
            work (v, now, siz[v]);
    }
}
int main()
{
    mem (head, -1);
    bit.init();
    read (n);
    for (int i = 1 ; i < n ; i ++)
    {
        int u , v, w;
        read (u, v, w);
        add (u, v, w);
        add (v, u, w);
    }
    read (k);
    work (1, 1, n);
    write (ans), LF;
}

二.

  • 题目链接： https://www.luogu.com.cn/problem/P4149
  • 解题思路： 本题和上一题类似，记录一下深度即可

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 2e5 + 5;
int ans = INF;
int n, head[N], cnt, k;
struct node {
    int t, next, w;
}edge[N << 1];
void add (int f, int t, int w)
{
    edge[cnt].w = w;
    edge[cnt].t = t;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
int t[2000000];
int rt, siz[N], vis[N];
ll dis[N];
int tot, dep[N];
void dfs_rt (int u , int fa, int s)
{
    siz[u] = 1;
    int rtCnt = 0;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa && !vis[v])
        {
            dfs_rt (v, u , s);
            siz[u] += siz[v];
            rtCnt = max (rtCnt, siz[v]);
        }
    }
    rtCnt = max (rtCnt , s - siz[u]);
    if (2 * rtCnt <= s) rt = u;
}
void dfs1 (int u , int fa)
{
    ++ tot;
    if (k>= dis[u]) {
        ans = min(ans,t[k-dis[u]] + dep[u]);
    }
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t , w = edge[i].w;
        if (!vis[v] && v != fa)
        {
            dep[v] = dep[u] + 1;
            dis[v] = dis[u] + w;
            dfs1 (v, u);
        }
    }
}
void dfs2 (int u , int fa, int p)
{
    if (dis[u] <= k)
    {
        if (p == 1)
            t[dis[u]] = min (t[dis[u]], dep[u]);
        else
            t[dis[u]] = INF;
    }
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (!vis[v] && v != fa)
            dfs2 (v, u, p);
    }
}
void solve (int u)
{
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t , w = edge[i].w;
        if (!vis[v])
        {
            tot = 0;
            dep[v] = 1;
            dis[v] = w;
            dfs1 (v, u);
            siz[v] = tot;
            dfs2 (v, u, 1);
        }
    }
    dfs2 (u, 0 , -1);
}
void work (int u , int fa, int s)
{
    dfs_rt (u , fa, s);
    int now = rt;
    vis[now] = 1;
    dis[now] = 0;
    solve (now);
    for (int i = head[now] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (!vis[v])
            work (v, now, siz[v]);
    }
}
int main()
{
    mem (head, -1);
    mem (t, INF);
    t[0] = 0;
    read (n, k);
    for (int i = 1 ; i < n ; i ++)
    {
        int u , v, w;
        read (u, v, w);
        add (u + 1, v + 1, w);
        add (v + 1, u + 1, w);
    }
    work (1, 1, n);
    if (ans == INF) ans = -1;
    write (ans), LF;
}

三.

  • 题目链接： https://www.luogu.com.cn/problem/P2634
  • 解题思路： 统计一下路径中0，1，2的数量即可，框架不变，注意 d f s 2 dfs2 dfs2函数哪些点该加该减

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)
#define sz(a) (int)a.size()
#define pii pair <int,int>
template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}

const int N = 100005;
int n, head[N], cnt, ans;
struct node {
    int t, w, next;
}edge[N << 1];
void add (int f, int t, int w)
{
    edge[cnt].t = t;
    edge[cnt].w = w;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
int vis[N], dis[N], siz[N], rt, tot;
int t[10];
void dfs_rt (int u ,int fa, int s)
{
    siz[u] = 1;
    int rtCnt = 0;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa && !vis[v])
        {
            dfs_rt(v, u, s);
            siz[u] += siz[v];
            rtCnt = max (rtCnt , siz[v]);
        }
    }
    rtCnt = max (rtCnt, s - siz[u]);
    if (rtCnt * 2 <= s) rt = u;
}
void dfs1 (int u , int fa)
{
    ++ tot;
    if (dis[u] == 0)
        ans += 1, ans += t[0];
    ans += t[3-dis[u]];

    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t, w = edge[i].w;
        if (v != fa && !vis[v])
        {
            dis[v] = (dis[u] + w)%3;
            dfs1 (v, u);
        }
    }
}
void dfs2 (int u, int fa, int p)
{
    if (fa != -1)
        t[dis[u]] += p;
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (v != fa && !vis[v])
            dfs2 (v, u, p);
    }
}
void solve (int u)
{
    for (int i = head[u] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t , w = edge[i].w;
        if (!vis[v])
        {
            tot = 0;
            dis[v] = w % 3;
            dfs1 (v, u);
            siz[v] = tot;
            dfs2 (v, u, 1);
        }
    }
    dfs2 (u, -1 , -1);
}
void work (int u , int fa, int s)
{
    dfs_rt (u , fa, s);
    int now = rt;
    vis[now] = 1;
    dis[now] = 0;
    solve (now);
    for (int i = head[now] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if (!vis[v])
            work (v, now , siz[v]);
    }
}
int main()
{
    mem (head, -1);
    read (n);
    for (int i = 1 ; i < n ; i ++)
    {
        int u , v,  w;
        read (u, v , w);
        add (u, v, w);
        add (v, u, w);
    }
    work (1, 1, n);
    //cout << ans << endl;
    ans *= 2;
    ans += n;
    int p = gcd (ans,n*n);
    printf ("%d/%d",ans/p,n*n/p);

}
卡常带师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Java数据结构和算法》学习笔记(5)——递归 归并排序
03-14
在本篇《Java数据结构和算法》学习笔记中，我们将深入探讨递归和归并排序。递归是一种强大的编程技术，常用于解决复杂问题，而归并排序则是利用递归实现的一种高效排序算法。 首先，让我们理解什么是递归。递归是...
卡常技巧
Freopen的博客
09-16 1925
大佬博客 非算法向的卡常技巧在上面。。。。。。 但是这些都没有什么用，只有他出什么高维DFT什么的范围还很好卡Cache的时候循环展开才能卡10倍左右的小常数。 ZZQ巨佬表示：什么卡常都比不上输入输出优化效果好 但是输入输出的卡常在不同电脑不同操作系统乃至不同评测软件效果都不一样，很容易发生本机卡过了（并且什么5s的代码加一个输入挂卡进1s表示经常发生），让人以为主程序的效率十分高，只是输入慢，...
2018.10.26【校内模拟】图（点分治（被卡常））（权值线段树合并（完爆标算））
zxyoi_dreamer的博客（不定期诈尸）
10-26 206
传送门 解析： 考场上写完T1T1T1后，本来说睡一会起来写T2T2T2，结果刚趴下五分钟就想出了点分治写法，一发过了大样例。结果最后卡常只剩80分。。。 结果标程是KruskalKruskalKruskal重构树上离线树状数组。。。O(nlog2n)O(nlog^2n)O(nlog2n)，我的点分治明明也是O(nlog2n)O(nlog^2n)O(nlog2n)。。。 可怕的是标程在OJ上直接...
bzoj4012(动态点分治+卡常数)
running_in_dark的博客
02-08 583
这是一种类型的动态点分治   动态点分治，关键还是要在均摊n的空间复杂度内存下所有东西。这个就要充分利用stl，比如vector 每一个点存以这个点为根点分治的信息。   对于询问一个点的路径时，就是沿着点分治树，不断朝fa走，每走一层统计一下，因为分治树可以保证在log层内，时间复杂度同阶     #include #include #include #include #incl
【bzoj1036】树的统计Count【树链剖分】【ZKW大法好】【卡常大法好】
ZMOIYNLP的专栏
03-12 831
关于这个树上路径端点会重合的问题，我们只要不判断x==y就行了。详见被注释呵呵的地方。#include<cstdio> #include<cstring> #include<iostream> using namespace std; const int maxn=30001; typedef int arr[maxn]; typedef int arr1[maxn<<1]; arr fa,top,
【点分治】的学习笔记和众多例题
cyclization的小栈
03-23 4501
包含点分治多道例题： 【POJ 1741 & BZOJ 1468 & BZOJ 3365】 【BZOJ 2152】 【BZOJ 2599】 【BZOJ 1316】 很详细的一篇文章，20分钟教会你点分治。
GitHub一战封神，字节跳动内部顶级数据结构刷题学习笔记根本停不下来（csdn）————程序.pdf
12-01
标题和描述中提到的是一份源自字节跳动内部的数据结构刷题学习笔记，这份笔记在GitHub上引起广泛关注，被认为是一份有助于提升编程能力，尤其是对于准备字节跳动面试的程序员极具价值的资源。主要关注点在于各种排序...
MIT算法导论公开课之课程笔记 分治法.rar
07-06
在计算几何部分，笔记讨论了使用分治法解决点在线段上的覆盖问题、最近点对问题等。这些问题在二维平面上具有丰富的几何结构，分治法能够有效利用这种结构进行高效求解。 最后，笔记还提到了分治法在处理大规模数据...
算法导论读书笔记
08-09
第二章 **基本概念**：这一章主要介绍了算法的基本定义、算法设计的目标以及衡量算法性能的两个重要指标——时间复杂度和空间复杂度。时间复杂度用于评估算法执行时间随输入规模的增长趋势，而空间复杂度则关注算法...
算法笔记-上机训练实战指南-胡凡 完整版
03-31
根据提供的文件信息，我们可以推断出这是一本关于算法学习的书籍资料——《算法笔记-上机训练实战指南》，作者为胡凡。该书共有442页，内容全面覆盖了算法的基础理论与实践操作，适合希望提升算法能力的学习者使用。...
点分治总结
weixin_44221747的博客
06-27 156
点分治 点分治的定义 点分治是指在树上运用分治的思想来解决问题 点分治的应用 点分治主要应用于解决树上的路径问题 用法 点分治是基于树上的点来进行的分治 我们首先随便选择一个点，然后把树分成多个连通块，然后对每个连通块进行递归处理 如图所示 以红色的节点，将有根树变成无根树，然后对红色节点的三个儿子所在的三个连通块进行递归处理 如何对删除的节点进行选择 首先我们清楚选择节点后剩下的部分要进行递归处理，所以我们要尽量保证删除后递归的层数尽可能小，而这个时候我们就想到了树的重心，它可以使树剩下的最大连通块最小
图论专题-学习笔记：点分治
Plozia 的小窝
06-17 192
图论专题-学习笔记：点分治1. 前言2. 详解2.1 树的重心2.2 点分治3. 总结 1. 前言 点分治，是一种图论算法，专门用于一类树上路径统计问题。 前置知识：无。 2. 详解 2.1 树的重心 讲点分治之前我们先来讲讲树的重心。 树的重心的定义是这样的：在一棵树中，如果以一个点为根，其所有儿子的子树大小最大值是最小的，那么这个点就是树的重心。 换言之，树的重心需要满足其子树的最大值最小。 比如下面这棵树，1 号点就是树的重心。 树的重心有一个很重要的性质：其最大子树大小小于等于 n2\dfrac{
点分治学习笔记
SUNSET
10-24 274
点分治 学习链接 通过这个blog入门的:https://www.luogu.org/blog/user9012/dian-fen-zhi-lve-xie 简介 在做一类树上的题目时,往往需要对树进行分治,能将子树分解成大小尽量相等的情况是最吼的,因此我们每次选择根节点的时候都应该是当前部分的重心. 因此点分治模板包含了两个主要的过程:寻找当前部分的根和点分治主递归. 算法模板 寻找重心 1.si...
树的重心、点分治
我的故事用酒换
08-19 249
大佬讲的树的重心 很详细的点分治，基本看完就懂了 计算以无根树每个点为根节点时的最大子树大小，这个值最小的点称为无根树的重心。 性质1：某个点是树的重心等价于它最大子树大小不大于整棵树大小的一半。 性质2：树至多有两个重心。如果树有两个重心，那么它们相邻。此时树一定有偶数个节点，且可以被划分为两个大小相等的分支，每个分支各自包含一个重心。 性质3：树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么到它们的距离和一样。反过来，距离和最小的点一定是重心。 性质4：往树上增加或
【算法学习】树的重心与点分治
Pengwill's Blog
08-31 1419
树的重心 树的重心也叫做树的质心。其本质是一个点，删除这个点后，形成的子树中最大的节点数目最小。 解法 一遍dfs即可。dfs的时候记录一下当前节点uuu的size[u]size[u]size[u]，同时记录他的所有儿子子树中的最大节点数目mxchildmxchildmxchild，那么删除当前节点uuu所形成的子树就是max(mxchild,n−size[u])max(mxchild,n−...
点分治学习：树的重心（质心）
yangzijiangac的博客
01-08 628
树的重心定义： 找到一个点,其所有的子树中最大的子树节点数最少,那么这个点就是这棵树的重心 dfs一遍就可以找到树的重心 void dfs(int u,int fa) { //vis[u]=true, sizx[u]=1; max_part[u]=0; for(int i=head[u]; ~i; i=tr[i].nex) { int ...
点分治详细解析
热门推荐
Guess_Ha的博客
08-24 2万+
点分治，是处理树上路径的一个极好的工具。 一般如果需要大规模处理树上路径，点分治是一个不错的选择。 这里我就来讲一讲我自己对于点分治的一点理解和感悟（帮助新手入坑……） 现在就开始吧！1.点分治的基本思想 点分治，顾名思义就是基于树上的节点进行分治。 如果我们在深入一点呢？对于点的拆开其实就是对于树的拆开。 所以我认为点分治的本质其实是将一棵树拆分成许多棵子树处理，并不断进行。 这应该
【创新未发表】Matlab实现白冠鸡优化算法COOT-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现淘金优化算法GRO-Kmean-Transformer-LSTM负荷预测算法研究.rar
最新发布
07-29
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
动态点分治：树形结构的修改与查询优化
与静态的点分治不同，动态点分治引入了动态维护机制，这意味着树的结构虽然在某些情况下不是完全动态的，但能够适应变化，并保持对数据结构的高效处理。 核心概念是动态维护的点分治算法，它包含以下关键步骤： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值