[TreeDivideAndConquer]点分治

最新推荐文章于 2020-08-20 12:12:08 发布
最新推荐文章于 2020-08-20 12:12:08 发布
阅读量750 收藏 1
点赞数
分类专栏： 点分治 文章标签： 点分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbhcy98/article/details/51457801
版权

Pre ：树分治

树分治有两种，一种是基于点的分治，一种是基于边的分治，由于我觉得边分治用处不大，所以我们只讨论点分治。

点分治

路径

点分治是在树上的基于重心的分治方法，最初被用来处理有关树上路径计数的问题（见漆子超论文），因此我们从路径统计问题开始谈起。
首先不管是什么路径，在树上一定都有一个最高点（也就是说一个路径 (u,v) 一定是从 v 往上爬，爬到LCA(u,v)，再向下走到 v 的）。树上的任何一个点都可能成为某一条路径的最高点，我们将所有路径按最高点分类来处理。
假如我们当前处理的点是点u，我们将点 u 的子树提取出来，所有以u为最高点的路径一定都是从 u 的两个不同子树中选取两个点作为端点，这时候我们自然产生了一种想法：假如我们对于每个u都能承受枚举 u 子树里所有点的复杂度，那么问题就会变的简化许多，因为我们至少已经得到了路径的最高点（就是u）和路径的一个端点(枚举得到)。
但是显然如果我们直接对原树每个点都这样做一次，最坏情况下复杂度是平方级别的，这时候我们就需要运用点分治来解决这一问题。

重心

为了引入点分治，我们首先介绍重心。
重心是一棵树中到所有点的距离和最小的那个点，同时也是一棵无根树中选取为根能够使得最大子树最小的那个点。
至于重心的求法，我们从它的定义出发做一遍动态规划就可以求出了。

重心分解

回到刚才的问题，我们希望选取出一个点 u ，处理出以这个点为最高点的路径，然后继续递归处理以它的儿子为最高点的路径，并使得我们能够承受枚举u子树里所有点的复杂度。
注意到我们很多时候并不关心某条路径的最高点具体是哪个点，我们只需要它被它的最高点统计过一次就行了，换言之，我们可以通过适当改变树的形态，来降低我们之前做法的复杂度（很多时候我们直接做都是被一条链卡掉的）。
点分治就成功运用了重心的独特性质来做到这一点：
假如我们当前统计子树 u 里的所有路径，我们提取出子树u的重心 cg 作为这棵树的根，统计出以 cg 为最高点的路径，然后继续递归子树。
点分治的复杂度分析基于这样一个定理：
每次提取出树的重心作为这棵树的根，删掉重心，原树被分解为若干子树，继续分解子树，至多分解 log(n) 次树就会被分解完。
可以用主定理证明，对于点分治的每一层来说，假如处理一个大小为 n 的子树的复杂度为O(f(n))，那么整个点分治的复杂度为 O(f(n)log(n))

BZOJ3365 [Usaco2004 Feb]Distance Statistics 路程统计

大意：
给一棵树，求两两之间距离不超过 K 的点对数
解：
这就是最简单的路径统计问题。我们运用点分治的思想，对于每棵子树提取出重心为根，然后考虑最高点在新根的所有路径。
对于一个根，我们遍历它的子树，将子树里所有点按到根的距离排序，对于一个点i，合法的路径的另一个端点必然在排序后的某一个前缀里，因此我们利用单调性扫一扫就好。

类似的简单题还有BZOJ2599, BZOJ2152

重心重构树到动态点分治

点分治最早用来解决路径统计问题，但点分治的威力绝不仅仅于此。
点分治最核心的思想，就在于重心分解，而重心分解从另一个角度来看，其实是将原树的结构做了重新的调整。
我们提取出分治时每一层的重心，将层与层之间的重心重新连边，我们就得到了原树重构之后的一棵新树，容易知道新树恰好包含了原树的每一个点，树高不超过 logn 并且保留了原树中的一些子树关系（例如原树的一棵子树对应到重构树里还是一棵子树，只不过父子关系发生了很大变化；原树一条根到子树的路径被拆解为根到重心，重心到子树的两条路径），之前的路径统计其实是在这棵隐式的重构树上暴力，我们并不需要把这棵重构树显式地建立出来。
有了重心重构树的想法，我们能够解决的问题就绝不仅仅限于路径统计了。

BZOJ3672 [Noi2014]购票

大意：
比较复杂不方便直接说，建议看一遍原题
解：
首先我们写出该题的动态规划方程，发现我们直接暴力转移是会超时的，观察之后发现要斜率优化，进而注意到对于一个点 v ，决策点是它向上若干连续的祖先，也就是对一条路径上的点求一个凸壳，直接做依然超时，我们考虑引入重心重构树的想法。
重心重构之后，假如我们原来要处理的子树是u，现在在重构树中对应于子树 cg ，重构树中的 cg 有若干子树，其中有一棵包含了 u ，其它都是cg在原树中的子树，注意到 u 所在的子树的dp值与 cg 其他子树无关，我们先递归处理之，得到该子树信息之后，我们考虑这棵子树对 cg 其它子树的影响：将 cg 到 u 的路径提取出来暴力求一个凸壳（这些点都在之前先求出来的子树里），再暴力更新cg其它子树的每一个点。最后递归处理 cg 其它子树即可，由于重心重构树的性质，我们这么暴力更新有复杂度保证。
有很多人说这么做类似于 CDQ分治 ，感觉颇有道理，把子树类比成区间似乎就有了共通的地方。不过本来都是分治算法，很正常。

//By Hachiman
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, r, l) for (int i = (r); i >= (l); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PER(i, n) for (int i = (n)-1; ~i; i--)
#define MS(_, __) memset(_, __, sizeof(_))
#define MP make_pair
#define PB push_back
#define FT first
#define SC second
#define Hachiman
#ifdef Hachiman
#   define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#   define debug(...)
#endif
#define RND(l, r) rand()%((r)-(l)+1)+(l)
typedef long long ll;
typedef long double ld;
typedef unsigned int ui;
typedef pair<ll, ll> PII;
const ll INF = 0x7fffffffffffffff;
const double eps = 1e-8;
template<typename T> inline void read(T &x){
    x = 0; T f = 1; char ch = getchar();
    while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); }
    while (isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
    x *= f;
} 
template<typename T> inline void ckmax(T &a, T b){ if (a < b) a = b; }
template<typename T> inline void ckmin(T &a, T b){ if (a > b) a = b; }
template<typename T> inline bool CKmax(T &a, T b){ if (a < b) { a = b; return 1;} return 0; }
template<typename T> inline bool CKmin(T &a, T b){ if (a > b) { a = b; return 1;} return 0; }

const int MaxN = 200100;

struct Point{
    ll x, y;
    Point(){}
    Point(ll X, ll Y):x(X), y(Y){}
}CH[MaxN];
struct Edge{
    int v; ll w; bool ban; Edge *nxt;
}pool[MaxN<<1], *tail = pool, *g[MaxN];
int TOP;
double slope[MaxN];
int n, type, fa[MaxN], lst[MaxN], root;
ll p[MaxN], q[MaxN], lim[MaxN], f[MaxN], dis[MaxN], mx[MaxN], sz[MaxN], mn;

inline double cal_slope(const Point &u, const Point &v){ return (1.*u.y-v.y)/(1.*u.x-v.x); }
inline void ins(int u){
    Point p = Point(dis[u], f[u]);
    double s = TOP ? cal_slope(p, CH[TOP]) : INF;
    for (; TOP >= 2 && s >= slope[TOP]; s = cal_slope(p, CH[--TOP]));
    slope[++TOP] = s; CH[TOP] = p;
}
inline int qry(double k){ 
    //printf("k=%.1lf\n",k); 
    if (slope[TOP] > k) return TOP;
    int l = 1, r = TOP;
    while (l + 1 < r){
        int mid = l+r >> 1;
        if (slope[mid] > k) l = mid; else r = mid;
    }
    return l;
}
inline bool cmp(int u, int v){ return dis[u]-lim[u] > dis[v]-lim[v]; }
inline void addedge(int u, int v, int w){
    tail->v = v; tail->w = w; tail->nxt = g[u]; g[u] = tail++;
}
inline void dfs_dis(int u){
    for (Edge *p = g[u]; p; p = p->nxt){
        dis[p->v] = dis[u] + p->w; dfs_dis(p->v);
    }
}
inline void dfs_size(int u){
    sz[u] = 1; mx[u] = 0;
    for (Edge *p = g[u]; p; p = p->nxt) if (!p->ban){
        dfs_size(p->v);
        sz[u] += sz[p->v]; ckmax(mx[u], sz[p->v]);
    }
}
inline void find_heavy(int u, int rt, int &gc, ll nowmn){
    ckmax(mx[u], sz[rt]-sz[u]);
    if (CKmin(nowmn, mx[u])) gc = u;
    for (Edge *p = g[u]; p; p = p->nxt) if (!p->ban) find_heavy(p->v, rt, gc, nowmn);
}
inline void dfs_lst(int u){
    lst[++lst[0]] = u;
    for (Edge *p = g[u]; p; p = p->nxt) if (!p->ban) dfs_lst(p->v);
}
inline void Tree_Divide_and_Conquer(int u, int size){
    if (size == 1) return;
    int root; ll mn = n; dfs_size(u); find_heavy(u, u, root, mn);
    for (Edge *p = g[root]; p; p = p->nxt) p->ban = 1;
    Tree_Divide_and_Conquer(u, size - sz[root] + 1);
    lst[0] = 0; for (Edge *p = g[root]; p; p = p->nxt) dfs_lst(p->v);
    sort(lst + 1, lst + 1 + lst[0], cmp); 
    TOP = 0;
    for (int i = 1, anc = root; i <= lst[0]; i++){ int now = lst[i];
        for (; anc != fa[u] && dis[anc]+lim[now]>=dis[now]; anc = fa[anc]) ins(anc);
        if (TOP){
            Point res = CH[qry(1.*p[now])];
            ckmin(f[now], res.y + p[now]*(dis[now]-res.x)+q[now]);
        }
    }
    for (Edge *p = g[root]; p; p = p->nxt) Tree_Divide_and_Conquer(p->v, sz[p->v]);
}
int main(int argc, char *argv[]){
    read(n); read(type);
    rep(i, 2, n){ ll len;
        read(fa[i]), read(len), read(p[i]), read(q[i]), read(lim[i]);
        addedge(fa[i], i, len);
    }
    dfs_dis(1);
    MS(f, 0x3f); f[1] = 0;
    Tree_Divide_and_Conquer(1, n);
    rep(i, 2, n) printf("%lld\n", f[i]);
    return 0;
}

由静到动：动态点分治

之前的问题我们都没有对树上的信息作任何的修改，因此我们不需要显式地将重心重构树建出来，但在更高层次的问题中，树上点/边的信息，甚至是树的形态都会发生改变，这时候重心重构的思想依然是重要的武器，但我们不得不将重心重构树建立出来，并用新的手段维护重构树上的信息了。
这种做法，就是动态点分治。

BZOJ1095 [ZJOI2007]Hide 捉迷藏

大意：
给一棵树，每个点要么黑要么白，给若干操作，改变棋子的颜色或是询问相距最远的两个黑点的距离
解：
假如说没有改颜色的话那么我们直接点分治就能解决这个问题了，但现在结点的信息在改变，我们需要显式地建立出重心重构树并维护重构树上的信息。
对于每个点，我们需要维护的是它和它子树里所有黑点到它的父亲（注意如果不特别指出我所说的都是重构树里的父子关系）的距离，以及它每个儿子的子树里到它最远的黑点的距离，我们用两个堆来维护上述两个信息（再次注意到由于重构树树高 log(n) ，我们存这么多信息也只会用 nlog(n) 的空间，因为一个点只会在它的所有祖先里被存下来，非常好）再用一个堆维护全局路径最大值，至于修改，找到那个点暴力往上爬把祖先一路改掉就行了。

//%%%SRwudi,%%%CZGJ
//By Hachiman
//Dynamic Tree Divide and Conquer
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, r, l) for (int i = (r); i >= (l); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define PER(i, n) for (int i = (n)-1; ~i; i--)
#define EREP(p, x) for (Edge *p = g[x]; p; p = p->nxt)
#define NEREP(p, x) for (Ede *&p = cur[x]; p; p = p->nxt)
#define MS(_) memset(_, 0, sizeof(_))
#define MP make_pair
#define PB push_back
#define FT first
#define SC second
#ifdef Hachiman
#   define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#   define debug(...)
#endif
#define RND(l, r) rand()%((r)-(l)+1)+(l)
typedef long long ll;
typedef long double ld;
typedef unsigned int ui;
typedef pair<int, int> PII;
const int INF = 0x7fffffff;
const double eps = 1e-8;
const int MOD = 1000000007;
template<typename T> inline void read(T &x){
    x = 0; T f = 1; char ch = getchar();
    while (!isdigit(ch)) { if (ch == '-') f = -1; ch = getchar(); }
    while (isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
    x *= f;
} 
template<typename T> inline void ckmax(T &a, T b){ if (a < b) a = b; }
template<typename T> inline void ckmin(T &a, T b){ if (a > b) a = b; }
template<typename T> inline bool CKmax(T &a, T b){ if (a < b) { a = b; return 1;} return 0; }
template<typename T> inline bool CKmin(T &a, T b){ if (a > b) { a = b; return 1;} return 0; }

const int MaxN = 100010;

struct Heap{
    priority_queue<int> ins, del;
    inline void Insert(int x){ ins.push(x); }
    inline void Erase(int x){ del.push(x); }
    inline void Clear(){ for (; !del.empty() && del.top() == ins.top(); del.pop(), ins.pop()); }
    inline void Pop(){ Clear(); ins.pop();  }
    inline int First(){ Clear(); return ins.top(); }
    inline int Second(){ int tmp = First(); Pop(); int res = First(); Insert(tmp); return res;  }
    inline int Size(){ return ins.size() - del.size(); }
}heap[2][MaxN], ans;
struct Edge{
    int v; bool ban; Edge *nxt, *ptr;
}pool[MaxN<<1], *tail = pool, *g[MaxN];

int n, m, cnt;
int fa[MaxN], mx[MaxN], Log[MaxN<<1], dep[MaxN], sz[MaxN], pos[MaxN], seq[MaxN<<1][20], Time = 0;
bool state[MaxN];

inline void addedge(int u, int v){
    tail->v = v; tail->nxt = g[u]; tail->ptr = tail+1; g[u] = tail++;
    tail->v = u; tail->nxt = g[v]; tail->ptr = tail-1; g[v] = tail++;
}
inline void dfs_size(int x, int fa){
    sz[x] = 1; mx[x] = 0;
    EREP(p, x) if (!p->ban && p->v != fa){
        dfs_size(p->v, x);
        sz[x] += sz[p->v]; ckmax(mx[x], sz[p->v]);
    }   
}
inline void find_heavy(int x, int rt, int fa, int &cg, int nowmn){
    ckmax(mx[x], sz[rt]-sz[x]);
    if (CKmin(nowmn, mx[x])) cg = x;
    EREP(p, x) if (!p->ban && p->v != fa) find_heavy(p->v, rt, x, cg, nowmn);
}
inline void dfs_dis(int x, int fa, int dep, Heap &q){
    q.Insert(dep);
    EREP(p, x) if (!p->ban && p->v != fa) dfs_dis(p->v, x, dep+1, q);
}
inline void ins(Heap &q){ if (q.Size()>=2) ans.Insert(q.First()+q.Second()); }
inline void del(Heap &q){ if (q.Size()>=2) ans.Erase(q.First()+q.Second()); }
inline int TreeDivideAndConquer(int x){
    int cg, mn = n; dfs_size(x, 0); find_heavy(x, x, 0, cg, mn);
    heap[1][cg].Insert(0);
    EREP(p, cg) if (!p->ban){ 
        p->ban = p->ptr->ban = true;
        Heap q; dfs_dis(p->v, 0, 1, q); int son = TreeDivideAndConquer(p->v);
        fa[son] = cg; heap[0][son] = q;
        heap[1][cg].Insert(heap[0][son].First());
    }
    ins(heap[1][cg]);
    return cg;  
}
inline void EulerTour(int x, int fa){
    seq[pos[x] = ++Time][0] = dep[x] = dep[fa] + 1;
    EREP(p, x) if (p->v != fa) EulerTour(p->v, x), seq[++Time][0] = dep[x];
}
inline void Mutiplication(){
    EulerTour(1, 0);
    rep(i, 2, Time) Log[i] = Log[i>>1]+1;
    rep(j, 1, Log[Time]) for (int i = 1; i+(1<<j)-1<=Time; i++)
        seq[i][j] = min(seq[i][j-1], seq[i+(1<<(j-1))][j-1]);   
}
inline int LCA_Depth(int x, int y){
    x = pos[x]; y = pos[y]; if (x > y) swap(x, y);
    int L = Log[y-x+1];
    return min(seq[x][L], seq[y-(1<<L)+1][L]);
}
inline int Distance(int x, int y){ return dep[x]+dep[y]-2*LCA_Depth(x, y); }
inline void Turnon(int x){
    del(heap[1][x]); heap[1][x].Erase(0); ins(heap[1][x]);
    for (int i = x; fa[i]; i = fa[i]){
        del(heap[1][fa[i]]);
        if (heap[0][i].Size()) heap[1][fa[i]].Erase(heap[0][i].First());
        heap[0][i].Erase(Distance(fa[i], x));
        if (heap[0][i].Size()) heap[1][fa[i]].Insert(heap[0][i].First());
        ins(heap[1][fa[i]]);
    }
}
inline void Turnoff(int x){
    del(heap[1][x]); heap[1][x].Insert(0); ins(heap[1][x]);
    for (int i = x; fa[i]; i = fa[i]){
        del(heap[1][fa[i]]);
        if (heap[0][i].Size()) heap[1][fa[i]].Erase(heap[0][i].First());
        heap[0][i].Insert(Distance(fa[i], x));
        if (heap[0][i].Size()) heap[1][fa[i]].Insert(heap[0][i].First());
        ins(heap[1][fa[i]]);
    }
}
int main(int argc, char *argv[]){
    read(n); cnt = n;
    rep(i, 1, n-1){ int u, v;
        read(u); read(v); addedge(u, v);
    }
    TreeDivideAndConquer(1);
    Mutiplication();
    rep(i, 1, n) state[i] = true;
    read(m);
    for (; m; m--){ char op;
        scanf(" %c", &op);
        if (op == 'G') printf("%d\n", cnt <= 1 ? cnt-1 : ans.First());
        else{ int x;
            scanf("%d", &x);
            if (state[x] == true){ --cnt; state[x] = false; Turnon(x); }
            else{ ++cnt; state[x] = true; Turnoff(x); } 
        }
    }
    return 0;   
}

BZOJ3435 [Wc2014]紫荆花之恋

大意：
给定一棵树，每次添加一个节点并询问当前有多少点对满足 dis(i,j)<=Ri+Rj 强制在线
解：
假如说不添加结点的话直接点分治就好了，现在树的形态在发生改变，这样问题就更为棘手，因为重心重构树的形态也会发生改变。
为了维护重心重构树的性质，我们引入替罪羊树的思想，先大胆直接添加叶子，一旦发现一棵子树过于不平衡，我们就暴力重构之。
然后在重构树每个点上用一个平衡树维护子树所有点的信息就可以了。

Sakagami_Tomoyo
关注
专栏目录
树分治
slark_的博客
07-16 1108
什么是分治算法： 分治算法的思想是将一个规模为N的问题分解为K个规模的较小的子问题，这些子问题相互独立且与原问题性质相同。求出这些问题的解后再将这些子问题的解合并，就可以得到原问题的解。例如快速排序和归并排序。 所谓树分治，就是在树形结构上的一种分治问题，主要操作是去除原本树中的某些对象，使得原树被分解成若干个互不相交的部分，由此可以解决许多以路径为询问对象的问题。 树分治分为以下两种...
『点分治及其简单运用』
weixin_34080571的博客
05-28 379
点分治 分治思想 点分治是一种用于处理静态树上路径统计问题的算法，其核心原理还是基于分治思想。 我们不妨对这类树上静态路径统计问题抽象化，例如： 给定一个棵无根树，求满足要求\(P\)的路径有几条。 我们可以使用分治算法求解本题，对于无根树，我们指定一个节点为根，显然，这样的路径可以归为两类： \(1.\) 满足要求\(P\)且经过根\(root\)的路径 \(2.\) 满足要...
点分治_点分治模板_
10-02
点分治（Disjoint Set）算法，又称为并查集，是数据结构和算法领域中的一种重要算法。它主要用于处理不相交集合的合并与查询问题，尤其在处理树形结构或者图的连通性问题时表现得极为有效。点分治模板通常包括了基本...
实验2_分治法求最近点对问题_分治法求最近点对问题_
10-03
1. 对于平面上给定的N个点，给出所有点对的最短距离，即，输入是平面上的N个点，输出是N点中具有最短距离的两点。2. 要求随机生成N个点的...3. 要求随机生成N个点的平面坐标，应用分治法编程计算出所有点对的最短距离。
test_分治法求最近点对问题_
09-29
3. 要求随机生成N个点的平面坐标，应用分治法编程计算出所有点对的最短距离。4. 分别对N=100100010000100000，统计算法运行时间，比较理论效率与实测效率的差异，同时对蛮力法和分治法的算法效率进行分析和比较。5. ...
分治法寻找临近点.docx
09-15
根据给定的信息，本文将详细解释如何利用分治法寻找二维空间中的最近点对，并对提供的代码进行解读。 ### 分治法寻找最近点对的基本原理 分治法是一种常见的算法设计策略，它通过将问题分解成更小的子问题来解决...
树的分治
shi_zi_183的博客
08-20 773
树的分治 树的分治分为两种：点分治、边分治。 点分治：点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。 边分治：边分治就是每次找到一条边，使得删掉这条边后分成的两棵子树大小尽可能平均，然后以删掉的边的两端点为根，分别统计根到两棵树中的每个结点的路径信息，
树分治（点）
冰柠橙的博客
12-11 175
 基本思想：把树分割成几个子树，从而快速解决一些问题（如树上距离小于等于k的点对数）。关键是如何取分割树，不难想到，如果能够找到一个点，这个点下面的各个子树的大小都一样，肯定是个最优点，也叫重心。当然都一样是理想情况，在实际中只要保证重心下面的子树中最大的尺寸是最小的即可。 模板题：poj 1741 树中距离小于等于k的对数 #include&lt;iostream&gt; #include...
树分治（点分治）
lahlah的博客
08-09 1561
点分治主要能解决的问题是树上路径个数的问题。 分治也并没有想象中的那么难，就是时间复杂度有点玄学，有的人说是nlog^2n有的说是nlogn，我也不知道具体是多少（反正比n^2暴力快就是了） 点分治的思想就是每次取一个重心，然后把每个经过该重心的路径数量算出来（要用容斥,注意重心是否要被计算），对于重心的每个儿子都递归进去做同样的操作，最后累加即可（看代码就懂了）。 扔道题 题意就是求长度...
【acwing 252】树（树分治）
Coldfresh的博客
03-14 345
给定一个有N个点（编号0,1,…,N-1）的树，每条边都有一个权值（不超过1000）。 树上两个节点x与y之间的路径长度就是路径上各条边的权值之和。 求长度不超过K的路径有多少条。 输入格式 输入包含多组测试用例。 每组测试用例的第一行包含两个整数N和K。 接下来N-1行，每行包含三个整数u,v,l，表示节点u与v之间存在一条边，且边的权值为l。 当输入用例N=0，K=0时，表示输入终止，且该用例...
树分治（点分治+边分治）
amourww的博客
03-31 3628
基本相关论文树分治分为点分治O（N和边分治。点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。 边分治就是每次找到一条边，使得删掉这条边后分成的
点分治总结
weixin_42465242的博客
07-17 120
点分治就是基于点的分治。 方法如下：dfs遍历整棵树，在遍历到点u时，考虑lca为u的点对组成的路径，时间复杂度为o(子树大小）。 但这样对一些极限数据会超时（例如一条链的情况），可能退化到n^2。 因为每次考虑点对，都是在以u为根的子树中考虑，与其它节点无关，所以每次dfs到u时，在处理完点对后，接下来要考虑的子树就相当于是一棵独立的树，所以对于这棵独立的树的dfs可以从任意节点开始继续搜...
浅谈树分治
lahlah的博客
05-16 389
前言 内容大概有 点分治 点分治 两年前好像写过一篇关于点分治的文章（但是菜得很）：https://blog.csdn.net/qq_38944163/article/details/81544134 用于解决某类树上路径的问题的高效算法 算法核心思想： 每次钦定一个点作为根，统计经过这个点的路径的贡献（两端都在子树内），然后这个点各个儿子子树之前不再有贡献，一路分治下去即可（儿子树的互相独立）。 在树上钦定的点要保证删掉这个点后最大的连通块节点个数最小，这个点就是树的重心。 找重心： 首先随便找一
分治法算法解决最近点对问题
文件的标签"分治法 算法 最近点对"进一步强调了这一点，意味着压缩包可能包含了分治法算法的实现以及如何应用该算法来解决最近点对问题的示例代码或文档。分治法解决最近点对问题的关键在于递归地将问题分解为较小的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值