专题·点分治【including 点分治，洛谷P3806·【模板】点分治1及例题

最新推荐文章于 2022-10-08 20:30:11 发布

樱狸❀

最新推荐文章于 2022-10-08 20:30:11 发布

阅读量271

点赞数

分类专栏：点分治文章标签：点分治

本文链接：https://blog.csdn.net/qq_43326267/article/details/100828754

版权

点分治专栏收录该内容

3 篇文章 0 订阅

订阅专栏

初见安~几百年没写专题了来整理一波：）

点分治

1.概念

众所周知，分治是一种算法思想层面的东西【大雾。那么点分治是什么呢——通过静态的运算统计出树上一定条件下路径的一种算法。诸如在树上求路径长度<=K的路径数量之类的。

那么对于分治，这一思想上的体现在于——因为路径有直链和折链，假设我们要求的是路径长度不超过K的路径数量，并且在以1为我们统计的路径的LCA的状况下，我们是不是可以通过求出其他每个点到点1的距离并且匹配看有多少合法的数量？这样统计出来的都是以1为LCA经过的路径。那么剩下的不经过1的路径呢？我们就可以以1的各个子树的根为根继续往下匹配剩下的不经过点1的路径……这里应该还是比较好理解的。这样下来每个点都会刚好作为一个子树的根统计一次路径，复杂度是 O(nlogn) 的。【后面还会讲到关于复杂度的】

但是我们继续思考——如果每次都固定以节点1作为根开始，然后依次子树往下，如果碰到一条链，复杂度就会径直退化到 O(n^2) 。所以为了维护这个log的复杂度，我们每次框定子树过后就以重心【重心：去掉该点后的最大子树最小】作为根。这样的话各个子树的深度就保证了在log的复杂度内了。

这样讲的话读者可以开留个大概印象，点分治主要处理路径的思路就是挨个处理子树，拼凑折链。

2.代码例题

洛谷P3806 【模板】点分治1

题目描述

给定一棵有n个点的树

询问树上距离为k的点对是否存在。

输入格式

n,m 接下来n-1条边a,b,c描述a到b有一条长度为c的路径

接下来m行每行询问一个K

输出格式

对于每个K每行输出一个答案，存在输出“AYE”,否则输出”NAY”(不包含引号)

输入

2 1
1 2 2
2

输出

AYE

说明/提示

对于30%的数据n<=100

对于60%的数据n<=1000,m<=50

对于100%的数据n<=10000,m<=100,c<=10000,K<=10000000

题解

这就是点分治最裸的板子题了，问你长度为K的路径是否存在。【头一次一段一段地解释代码呢……】

本人用的是邻接表存图】

首先，从整棵树入手，我们要先求出整棵树的重心作为根节点切入。

求重心：

int root, max_num, part[maxn];
void get_root(int u, int fa) {
	size[u] = 1, part[u] = 0;//size是以u为根节点的整个树的大小，part是最大的子树大小
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(v == fa || vis[v]) continue;
		get_root(v, u);
		size[u] += size[v], part[u] = max(part[u], size[v]);
	}
	part[u] = max(part[u], max_num - size[u]);//max_num是所求的整棵树的大小，具体可以看主函数
	if(part[u] < part[root]) root = u;
}

求出来了重心root，我们就可以开始solve这棵树了。

solve的主要功能是点分治的框架的构造。


int root, max_num, part[maxn];
bool vis[maxn];//vis记录是否以这个节点为重心过
void solve(int u) {
	judge[0] = true;//judge是桶，judge[i]表示长度为i的路径存在，后面会用到
	vis[u] = true;
	cal(u);//cal去实现求答案
	
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(vis[v]) continue;//往下遍历子树
		max_num = size[v]; root = 0; get_root(v, u);//为子树求出重心
		solve(root);//点分治
	}
}

接下来我们就要考虑答案的计算了，也就是最核心的代码部分：cal函数：

int len[maxn], dis[maxn];
bool judge[INF], test[maxn];
void get_dis(int u, int fa) {//递归求距离，很基础就不解释了
	len[++len[0]] = dis[u];
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(v == fa || vis[v]) continue;
		dis[v] = dis[u] + e[i].w;
		get_dis(v, u);
	}
}

void cal(int u) {
	int p = 0;
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(vis[v]) continue;
		len[0] = 0; dis[v] = e[i].w;//len[0]用来统计有多少个len，后面dis会用
		get_dis(v, u);//这里是递归去求子树各个点到u的距离
		
		for(int j = len[0]; j; j--)
			for(int k = 1; k <= m; k++) if(len[j] <= ques[k])//ques[k]是第k个询问
				test[k] |= judge[ques[k] - len[j]];//test是第k个询问是否有答案，这里是在用judge匹配
				
		for(int j = len[0]; j; j--) judge[len[j]] = true, q[++p] = len[j];//把答案加入judge
	}
	
	for(int i = 1; i <= p; i++) judge[q[i]] = 0;// judge每次用完过后都要清空的。
}

到这里，我们的核心代码就都已经完成啦~

下面上完整代码【没有核心代码的注解哦】

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
#define maxn 10004
using namespace std;
typedef long long ll;
const int INF = 1e7 + 5;//按照题目意思应该要开1e8，但是……数据水，开1e5都能过
int read() {
	int x = 0, f = 1, ch = getchar();
	while(!isdigit(ch)) {if(ch == '-') f = -1; ch = getchar();}
	while(isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
	return x * f;
}

int n, m;
struct edge {
	int to, w, nxt;
	edge() {}
	edge(int tt, int ww, int nn) {to = tt, w = ww, nxt = nn;}
}e[maxn << 1];

int head[maxn], k = 0;
void add(int u, int v, int w) {e[k] = edge(v, w, head[u]); head[u] = k++;}

int ques[maxn], size[maxn], q[maxn], len[maxn], dis[maxn];
int root, max_num, part[maxn];
bool vis[maxn], judge[INF], test[maxn];
void get_root(int u, int fa) {
	size[u] = 1, part[u] = 0;
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(v == fa || vis[v]) continue;
		get_root(v, u);
		size[u] += size[v], part[u] = max(part[u], size[v]);
	}
	part[u] = max(part[u], max_num - size[u]);
	if(part[u] < part[root]) root = u;
}

void get_dis(int u, int fa) {
	len[++len[0]] = dis[u];
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(v == fa || vis[v]) continue;
		dis[v] = dis[u] + e[i].w;
		get_dis(v, u);
	}
}

void cal(int u) {
	int p = 0;
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(vis[v]) continue;
		len[0] = 0; dis[v] = e[i].w;
		get_dis(v, u);
		
		for(int j = len[0]; j; j--)
			for(int k = 1; k <= m; k++) if(len[j] <= ques[k])
				test[k] |= judge[ques[k] - len[j]];
				
		for(int j = len[0]; j; j--) judge[len[j]] = true, q[++p] = len[j];
	}
	
	for(int i = 1; i <= p; i++) judge[q[i]] = 0;// 
}

void solve(int u) {
	judge[0] = true;
	vis[u] = true;
	cal(u);
	
	for(int i = head[u]; ~i; i = e[i].nxt) {
		register int v = e[i].to; if(vis[v]) continue;
		max_num = size[v]; root = 0; get_root(v, u);
		solve(root);
	}
}

signed main() {
	memset(head, -1, sizeof head);
	n = read(), m = read();
	for(int u, v, w, i = 1; i < n; i++) u = read(), v = read(), w = read(), add(u, v, w), add(v, u, w);
	
	for(int i = 1; i <= m; i++) ques[i] = read();
	
	max_num = part[0] = n; root = 0;//这里就是一开始求重心的初始化
	get_root(1, 0);
	solve(root);
	
	for(int i = 1; i <= m; i++) {
		if(test[i]) puts("AYE");
		else puts("NAY");
	}
	return 0;
}

其实点分治也是要多做几个板子题才能较为熟练地运用。并且有个很有趣的细节要注意一下：每次我们递归点分治求重心的时候，其实赋值给max_num的size[v]并不一定就刚好是这颗子树的大小。为什么？因为我们求重心的同时各个子树的形态也一直在变呀，简单模拟一下就可以发现这一点了。但是却也真的保证了答案的正确性，毕竟最大的子树这种东西……只要够小，max_num等于多少都是相对的，还是可以选出来。

下面还推荐一个很模板的题目：洛谷P2634 聪聪可可

以及一个稍微灵活一丢丢，可以在刷完前两题就来做的题目：洛谷P2993 最短路径树问题

迎评：）
——End——