动态点分治 / 点分树学习笔记 ---- BZOJ3730 震波 / [ZJOI2017] 幻想乡的战略游戏 / [HNOI2015]开店

最新推荐文章于 2024-07-28 16:09:03 发布
最新推荐文章于 2024-07-28 16:09:03 发布
阅读量194 收藏
点赞数
分类专栏： 动态点分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sslz_fsy/article/details/90313504
版权

点分树就是将每一次的重心连起来， 形成一个深度不超过log的树

相当于将点分治的过程静态到一颗树上

实现如下， fa记录点分树上的父亲

void Divide(int u, int f){
	fa[u] = f; vis[u] = 1; int sum = Siz;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(vis[t]) continue;
		if(siz[t] > siz[u]) Siz = sum - siz[u];
		else Siz = siz[t];
		rt = 0; getrt(t, 0); Divide(rt, u);
	}
}

然后我们可以在点分树上每个点维护一种数据结构， 来完成题目中的修改要求

例1： BZOJ3730 震波

建出点分树后可以每个点维护一个树状数组， 表示 u 子树中到 u 距离为 1/2/3 ... 的点的权值和

那么 对于u的子树， <= k 的树状数组查一下就可以了。

然后考虑经过 u 在点分树上的祖先 fa， 那么是不是可以在 fa的树状数组中查 <= k - dis(fa, u) 的和呢

容斥一下将 u 子树中的贡献减掉， 于是再维护一个树状数组表示 u 子树中到 fa 距离为 1/2/3... 的点权和

这样最多查 logn次， 因为每次跳fa最多log层， 每次要log查询， 所以复杂度是 log^2

树状数组可以用 vector 动态开点， 这样空间是 nlog的

#include<bits/stdc++.h>
#define N 500050
using namespace std;
int first[N], nxt[N], to[N], tot;
void add(int x, int y){
	nxt[++tot] = first[x], first[x] = tot, to[tot] = y;
}
int n, m, val[N];
struct vec{
	vector<int> v; int s;
	void init(){ v.assign(s+10, 0);}
	void update(int x, int val){
		x++; for(;x<=s;x+=x&-x) v[x]+=val;
	}
	int Ask(int x){ 
		x++; x = min(x, s); int res = 0;
		for(;x>=1;x-=x&-x) res += v[x]; return res;
	}
}f1[N], f2[N];
int st[N][22], sign, id[N], dis[N], lg[N];
void dfs(int u, int f){
	st[++sign][0] = dis[u]; id[u] = sign;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f) continue;
		dis[t] = dis[u] + 1; dfs(t, u);
		st[++sign][0] = dis[u]; 
	}
}
int siz[N], Maxson[N], rt, Siz, vis[N];
void getrt(int u, int f){
	siz[u] = 1; Maxson[u] = 0;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f || vis[t]) continue;
		getrt(t, u); siz[u] += siz[t];
		Maxson[u] = max(Maxson[u], siz[t]);
	} Maxson[u] = max(Maxson[u], Siz - siz[u]);
	if(Maxson[u] < Maxson[rt]) rt = u;
}
int fa[N], dep[N], d[N], res;
int dist(int u, int v){
	int x = id[u], y = id[v];
	if(x > y) swap(x, y);
	int t = lg[y - x + 1];
	return dis[u] + dis[v] - 2 * min(st[x][t], st[y-(1<<t)+1][t]);
}
void getdis(int u, int f){
	d[dep[u]] += val[u]; res = max(res, dep[u]);
	for(int i=first[u];i;i=nxt[i]){ 
		int t = to[i]; if(t == f || vis[t]) continue;
		dep[t] = dep[u] + 1; getdis(t, u);
	} 
}
void calc(vec &x){
	x.s = res + 1; x.init();
	for(int i=0; i<=res; i++){
		x.update(i, d[i]); d[i] = 0;
	} res = 0; 
}
void Divide(int u, int f){
	fa[u] = f; vis[u] = 1; dep[u] = 0; getdis(u, 0); 
	calc(f1[u]); int sum = Siz;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(vis[t]) continue;
		if(siz[t] > siz[u]) Siz = sum - siz[u];
		else Siz = siz[t];
		rt = 0; getrt(t, 0); dep[t] = 1; getdis(t, 0);
		calc(f2[rt]); dep[t] = 0; Divide(rt, u);
	}
}
int ans;
int Qu(int x, int k){
	int res = 0;
	for(int i=x; i; i = fa[i]){
		res += f1[i].Ask(k - dist(i, x));
	}
	for(int i=x; fa[i]; i = fa[i]){
		res -= f2[i].Ask(k - dist(fa[i], x));
	} return res;
}
void Modify(int x, int k){	
	for(int i=x; i; i = fa[i]){
		f1[i].update(dist(x, i), k);
	}
	for(int i=x; fa[i]; i = fa[i]){
		f2[i].update(dist(fa[i], x), k);
	}
}
int main(){
	scanf("%d%d", &n, &m);
	for(int i=1; i<=n; i++) scanf("%d", &val[i]);
	for(int i=1; i<n; i++){
		int x, y; scanf("%d%d", &x, &y);
		add(x, y); add(y, x);
	} dfs(1, 0);
	for(int i=2; i<=sign; i++) lg[i] = lg[i>>1] + 1;
	for(int i=1; (1<<i) <= sign; i++)
		for(int j=1; j+(1<<i)-1 <= sign; j++)
			st[j][i] = min(st[j][i-1], st[j+(1<<(i-1))][i-1]);
	Siz = n; Maxson[0] = 1e9; 
	getrt(1, 0); 
	Divide(rt, 0); 
	while(m--){
		int op, x, y; scanf("%d%d%d", &op, &x, &y); x ^= ans; y ^= ans;
		if(op == 0) ans = Qu(x, y), printf("%d\n", ans);
		if(op == 1) Modify(x, y - val[x]), val[x] = y;
	} return 0;
}

我们经过反思后发现 ， 如果每次暴力点分治会把n个重心全部查一遍，但与当前点u有关的只有log个

我们通过点分树将这log个找出来， 并在这log个中查询，维护， 从而达到了可观的复杂度

例2：[ZJOI2017] 幻想乡的战略游戏

我们考虑假设当前最优点是x，如果修改了一个点权，就会想某个儿子偏移

我们可以枚举这个儿子（因为度数<=20）, 然后计算在这个儿子的答案，如果比当前小就往儿子走

现在有两个问题：

1. 如何快速计算在儿子的答案

2. 往儿子走有可能被卡成 n ^ 2

我们考虑在点分树上“二分”， 这样最多走log层就能到底，找到我们的答案

为了能够快速计算某个点的答案， 我们记录点分树上的点 u的子树到u的答案，sum表示

分情况讨论，画个图容斥一下就可以了：

首先加上u子树内的答案， 用dis1(u) 表示， 其次枚举 u 的祖先 fa

加上 dis1(fa) , 但是u子树内会算重， 于是减去 u的贡献， 用dis2(u)表示，最后还要把所有点从fa移到u

贡献就是 (sum(fa) - sum(u)) * dis(fa, u) 

然后修改的时候维护dis1， dis2就可以了

#include<bits/stdc++.h>
#define N 200050
using namespace std;
typedef long long ll;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;}
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
int n, m;
int first[N], nxt[N], to[N], w[N], tot;
void add(int x, int y,int z){
	nxt[++tot] = first[x], first[x] = tot;
	to[tot] = y; w[tot] = z;
}
ll dis[N], st[N][22]; 
int lg[N], sign, id[N];
int Siz, siz[N], Maxson[N], rt; 
void dfs(int u, int f){
	st[++sign][0] = dis[u]; id[u] = sign;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f) continue;
		dis[t] = dis[u] + (ll)w[i];  dfs(t, u);
		st[++sign][0] = dis[u];
	}
}
int vis[N];
ll getdis(int u, int v){
	int x = id[u], y = id[v];
	if(x > y) swap(x, y);
	int t = lg[y-x+1];
	return dis[u] + dis[v] - 2 * min(st[x][t], st[y-(1<<t)+1][t]);
}
void getrt(int u, int f){
	siz[u] = 1; Maxson[u] = 0;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f || vis[t]) continue;
		getrt(t, u); siz[u] += siz[t];
		Maxson[u] = max(Maxson[u], siz[t]);
	} Maxson[u] = max(Maxson[u], Siz - siz[u]);
	if(Maxson[u] < Maxson[rt]) rt = u;
}
int fa[N]; ll sum[N], dis1[N], dis2[N];
vector<pair<int, int> >son[N];
#define mp make_pair 
void Divide(int u, int f){
	fa[u] = f; vis[u] = 1; int sum = Siz;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(vis[t]) continue;
		if(siz[t] > siz[u]) Siz = sum - siz[u];
		else Siz = siz[t];
		rt = 0; getrt(t, 0); son[u].push_back(mp(t, rt)); 
		Divide(rt, u);
	}
}
void update(int u, ll k){
	sum[u] += k;
	for(int i=u; fa[i]; i = fa[i]){
		ll d = getdis(fa[i], u);
		dis2[i] += k * d; dis1[fa[i]] += k * d;
		sum[fa[i]] += k;
	}
}
ll calc(int u){
	ll res = dis1[u];
	for(int i=u; fa[i]; i = fa[i]){
		ll d = getdis(u, fa[i]);
		res += dis1[fa[i]] - dis2[i];
		res += d * (sum[fa[i]] - sum[i]);
	} return res;
}
ll query(int u){
	ll ans = calc(u);
	for(int i=0; i<son[u].size(); i++){
		int t = son[u][i].first, v = son[u][i].second;
		ll tmp = calc(t); if(tmp < ans) return query(v);
	} return ans;
}
int main(){
	n = read(), m = read();
	for(int i=1; i<n; i++){
		int x = read(), y = read(), z = read();
		add(x, y, z); add(y, x, z);
	} dfs(1, 0);
	for(int i=2; i<=sign; i++) lg[i] = lg[i>>1] + 1;
	for(int i=1; (1<<i) <= sign; i++)
		for(int j=1; j+(1<<i)-1<=sign; j++)
			st[j][i] = min(st[j][i-1], st[j+(1<<(i-1))][i-1]);
	Maxson[0] = 1e9; Siz = n; getrt(1, 0); int pre = rt;
	Divide(rt, 0); rt = pre;
	while(m--){
		int u = read(), k = read();
		update(u, k); 
		printf("%lld\n", query(rt));
	} return 0;
}

其实，点分树就是一种暴力，但由于树高是log， 所以暴力显现出来很优秀

这道题也其实我们，SCOI2019 DAY1T2 的另外20分做法，就是莫对+点分树

例3：[HNOI2015]开店

类似上一道题，维护前缀和就可以了

#include<bits/stdc++.h>
#define N 500050
using namespace std;
typedef long long ll;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ch = getchar(); if(ch == '-') f = -1;}
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{
 	int x; ll sum;
 	friend bool operator < (const Node &a, const Node &b){
 		return a.x < b.x;
 	}
}; vector<Node> f1[N], f2[N];
int n, m, A, x[N];
int first[N], nxt[N], to[N], w[N], tot;
void add(int x, int y, int z){
	nxt[++tot] = first[x], first[x] = tot;
	to[tot] = y, w[tot] = z;
}
ll dis[N], st[N][22]; int id[N], sign, lg[N];
void dfs(int u, int f){
	st[++sign][0] = dis[u]; id[u] = sign;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f) continue;
		dis[t] = dis[u] + (ll)w[i]; dfs(t, u);
		st[++sign][0] = dis[u];
	}
}
int siz[N], mx[N], rt, Siz, vis[N], fa[N];
void getrt(int u, int f){
	siz[u] = 1; mx[u] = 0;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == f || vis[t]) continue;
		getrt(t, u); siz[u] += siz[t];
		mx[u] = max(mx[u], siz[t]);
	} mx[u] = max(mx[u], Siz - siz[u]);
	if(mx[u] < mx[rt]) rt = u;
}
ll dist(int u, int v){
	int x = id[u], y = id[v];
	if(x > y) swap(x, y);
	int t = lg[y-x+1];
	return dis[u] + dis[v] - 2 * min(st[x][t], st[y-(1<<t)+1][t]);
}
void Divide(int u, int f){
	fa[u] = f; vis[u] = 1; int sum = Siz;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(vis[t]) continue;
		if(siz[t] > siz[u]) Siz = sum - siz[u];
		else Siz = siz[t];
		rt = 0; getrt(t, 0); Divide(rt, u); 
	} 
}
ll query(int u, int k){
	ll res = 0;
	for(int i=u; i; i=fa[i]){
		int p = lower_bound(f1[i].begin(), f1[i].end(), (Node){k, 0}) - f1[i].begin() - 1;
		res += f1[i][p].sum + 1ll * p * dist(u, i);
	}
	for(int i=u; fa[i]; i=fa[i]){
		int p = lower_bound(f2[i].begin(), f2[i].end(), (Node){k, 0}) - f2[i].begin() - 1;
		res -= f2[i][p].sum + 1ll * p * dist(u, fa[i]);
	} return res;
}
int main(){
	n = read(), m = read(), A = read();
	for(int i=1; i<=n; i++) x[i] = read();
	for(int i=1; i<n; i++){
		int x = read(), y = read(), z = read();
		add(x, y, z); add(y, x, z);
	} dfs(1, 0); 
	for(int i=2; i<=sign; i++) lg[i] = lg[i>>1] + 1;
	for(int i=1; (1<<i) <= sign; i++)
		for(int j=1; j+(1<<i)-1<=sign; j++)
			st[j][i] = min(st[j][i-1], st[j+(1<<(i-1))][i-1]);
	mx[0] = 1e9; Siz = n; getrt(1, 0);
	 Divide(rt, 0);
	for(int i=1; i<=n; i++){
		for(int u=i; u; u = fa[u]){
			f1[u].push_back((Node){x[i], dist(u, i)});
			f2[u].push_back((Node){x[i], dist(fa[u], i)});
		}
	}
	for(int u=1; u<=n; u++){
		f1[u].push_back((Node){-1, 0}); f1[u].push_back((Node){2e9, 0}); 
		f2[u].push_back((Node){-1, 0}); f2[u].push_back((Node){2e9, 0}); 
		sort(f1[u].begin(), f1[u].end());
		sort(f2[u].begin(), f2[u].end());
		for(int i=1; i<f1[u].size(); i++) f1[u][i].sum += f1[u][i-1].sum;
		for(int i=1; i<f2[u].size(); i++) f2[u][i].sum += f2[u][i-1].sum;
	}
	ll ans = 0;
	while(m--){
		int u = read(), a = read(), b = read();
		int L = min((a+ans) % A, (b+ans) % A); 
		int R = max((a+ans) % A, (b+ans) % A);	
		ans = query(u, R+1) - query(u, L);
		printf("%lld\n", ans);
	} return 0;
}

总结一下：

其实点分树就算一种精心策划的暴力，枚举fa的手法比较常见

套上容斥我们就可以知道要维护什么，利用树高的优势使复杂度正确

FSYo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
点分树/动态点分治
hipamp的博客
04-13 364
前言 点分治是一种树上分治算法，常用于处理和路径相关的统计，或者是树上满足某种条件的点对数量。 在点分治的基础上，构造一棵支持修改的树，就成了点分树。 算法理解 点分治的核心是按照重心来划分连通块，我们在递归的时候，将上一层的重心作为这一层的重心的父亲，就成了点分树。容易知道，这棵树的树高是 O(logn)O(logn)O(logn) 的，因为总共只会有 O(logn)O(logn)O(logn) 层。下面盗用 辰星凌大佬的图 来看看点分树长什么样子。 如图，上面是原树，下面是点分树。可以看到，点分树和原
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的...
cdqz2017-test8-Tree（点分树）
weixin_33817333的博客
04-03 103
n个点的带点权带边权的树，设点权为a[i]，边权为b[i] 一棵树有n*（n-1）/2个点对， 定义这棵树的价值为任意两点对的(a[x]^a[y])*dis(x,y) 有m次修改一个点的点权的操作 输出每次修改完点权后这颗树的价值 第i次的修改会影响到第i次之后的修改 第一眼：我靠怎么又是点分树 然后因为没有处理好选的点对和自己处于根的同一子树，一下午过去了，一晚上过去了，又一...
点分治、点分树的理解
最新发布
weixin_69172093的博客
07-28 259
告诉我们一棵无根树，求解树上距离关系等如有多少条长度不超过K的路径，如果直接求解可能时间复杂度会很大，我们可以通过换的重心的方式来实现降低时间复杂度。
【BZOJ】4012: [HNOI2015]开店-点分树/树剖+主席树
远行客
12-04 347
毒瘤数据结构
[HNOI2015]开店【动态点分治/点分树】
既然弱小，就只顾变强就是了
04-14 215
题目链接 Q次强制在线查询，求N个点的固定树型结构的某点u到其余范围在[L, R]区间内的点的距离之和。 又是一道动态点分治的码量题，逐渐写出手感。 首先，由于这道题没有修改操作（可以省掉好多码量了呢），我们可以用前缀和、差分这样的方法来进行求解。所以，我们先看怎样求一点到树上各点的距离，这在[ZJOI2015]幻想乡战略游戏【动态点分治/点分树】中有了初略的涉及，这里再细致的再...
BZOJ1095 动态点分治(点分树)
weixin_30486037的博客
09-16 174
题意： 操作1.修改一个点的颜色（黑白互换） 操作2.询问所有黑色点之间最远距离 点分树：当我们可以形如点分治一样的统计答案，即每次确定一个重心，然后计算他们子树之间的贡献和得出答案的时候 我们可以将每个区域的重心作为其所有子树的重心的父亲，构成一颗新的树，显然这棵树的深度不会超过logn 每次对于单点（边）更新的时候，只要对其所有的父亲更新，就只需要更新log个点，这样...
wangjunrui666#bzoj-problem##2000. [Hnoi2010]stone 取石头游戏1
07-25
然后两个玩家轮流来取石子，每次每个玩家可以取走一堆中的所有石子，但有一个限制条件：一个玩家若要取走一堆石子，则与这堆石子相邻的某堆石子已被取走(之前被某个玩家取
wangjunrui666#bzoj-problem##2017. [Usaco2009 Nov]硬币游戏1
07-25
初始时，一个有N(5 ,000)枚硬币的堆栈放在地上，从堆顶数起的第I枚硬币的币值为C_i (1 ,000)。第1行
Node.js-ZOJCH是BZOJ题库的离线版
08-09
【标题】"Node.js-ZOJCH是BZOJ题库的离线版"揭示了这个项目的核心功能，即提供一个基于Node.js平台的离线版本的BZOJ（BestCoder Judging System）题库。BZOJ是一个在线编程竞赛平台，而ZOJCH则允许用户在没有网络...
NOIP初赛知识点－信息学竞赛中的数学知识_2022_02_06（B）.pdf
02-06
NOIP初赛知识点－信息学竞赛中的数学知识 本资源摘要信息涵盖了NOIP初赛中的数学知识点，主要涉及集合运算、排列与组合、容斥原理等方面。 一、集合运算 * 集合的运算包括并、交、补、差等 * 并：∪ * 交：∩ * ...
点分树(动态点分治)
平凡人Kalzn的博客
09-26 1156
前置知识 点分治 吐槽 不知道为什么，网上有关点分树的讲解不多。而且都写的很简单（快哭了）。憨批实在是不懂。于是只能按照他们所给的思想手撸代码了。 讲解 我们在点分治中，使用了分治的思想，对于每个子树求解，我们都不会直接递归，而是找到重心后，从重心开始递归。这样在一些极端样例（一条链）的情况，仍能保证O(nlogn)O(nlogn)O(nlogn)不会退化为O(n2)O(n^2)O(n2)。这是一个很神奇的分治方式。这时我们试想这么一道题目： 给你一颗n个节点树（n<1e5），给你m次询问（m&lt
学习笔记--点分树
liusuihuashang的博客
11-03 49
然后考虑两对点，做法就是点分治套点分树，对 x,a 进行点分治，然后将在这一层的操作处理掉，按顺序对 y,b 进行点分树上的修改和查询。具体就是先建一棵点分树，然后将每个操作压入所有涉及到的分治重心上，这里直接在点分树上跳就可以。点分树是通过更改原树形态使树的层数变为稳定 log⁡� 的一种重构树。就是通过点分治找重心的方式，将这一层重心为上一层重心的儿子。子任务二可以直接拿点分树做，就是对于每个重心维护到这个点距离最近的点的距离。—— oi-wiki。一开始发现建树错了，然后发现是原先的点分治错了。
点分树 note
weixin_45743001的博客
08-30 654
算法原理 点分树是以点分治为基础的，把原树“化实为虚”的构造。我们在点分治的过程中，存储每个分治重心的上级重心，也就是点分树的父子关系。显然，根据点分治的原理，点分树的树高是log⁡n的。这样，我们可以利用这棵树来跑一些类似“从询问点出发，不断跳fa”的暴力，来解决一些树上的多次询问/修改问题。 一个比较常见的套路是这样的： 进行一次点分治，求出每个点在点分树上的父节点。 对于每个点，开一个数据结构S1存储点分树子树的贡献，再开一个数据结构S2​存储点分树父亲的贡献，用来容斥，防止算重。 对x进
[BZOJ1095]-[ZJOI2007]Hide 捉迷藏-点分树
泉華子的OI足迹
01-09 757
说在前面 刚刚得知me居然可以去冬眠，开心!!! 本来今天要写很多很多的点分树的…然而上午去陪替罪羊玩，下午又被指针调戏… （只要订了计划就一定完不成系列） 题目 BZOJ1095传送门 题目大意 给出一个N个点的无根树，节点有黑或白两种颜色，初始时节点全是黑色，现在有以下两个操作： 1. G ：询问树上最远的黑色点对的距离，如果只有一个黑点则输出0，没有黑点则输出-1...
点分治和点分树
啊宸的前博客
03-07 403
文章目录吐槽题目[IOI2011]Racecf716 E. Digit Treecf293 E. Close Verticesbzoj3730: 震波cf757 G. Can Bash Save the Day? 吐槽 去年送我退役的好东西。写了一道题就觉得自己已经会动态点分治的我真是too young too simple,sometimes naive. 现在至少不像去年抓破脑壳写个模板了。然...
关于点分治的理解
anzhi7214的博客
09-27 139
【引言】 由于树具有一般的图没有的特点，所以在竞赛中的应用更广。 在一些树上路径问题中，暴力求解时间复杂度过高，往往需要一些更为高效的算法，点分治就是其中之一。 【流程】 1、首先选取一个点，把无根树变成有根树。 　　那么如何选点呢？ ——树型动规 　　因为树是递归定义的，所以我们当然希望递归的层数最小。 　　每次选取的点，要保证与此点相连的结点数最多的连通块的结点数...
【BZOJ2566】xmastree（点分树）
zxyoi_dreamer的博客（不定期诈尸）
09-27 303
传送门 题解： 可能手残到了一定程度才会像我一样在算子树siz的时候将siz[u]+=siz[v]打成siz[v]+=siz[u]，然后莫名其妙挂一堆点 思路挺简单，码起来没什么细节就是有点长~ 建立点分树，每个分治中心维护两个东西，各个子树中每种颜色到自己的最小距离的序列，自己掌管的子树中每种颜色的点到分治父亲的距离的序列。 显然自己更新答案就是考虑每种颜色将两个来自不同子树的路径拼起来，然后...
BZOJ JOI 2013-2014春季训练合宿题目解析1
"BZOJ JOI 2013~2014 春季training合宿 系列题解1" 这篇题解涉及到的是一个编程竞赛中的题目，主要运用了哈希算法来解决。哈希算法在计算机科学中是一种高效的数据结构和算法，它能够快速查找、插入和删除元素，其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FSYo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值