树上启发式合并 (dfs on tree)

已于 2023-09-16 11:56:44 修改
阅读量92 收藏
点赞数
分类专栏： 图论 笔记 文章标签： 算法
于 2022-10-10 17:46:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50815157/article/details/127249290
版权

文章目录

例题引入（来自OI-wiki）

在这里插入图片描述
代码模板

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define all(x) begin(x),end(x)
#define debug(x) cout<<#x<<": "<<x<<endl;
using namespace std;
using ll = long long;
const int N = 1e5 + 10;

// 计算每个不同子树中有多少种不同的颜色  (本题也可以在dfs序上莫队)

int n;
vector<int> g[N];
int sz[N], son[N], col[N], L[N], R[N], node[N], totdfn;
int ans[N], cnt[N], totColor;

void add(int u) {
	if (cnt[col[u]] == 0)	++ totColor;
	cnt[col[u]] ++;
}

void del(int u) {
	cnt[col[u]] --;
	if (cnt[col[u]] == 0)	-- totColor;
}

int getAns() {
	return totColor;
}

void dfs(int u, int fa) {
	L[u] = ++ totdfn;
	node[totdfn] = u;
	sz[u] = 1;
	for (int &v: g[u]) {
		if(v == fa)	continue;
		dfs(v, u);
		sz[u] += sz[v];
		if (!son[u] or sz[son[u]] < sz[v])	son[u] = v;
	}
	R[u] = totdfn;
}

void DFS(int u, int fa, bool keep) {
	// 先算轻儿子，后算重儿子，且重儿子保留
	for (int v: g[u]) {
		if (v == fa or v == son[v])	continue;
		DFS(v, u, false);
	}
	if (son[u])	DFS(son[u], u, true);
	// 因轻儿子未保留，需要重新加回来
	for (int v: g[u]) {
		if (v == fa or v == son[u])	continue;
		for (int i = L[v]; i <= R[v]; i ++)	add(node[i]);
	}
	add(u);  // 加上节点u自己
	ans[u] = getAns();  // 得到以u为根的子树答案

	if (keep == false) {
		for (int i = L[u]; i <= R[u]; i ++)	del(node[i]);
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n;
	for (int i = 1; i <= n; i ++)	cin >> col[i];
	for (int i = 1; i < n; i ++) {
		int u, v;
		cin >> u >> v;
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1, 0);
	dfs(1, 0, false);
	for (int i = 1; i <= n; i ++)	cout << ans[i] << " \n"[i == n];
	
	return 0;
}

CF600E Lomsat gelral

在这里插入图片描述

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define all(x) begin(x),end(x)
#define debug(x) cout<<#x<<": "<<x<<endl;
using namespace std;
using ll = long long;
const int N = 1e5 + 10;

int n, col[N], cnt[N];
vector<int> g[N];
int sz[N], son[N], L[N], R[N], node[N], totdfn;

void dfs(int u, int fa) {
	L[u] = ++ totdfn; node[totdfn] = u;
	sz[u] = 1;
	for (int v: g[u]) {
		if (v == fa)	continue;
		dfs(v, u);
		sz[u] += sz[v];
		if (!son[u] or sz[v] > sz[son[u]])	son[u] = v;
	}
	R[u] = totdfn;
}

ll ans[N], res, mxcnt;
void add(int u) {
	cnt[col[u]] ++;
	if (cnt[col[u]] > mxcnt) {
		res = col[u];
		mxcnt = cnt[col[u]];
	} else if (cnt[col[u]] == mxcnt) {
		res += col[u];
	}
}

void del(int u) {
	// 这里没有对res和mxcnt维护，因为已经清零了
	cnt[col[u]] --;
}

void DFS(int u, int fa, bool keep) {
	for (int v: g[u]) {
		if (v == fa or v == son[u])	continue;
		DFS(v, u, false);
	}
	if (son[u])	DFS(son[u], u, true);

	for (int v: g[u]) {
		if (v == fa or v == son[u])	continue;
		for (int i = L[v]; i <= R[v]; i ++)	add(node[i]);
	}
	add(u);
	ans[u] = res;
	if (keep == false) {
		res = mxcnt = 0;  // 全部清零，del函数中无需对res和mxcnt维护
		for (int i = L[u]; i <= R[u]; i ++)	del(node[i]);
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n;
	for (int i = 1; i <= n; i ++)	cin >> col[i];
	for (int i = 1; i < n; i ++) {
		int x, y;
		cin >> x >> y;
		g[x].push_back(y);
		g[y].push_back(x);
	}

	dfs(1, 0);
	DFS(1, 0, false);

	for (int i = 1; i <= n; i ++)	cout << ans[i] << " \n"[i == n];
	
	return 0;
}

CF570D Tree Requests

在这里插入图片描述
1 ≤ n , m ≤ 5 e 5 1\le n,m \le5e5 1≤n,m≤5e5

sol:
维护同一深度上 26 26 26个字母的情况。
只有当这 26 26 26个字母中出现次数为奇数的个数不大于 1 1 1时才能构成回文。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define all(x) begin(x),end(x)
#define debug(x) cout<<#x<<": "<<x<<endl;
using namespace std;
using ll = long long;
const int N = 5e5 + 10;

int n, m, d[N];
char s[N];
vector<int> g[N];
int sz[N], son[N], L[N], R[N], node[N], totdfn;

void dfs(int u, int fa) {
	sz[u] = 1, d[u] = d[fa] + 1;
	L[u] = ++ totdfn; node[totdfn] = u;
	for (auto& v: g[u]) {
		if (v == fa)	continue;
		dfs(v, u);
		sz[u] += sz[v];
		if (!son[u] or sz[v] > sz[son[u]])	son[u] = v;
	}
	R[u] = totdfn;
}

vector<pair<int, int>> Q[N];
array<int, 26>	cnt[N];
bool ok[N];

bool check(int dep) {
	int odd = 0;
	for (auto& x: cnt[dep]) {
		if (x & 1)	odd ++;
	}
	return odd <= 1;
}

void add(int u) {
	cnt[d[u]][s[u] - 'a'] ++;
}
void del(int u) {
	cnt[d[u]][s[u] - 'a'] --;
}

void DFS(int u, int fa, bool keep) {
	for (auto& v: g[u]) {
		if (v == fa or v == son[u])	continue;
		DFS(v, u, false);
	}
	if (son[u])	DFS(son[u], u, true);

	for (auto& v: g[u]) {
		if (v == fa or v == son[u])	continue;
		for (int i = L[v]; i <= R[v]; i ++)	add(node[i]);
	}
	add(u);
	for (auto &[dep, id]: Q[u])	ok[id] = check(dep);

	if (keep == false) {
		for (int i = L[u]; i <= R[u]; i ++)	del(node[i]);
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n >> m;
	for (int i = 2; i <= n; i ++) {
		int p; cin >> p;
		g[p].push_back(i);
	}
	cin >> s + 1;
	for (int i = 1; i <= m; i ++) {
		int a, b;
		cin >> a >> b;
		Q[a].emplace_back(b, i);
	}

	dfs(1, 0);
	DFS(1, 0, false);

	for (int i = 1; i <= m; i ++)	cout << (ok[i] ? "Yes" : "No") << '\n';
	
	return 0;
}

wannafly Day2 E 阔力梯的树

在这里插入图片描述
sol:
用一个 s e t set set维护当前所有节点。
插入时在set中查找前驱后继，并计算贡献。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define all(x) begin(x),end(x)
#define debug(x) cout<<#x<<": "<<x<<endl;
using namespace std;
using ll = long long;
const int N = 1e5 + 10;

int n;
vector<int> g[N];
int sz[N], son[N], L[N], R[N], node[N], totdfn;
set<int> S;
ll ans[N], res;

void add(int u) {
	if (S.empty()) {
		S.insert(u);
		return ;
	}
	auto it = S.lower_bound(u);
	if (it == S.begin()) {
		ll x = *S.begin();
		res += (x - u) * (x - u);
	} else if (it == S.end()) {
		ll x = *--S.end();
		res += (x - u) * (x - u);
	} else {
		ll y = *it, x = *--it;
		res += 2ll*u*u - 2*u*(x+y) + 2*x*y;
	}
	S.insert(u);
}

void dfs(int u, int fa) {
	sz[u] = 1;
	L[u] = ++ totdfn; node[totdfn] = u;
	for (auto& v: g[u]) {
		if (v == fa)	continue;
		dfs(v, u);
		sz[u] += sz[v];
		if (!son[u] or sz[v] > sz[son[u]])	son[u] = v;
	}
	R[u] = totdfn;
}

void DFS(int u, int fa, bool keep) {
	for (auto& v: g[u]) {
		if (v == fa or v == son[u])	continue;
		DFS(v, u, false);
	}
	if (son[u])	DFS(son[u], u, true);
	for (auto& v: g[u]) {
		if (v == fa or v == son[u])	continue;
		for (int i = L[v]; i <= R[v]; i ++)	add(node[i]);
	}
	add(u);
	ans[u] = res;
	if (keep == false) {
		S.clear();
		res = 0;
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n;
	for (int i = 2; i <= n; i ++) {
		int p; cin >> p;
		g[p].push_back(i);
	}
	dfs(1, 0);
	DFS(1, 0, false);
	for (int i = 1; i <= n; i ++)	cout << ans[i] << "\n";
	
	return 0;
}

CF208E Blood Cousins

在这里插入图片描述
sol:
对于每一个询问 v , p v,p v,p，用倍增找到 v v v的 p p p级祖先 u u u，然后在以 u u u为根的子树中，与 v v v深度相同的节点个数 − 1 -1 −1即是 v v v的 p p p级表亲的个数。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define all(x) begin(x),end(x)
#define debug(x) cout<<#x<<": "<<x<<endl;
using namespace std;
using ll = long long;
const int N = 1e5 + 10;

int n, m, limit, d[N];
vector<int> g[N];
int f[N][22];
int sz[N], L[N], R[N], son[N], node[N], totdfn;
vector<pair<int, int>> Q[N];  // Q[p-fa] : {v, id}
int ans[N], cnt[N];  // cnt[i] 当前深度为i的节点有多少

void dfs(int u) {
	L[u] = ++totdfn; node[totdfn] = u;
	sz[u] = 1; d[u] = d[f[u][0]] + 1;
	for (int i = 1; i <= limit; i ++)
		f[u][i] = f[f[u][i - 1]][i - 1];
	for (auto& v: g[u]) {
		if (v == f[u][0])	continue;
		f[v][0] = u;
		dfs(v);
		sz[u] += sz[v];
		if (!son[u] or sz[v] > sz[son[u]])	son[u] = v;
	}
	R[u] = totdfn;
}

void add(int u) {
	cnt[d[u]] ++;
}
void del(int u) {
	cnt[d[u]] --;
}

void DFS(int u, bool keep) {
	for (auto& v: g[u]) {
		if (v == f[u][0] or v == son[u])	continue;
		DFS(v, false);
	}
	if (son[u])	DFS(son[u], true);
	for (auto& v: g[u]) {
		if (v == f[u][0] or v == son[u])	continue;
		for (int i = L[v]; i <= R[v]; i ++)	add(node[i]);
	}
	add(u);
	for (auto& [v, id]: Q[u])	ans[id] = cnt[d[v]] - 1;
	if (keep == false) {
		for (int i = L[u]; i <= R[u]; i ++)	del(node[i]);
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> n;
	limit = log2(n);
	vector<int> rt;
	for (int i = 1; i <= n; i ++) {
		int p; cin >> p;
		if (p == 0)rt.push_back(i);
		else	g[p].push_back(i);
	}

	for (auto& root: rt)	dfs(root);
	
	cin >> m;
	for (int i = 1; i <= m; i ++) {
		int v, p;
		cin >> v >> p;
		int u = v;
		for (int j = limit; j >= 0; j --)
			if (p >> j & 1)	u = f[u][j];
		Q[u].emplace_back(v, i);
	}
	for (auto& root: rt)	DFS(root, false);
	for (int i = 1; i <= m; i ++)	cout << ans[i] << " \n"[i == m];
	
	return 0;
}
proudzhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树上启发式合并（dsu on tree）
UniverseofHK的博客
01-01 401
Lomsat gelral 之前没有记录过dsu on tree，挑了一个板子题记录一下 DSU on tree（Disjoint Set Union，树上启发式合并） 思想：利用每个节点到根节点路径上的轻边数复杂度是logloglog级别的，同时只有当每次遍历轻边时才会将整棵轻边连接的子树额外暴力遍历一遍，所以每个节点被暴力遍历的次数就是logloglog级别的，这样就保证了整体复杂度在log...
树上启发式合并（DSU on Tree）
KaiserWilheim的博客
12-17 535
一种在 O(nlogn) 复杂度内求树上问题的算法。
树上启发式合并 dsu on tree
ylxmf2005's Blog
02-20 165
dsu on tree 用来解决树上问题。可以在 O(nlog⁡n)O(n \log n)O(nlogn) 中完成对静态的子树统计。但是，不支持修改，只能对子树统计，不能链上统计。 我们来看一个问题。有一棵树，每个点有一个权值。求这棵树的每一棵子树的众数权值之和，如果有多个众数那么都要统计。先考虑 O(n2)O(n^2)O(n2) 的暴力，对于每一棵子树，遍历这棵子树的所有点，用一个桶记录每一个数...
「dsu on tree」树上启发式合并
wzw
06-01 811
dsu on tree-树上启发式合并 这篇博客持续更新，先放一个题目，后续补上个人对树上启发式合并的理解，算法复杂度证明以及更多的例题 hdu4358 解法一 ⇒\Rightarrow⇒ dfs序加莫队 #include<iostream> #include<cstdio> #include<algorithm> #include<vector&gt...
学习笔记：树上启发式合并（DSU on tree）
weixin_55851276的博客
11-03 402
求每个子树中最长的Dokhtar-kosh路径的长度。这个集合的大小可以认为是集合的高度（在正常情况下），而我们将集合高度小的并到高度大的显然有助于我们找到父亲。在这里，对于两个大小不一样的集合，我们将小的集合合并到大的集合中，而不是将大的集合合并到小的集合中。让高度小的树成为高度较大的树的子树，这个优化可以称为启发式合并算法。启发式算法是基于人类的经验和直观感觉，对一些算法的优化。首先可以分析出来，合法的Dk路径一定是上面的所有。到全局根的路径上的字母信息，新增一个字母改变奇偶性可以通过。
树上启发式合并（dsu on tree）学习
wr114514的博客
04-13 725
介绍了树上启发式合并在实际解题中的应用。
树上启发式合并（DSU ON TREE）
m0_53899788的博客
05-09 420
算法过程 对于树上的一个节点uuu，按照以下步骤执行： 遍历 uuu 的轻儿子，计算轻儿子的答案，不保留对 uuu 的贡献 遍历 uuu 的重儿子，计算重儿子的答案，保留对 uuu 的贡献 遍历 uuu 的轻儿子，加入其对 uuu 的贡献，得到 uuu 的答案 一般来说，没有修改、只对子树进行询问(或者转化成子树的答案) 就可以用 dsu on tree。 时间复杂度 根节点到任意节点的轻边数不超过 lognlognlogn 条。设根节点 rootrootroot 到节点 uuu 的路径中有 xxx 条
[dsu on tree]树上启发式合并总结（算法思想及模板附例题练习）
12-04 1025
临考前乱杀新算法
树上启发式合并
qq_35975367的博客
07-27 465
文章内容选自OI Wiki 内容： 树上启发式合并（dsu on tree）对于某些树上离线问题可以速度大于等于大部分算法且更易于理解和实现的算法。 例题： 给出一棵 n个节点以 1为根的树，节点 u的颜色为cu ，现在对于每个结点 u询问 u子树里一共出现了多少种不同的颜色。 n<=2e5 树套树可以解决，如果可以离线的话，树上莫队复杂度带根号，现在我们要用一个带log的算法。 对于直接暴力复杂度为O(n^2),即对每一个子节点进行一次遍历， 对于每个节点的答案是由其子树和其本身得到的，现在考虑利
(树上启发式合并)dsu on tree 学习报告总结
qq_44341728的博客
10-30 327
树上启发式合并： 简介：它是用来解决一类树上询问问题，一般这种问题有两个特征 1、只有对子树的询问 2、没有修改 一般这时候就可以强上dsu on tree了 update：可能特征1不会很显然，就是说题目中不一定明确的问你子树i的答案，可能是把问题转化后需要算子树的答案 （妈妈再也不用担心我不会线段树合并了… ） 流程： 1.O(n)计算出每一个点的重儿子 2.对于节点i： –遍历每一个节点：递...
启发式搜索-TSP.zip
06-28
采用启发式搜索解决 TSP问题，通过构造最小生成树来 构造闭合回路 寻求最小路径的回路
博弈树的启发式搜索
04-16
人工智能中博弈树的启发式搜索策略，分为极大极小算法和α-β剪枝技术！
【省选模拟】世界树（点分治）（单调队列）（启发式合并）
01-06
这个东西是个单点修改区间加，所以考场我就码了个深度为下标的线段树，单修区查 maxmaxmax。 于是复杂度是美妙的 nlog(n)3nlog(n)^3nlog(n)3。 考虑把 [L,R][L,R][L,R] 的限制用单调队列来解决，这样就可以做到 nlog...
matlab多目标mfo飞蛾扑火启发式算法
04-17
matlab多目标mfo飞蛾扑火启发式算法
基于组合启发式算法的三维装箱
05-01
三维装箱 基于组合启发式算法的三维装箱
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 358
unordered_map实现输出前k个高频元素
回溯之分割回文串
最新发布
JINbigXIA的博客
06-04 201
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1231
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 458
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
启发式算法 启发式函数
04-28
启发式算法是一种基于经验和启发性思路的优化算法，通常用于在大规模搜索空间中寻找最优解或次优解。启发式算法不保证找到全局最优解，但是通常可以在可接受的时间内找到较优解。 启发式函数是一种评估函数，用于启发式算法中对搜索状态进行评估和排序。启发式函数通常基于问题的特征和经验知识，可以评估当前搜索状态的优劣程度，指导搜索方向和决策。在搜索过程中，启发式函数最优值越接近真实最优解，启发式算法搜索效率就越高。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值