点分治

最新推荐文章于 2021-06-28 19:16:48 发布
最新推荐文章于 2021-06-28 19:16:48 发布
阅读量83 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42465278/article/details/116266675
版权

我搬运我自己应该算原创吧

感谢 LittleChai 教会了我点分治!

点分治

点分治用来处理许多(一般是所有)树上点对信息, 比如路径.

比如洛谷上的板题:

给定一棵有 n n n 个点的树, m m m 次询问, 问树上距离为 k k k 的点对是否存在.

暴力是枚举两个点 x , y x, y x,y, 然后求 l c a lca lca, 再算 d i s t ( l c a , x ) + d i s t ( l c a , y ) dist(lca, x) + dist(lca, y) dist(lca,x)+dist(lca,y)

现在我们这么思考: 对于一棵树, 我们把路径(点对)分成两种:

  1. 经过根的
  2. 不经过根的

此时, 经过根的路径就类似于lca那样, 可以被分为两段: d i s t ( x , r o o t ) dist(x, root) dist(x,root) 和 d i s t ( y , r o o t ) dist(y, root) dist(y,root). 假设我们处理出了所有的 d i s t ( v , r o o t ) dist(v, root) dist(v,root)(其中 v v v 为 r o o t root root 的后代), 那么枚举一下所有的 d i s t ( u , r o o t ) dist(u, root) dist(u,root), 就变成了判断是否存在 d i s t ( v , r o o t ) = k − d i s t ( u , r o o t ) dist(v, root) = k - dist(u, root) dist(v,root)=k−dist(u,root). 当然这里会出现这样的情况, 需要容斥一下, 待会再详细讲:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qI5G4uct-1619672471542)(/img/centroid-decomposition/invalid.jpg)]

然后我们考虑不经过根的路径.

这时, 所有经过根的路径已经被处理完了, 所以根这个点可以删掉了.

于是, 剩下了一些子树. 在这些子树中, 我们又可以用同样的方法考虑点对.

由于求点对信息(路径等)的话, 根的选取不改变树的结构, 所以这个"根"我们是可以随便选的. 如何选最优呢? 答案是选重心. 重心能把子树的高度尽可能划分成最小, 这样在继续分治的过程中就可以减小操作的次数了. 可以证明, 这样的操作考虑所有点的复杂度是 O ( n l o g n ) O(nlogn) O(nlogn)的(口胡).

接下来, 我们考虑容斥掉多算了的.

还是上面那个例子, s s s 是 r r r 的儿子, u , v u, v u,v点对是"非法的", 因为他的路径其实不经过 r r r. 所以我们要去掉这个. 这一条"路径"(这里的路径也是假的, 下面有解释)一定会经过 s s s, 所以我们在子树 s s s 中, 减去长度为 k − 2 w ( r , s ) k - 2w(r, s) k−2w(r,s)的路径即可. 在实现的过程中是这样做的: 把 k k k 看成 d i s t 1 + d i s t 2 dist_1 + dist_2 dist1​+dist2​, 然后把两个距离都"加上" w w w, 这样目标长度还是 k k k, 做到了统一.

这种情况呢? 解释在图里, 并且也说明了路径为什么打引号.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ycU0L88z-1619672471544)(/img/centroid-decomposition/invalid2.jpg)]

至此, 我们就大概做完了这题.

当然不是所有的题都要容斥掉一部分, 具体题目还得具体分析. 如果点对信息是路径的话, 由于重心并不是lca, 所以会"多算了".

更多板题

再来看一道板题聪聪可可:

求树上点对路径为 3 3 3 的倍数的有多少条(有序对)

还是一样, 先找重心, 然后求子代到重心的路径长度. 由于只计算 3 3 3的倍数, 所以长度对 3 3 3 取模, 路径条数存在大小为 3 3 3 的桶里. 设长度模 3 3 3 为 i i i 的子代到重心的路径为 t i t_i ti​, 那么经过重心的路径长度为 3 3 3的倍数的条数有 t 0 2 + 2 t 1 t 2 t_0^2 + 2t_1t_2 t02​+2t1​t2​. 当然此时有"不合法路径", 由于"不合法路径"经过重心的儿子, 所以求儿子的子代到儿子的路径长度, 一样丢在桶里, t 0 ′ + 2 t 1 ′ t 2 ′ t_0' + 2t_1't_2' t0′​+2t1′​t2′​ 就是不合法的路径条数, 减去就是真正的所有经过重心的长度为 3 3 3 的倍数的路径了.

然后我们处理经过其他点的路径. 再从子树中找重心, 重复上述过程即可.

再来看一道板题(LittleChai讲的, 我还没去找题目链接):

求树上点对路径大于 k k k 的有多少条.

还是一样的做法, 先把每一个 d i s t ( v , c ) dist(v, c) dist(v,c) 求出来, 然后丢到权值BIT中. 之后再遍历每一个 d i s t dist dist, 求出大于 k − d i s t k - dist k−dist 的有多少. 注意不要求到自己. 可以先在BIT中减去当前枚举的 d i s t dist dist, 求完以后再插回去. 同理需要容斥.

高级处理

最后再来仔细分析一下去年vp的韩国一场open cup的一个点分治

题目链接

分析个屁不会做, 看题解+思考好久才能明白, 也说不清楚, 考场也想不到, 我是废物!

以后能力强了再来看看能不能解释明白吧. 等那一天解释明白了考场才能想到这样的做法吧.

模板代码

int sz[MAXN], vis[MAXN]; // sz[u] 为每次dfs计算以u为根的子树的大小
// descendant 保存第一次调用dfs的点u到包含u的树中的所有的点v及他们之间的距离
vector<PII> descendant;

/* 遍历, 同时计算sz和descentant */
/* dis是根(第一次调用dfs的点)到当前点u的距离(如果第一次调用dis参数为0, 不为0的话会在所有距离上加上这个参数) */
void dfs(int u, int f, int dis) {
	sz[u] = 1;
	descendant.emplace_back(u, dis);
	for (int i = head[u]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (e.to != f && !vis[e.to]) {
			dfs(e.to, u, dis + e.w);
			sz[u] += sz[e.to];
		}
	}
}


/* 求包含u的树的重心 */
int center(int u) {
	// 每一次求重心的时候, 要重新求子代, 注意清空
	descendant.clear();
	dfs(u, 0, 0);
	int tot_sz = descendant.size();
	for (auto des : descendant) {
		int is_center = 1;
		int x = des.first;
		for (int i = head[x]; i; i = edges[i].next) {
			Edge &e = edges[i];
			if (vis[e.to])
				continue;
			// sz[x] > sz[v] == v 是 x 的儿子
			// sz[v] > n / 2, v 不是重心
			if (sz[x] > sz[e.to] && (sz[e.to] << 1) > tot_sz) {
				is_center = 0;
				break;
			}
			// sz[x] < sz[v] == v 是 x 的父亲
			// tot_sz - sz[x] 是 v "向上"的子树大小
			// tot_sz - sz[x] > n / 2, v 不是重心
			if (sz[x] < sz[e.to] && ((tot_sz - sz[x]) << 1) > tot_sz) {
				is_center = 0;
				break;
			}
		}
		if (is_center) {
			// 找到重心, 需要以重心为根, 求一下树中所有点到重心的距离
			// 这样调用完center后就可以保存所有点到重心的距离了
			descendant.clear();
			dfs(x, 0, 0);
			return x;
		}
	}
	return -1;
}

void divide(int u) {
	int c = center(u);
	vis[c] = 1;	// 标记重心, 删去
	work();		// 已经在center函数中处理了 "经过重心的'半路径'", 在work函数中考虑如何把两条半路径组合成一条路径, 并考虑如何处理数据, 回答问题
	for (int i = head[c]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (vis[e.to])	// v 已经删除, 不考虑
			continue;
		iework();		// 考虑把"假的路径"容斥掉. 如果是路径, 那么求一次dfs(e.to, c, e.w)得到的descentant就是所有"假的路径". 这时候虽然第一次调用dfs的是e.to, 但由于加上的e.w, 也可以认为是点到c的距离
		divide(e.to);	// 找到剩余的点(所在的子树), 继续处理
	}
}

板题代码

洛谷模板题点分治1

这题要注意不能处理出所有"半路径"以后枚举两条拼凑, 这样复杂度是 O ( n 2 ) O(n^2) O(n2) 的. 注意到询问只有 100 100 100 个, 所以可以枚举询问和一条半路径, 判断能够凑成询问的另一半是否存在. 这样复杂度是 O ( m n ) O(mn) O(mn)

总复杂度 O ( m n l o g n ) O(mnlogn) O(mnlogn)

{{% code %}}

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <stack>
#define lowbit(x) (x&(-x))
#define LCH(x) (x<<1)
#define RCH(x) (x<<1|1)
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;

const int INTINF = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;

const int MAXN = 1e4+10;
const int MAXK = 1e7+10;
const int MAXM = 110;

struct Edge {
	int to, next, w;
} edges[MAXN<<1];
int mm = 0, head[MAXN];

void addEdge(int u, int v, int w) {
	edges[++mm] = Edge{v, head[u], w};
	head[u] = mm;
}

void addNet(int u, int v, int w) {
	addEdge(u, v, w);
	addEdge(v, u, w);
}

int n, q, k[MAXM], t[MAXK], sz[MAXN], vis[MAXN], ans[MAXM];
vector<PII> descendant;

void dfs(int u, int f, int dis) {
	sz[u] = 1;
	descendant.emplace_back(u, dis);
	for (int i = head[u]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (e.to != f && !vis[e.to]) {
			dfs(e.to, u, dis + e.w);
			sz[u] += sz[e.to];
		}
	}
}

int center(int u) {
	descendant.clear();
	dfs(u, 0, 0);
	int tot_sz = descendant.size();
	for (auto des : descendant) {
		int is_center = 1;
		int x = des.first;
		for (int i = head[x]; i; i = edges[i].next) {
			Edge &e = edges[i];
			if (vis[e.to])
				continue;
			if (sz[x] > sz[e.to] && (sz[e.to] << 1) > tot_sz) {
				is_center = 0;
				break;
			}
			if (sz[x] < sz[e.to] && ((tot_sz - sz[x]) << 1) > tot_sz) {
				is_center = 0;
				break;
			}
		}
		if (is_center) {
			descendant.clear();
			dfs(x, 0, 0);
			return x;
		}
	}
	return -1;
}

void divide(int u) {
	int c = center(u);
	vis[c] = 1;
	for (auto des : descendant) if (des.second <= 1e7)
		t[des.second]++;
	for (int i = 1; i <= q; i++)
		for (auto des : descendant) {
			if (k[i] - des.second >= 0)
				ans[i] += t[k[i] - des.second] > 0;
		}
	for (auto des : descendant) if (des.second <= 1e7)
		t[des.second]--;
	for (int i = head[c]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (vis[e.to])
			continue;
		descendant.clear();
		dfs(e.to, c, e.w);
		for (auto des : descendant) if (des.second <= 1e7)
			t[des.second]++;
		for (int i = 1; i <= q; i++)
			for (auto des : descendant)
				if (k[i] - des.second >= 0)
					ans[i] -= t[k[i] - des.second] > 0;
		for (auto des : descendant) if (des.second <= 1e7)
			t[des.second]--;
		divide(e.to);
	}
}

int read() {
    int x=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
    return x*f;
}

int main() {
	scanf("%d%d", &n, &q);
	for (int i = 1; i < n; i++) {
		int u = read(), v = read(), w = read();
		addNet(u, v, w);
	}
	for (int i = 1; i <= q; i++)
		scanf("%d", k + i);
	divide(1);
	for (int i = 1; i <= q; i++)
		puts(ans[i] ? "AYE" : "NAY");
	return 0;
}

{{% /code %}}

聪聪可可

{{% code %}}

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <stack>
#define lowbit(x) (x&(-x))
#define LCH(x) (x<<1)
#define RCH(x) (x<<1|1)
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;

const int INTINF = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;

const int MAXN = 2e4+10;

struct Edge {
	int to, next, w;
} edges[MAXN<<1];
int mm = 0, head[MAXN];

void addEdge(int u, int v, int w) {
	edges[++mm] = Edge{v, head[u], w};
	head[u] = mm;
}

void addNet(int u, int v, int w) {
	addEdge(u, v, w);
	addEdge(v, u, w);
}

int n, t[5], sz[MAXN], vis[MAXN], ans = 0;
vector<PII> descendant;

void dfs(int u, int f, int dis) {
	sz[u] = 1;
	descendant.emplace_back(u, dis%3);
	t[dis%3]++;
	for (int i = head[u]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (e.to != f && !vis[e.to]) {
			dfs(e.to, u, (dis + e.w)%3);
			sz[u] += sz[e.to];
		}
	}
}

int center(int u) {
	descendant.clear();
	t[0] = t[1] = t[2] = 0;
	dfs(u, 0, 0);
	int tot_sz = descendant.size();
	for (auto des : descendant) {
		int is_center = 1;
		int x = des.first;
		for (int i = head[x]; i; i = edges[i].next) {
			Edge &e = edges[i];
			if (vis[e.to])
				continue;
			if (sz[x] > sz[e.to] && (sz[e.to] << 1) > tot_sz) {
				is_center = 0;
				break;
			}
			if (sz[x] < sz[e.to] && ((tot_sz - sz[x]) << 1) > tot_sz) {
				is_center = 0;
				break;
			}
		}
		if (is_center) {
			descendant.clear();
			t[0] = t[1] = t[2] = 0;
			dfs(x, 0, 0);
			return x;
		}
	}
	return -1;
}

void divide(int u) {
	int c = center(u);
	vis[c] = 1;
	ans += t[0] * t[0] + 2 * t[1] * t[2];
	for (int i = head[c]; i; i = edges[i].next) {
		Edge &e = edges[i];
		if (vis[e.to])
			continue;
		descendant.clear();
		t[0] = t[1] = t[2] = 0;
		dfs(e.to, c, e.w);
		ans -= t[0] * t[0] + 2 * t[1] * t[2];
		divide(e.to);
	}
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i < n; i++) {
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		addNet(u, v, w);
	}
	divide(1);
	int d = __gcd(ans, n * n);
	printf("%d/%d\n", ans/d, n*n/d);
	return 0;
}

{{% /code %}}

WingsZeng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法笔记——点分治
m0_67142204的博客
07-27 298
点分治
点分治_点分治模板_
10-02
点分治（Disjoint Set）算法，又称为并查集，是数据结构和算法领域中的一种重要算法。它主要用于处理不相交集合的合并与查询问题，尤其在处理树形结构或者图的连通性问题时表现得极为有效。点分治模板通常包括了基本...
树分治 点分治
02-26
树分治就是在树形结构上进行分而治之的操作，包括点分治和边分治。 点分治的效率比较稳定，最坏情况下递归深度为O(logn)。 边分治在定点度数D为常数时，基于边的分治递归最坏深度为O(log N) ，然而D较大时会达到O(N)
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的...
分治法寻找临近点.docx
09-15
分治法寻找临近点 import random import math n = 500 minimum = float("inf") point = [(random.randint(0, 3 * n), random.randint(0, 3 * n)) for i in range(0, n)] # 随机生成n个坐标 closest_pair = {} buff...
分治法求最近点对代码
02-08
3. 要求随机生成N个点的平面坐标，应用分治法编程计算出所有点对的最短距离。 4. 分别对N=100,1000,10000,100000，统计算法运行时间，比较理论效率与实测效率的差异，同时对蛮力法和分治法的算法效率进行分析和比较...
点分治入门
Lstdo的博客
06-20 216
点分治就是树上的分治，也就是处理把分治强行搬到树上的毒瘤问题。 算法流程 引入：[国家集训队]聪聪可可 （各大OJ搜索即可） 题意：给一棵树，随机选两个点（可以相同），求距离为3的倍数的概率。 显然求长度是3的倍数的路径数即可。 首先是分治，那我们考虑一个子问题，即一棵树。 然而树上没有中点。如果直接分，给条链就挂了。 所以我们yy一个中点：重心 重心定义是以它为根的子树size的最大值最小。 ...
【点分治总结】
ＡＴＯＤ
05-13 5326
点分治教程：例题 给定一棵带权树，显然共有N*(N-1)/2条边，问：第k小的边边长多长？ N<=10000.题解： 这道题直接上手做实在是太难了，需要逐步拆分。 首先，问题是第k小的边的边长，这个问题不好解，但是转换一下问题，二分第k小的边长T，然后判断这棵树中<=T的路径有多少条，这个能稍微好做一下，至少变成了一个统计性问题。 二分后题目变成： 给定一棵带权树，显然共有N*(N-1)
点分治总结
夕夏锦年的博客
06-28 145
目录处理的问题算法复杂度分析例题分析race题目大意输入输出输入样例输出样例分析 处理的问题 点分治一般用来处理树上的路径统计，如统计 (⋯⋯ )(\cdots\cdots)(⋯⋯) 条件的路径数。 算法复杂度分析 由于其是类似用分治对类似于一段数进行分割，所以复杂度一般为 O(n log n)O(n\,log\,n)O(nlogn)。但是在特殊构造的图(如菊花图)上会退化为 O(n2)O(n^2)O(n2)，所以要用重心来优化为稳定的 O(n log n)O(n\,log\,n)O(nlogn)。 重心
点分治详细解析
热门推荐
Guess_Ha的博客
08-24 2万+
点分治，是处理树上路径的一个极好的工具。 一般如果需要大规模处理树上路径，点分治是一个不错的选择。 这里我就来讲一讲我自己对于点分治的一点理解和感悟（帮助新手入坑……） 现在就开始吧！1.点分治的基本思想 点分治，顾名思义就是基于树上的节点进行分治。 如果我们在深入一点呢？对于点的拆开其实就是对于树的拆开。 所以我认为点分治的本质其实是将一棵树拆分成许多棵子树处理，并不断进行。 这应该
点分治详解
aiweiluan5095的博客
06-29 437
点分治详解 点分治是一个需要自己推导的算法，但是有板子，但是Cal这个函数根据不同题目是会变的。 点分治是解决树上求值的一种算法，比如说一棵树上路径距离(u,v)距离<=K距离(u,v)距离<=K的点对数量。 我们首先思考最笨的想法： 我们可以先求出所以路径长度，然后减去不满足的路径长度(也就是最近公共祖先不是跟的路径长度)。 DF...
Mirai使用教程-定时任务
Wings
05-28 1531
更好的阅读体验请访问个人博客 本文使用 graia-scheduler 包进行开发. 实际上是python的异步功能, 但是我不会, 所以就找到了作者写好的包???? 安装 graia-scheduler 使用 详解 GraiaScheduler 定时函数 async 和 await override schedule 函数 crontabify 参数 roop.run_forever() 示例: 定时向某些群发布某些消息 安装 graia-scheduler pip install
【点分治】的学习笔记和众多例题
cyclization的小栈
03-23 4499
包含点分治多道例题： 【POJ 1741 & BZOJ 1468 & BZOJ 3365】 【BZOJ 2152】 【BZOJ 2599】 【BZOJ 1316】 很详细的一篇文章，20分钟教会你点分治。
js分治法最近点对js
最新发布
08-06
js分治法是一种解决最近点对问题的算法。 js分治法的基本思想是将问题划分为更小的子问题，然后逐步解决子问题，并将子问题的解合并成原始问题的解。对于最近点对问题，首先将所有点按照横坐标进行排序，然后通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值