树上启发式合并 学习笔记

已于 2023-04-06 21:09:08 修改
阅读量427 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： 学习
于 2023-02-05 23:33:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sophilex/article/details/128894867
版权

又叫dsu on tree，一般用来解决下面这类问题

1.只有对子树的查询

2.没有修改操作

其实就有点像并查集里面的启发式合并，只不过是在树上做信息合并罢了。

先来看一道祖传例题

cf600 E

大意：

给出一个树，求出每个节点的子树中出现次数最多的颜色的编号和

思路：

想一想，我们如果暴力的话，就是对每一个节点做dfs，时间复杂度是n^2级别的。

考虑优化，发现只有对子树的询问，所以我们不难想到树链剖分，这样之后子树问题就转化为了序列问题，然后可以再用莫队来解决，时间复杂度来到了n*sqrt(n)级别的。

如果再优化的话，就是今天的dsu on tree了。时间复杂度可以达到nlogn

想一想，启发式合并做的是什么？是把小的一堆信息合并到大的信息上去，那么在树上如何区分信息大小？就是子树大小。那么我们应该如何确定要作为被合并的子树？显然取最大的子树对应的根节点，也就是重儿子。那么，一顿树剖之后，我们就可以确定合并对象了。

再想想，对于普通暴力的做法（虽然时间复杂度已经炸了），显然我们需要一个cnt数组记录每一种颜色的数量，如果每次对一个节点完成查询后清除cnt数组，我们的空间复杂度就不会炸，否则就MLE了。树上启发式也一样，对于儿子的信息查询之后，我们势必要清空数组，但是我们可以合并信息，这也就意味着，如果我们最后对重儿子进行查询的话，查完之后的cnt数组并不用清空，我们可以直接将其它子树的信息合并上去（当然轻儿子的查询是要清空信息的）。

这样一来，重链我们只会访问一次（查询时），加上轻链的边数不会超过logn（因为轻链意味着每一层都要减去至少一半的节点数），我们的时间复杂度就可以达到nlogn。

综上，我们首先一遍dfs找到重儿子。第二遍dfs的时候，首先对轻儿子dfs，然后对重儿子dfs，然后合并信息，最后清除轻儿子的影响即可。这其中合并信息和清除影响可以用一个函数实现，因为清除影响等价于沿路的对应颜色数-1。

code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=1e5+10;
struct ty
{
	ll t,l,next;
}edge[N<<1];
ll cn=0;
ll head[N];
ll flag=0;//标记重儿子 
ll sum=0,ma=0;
void add_edge(ll a,ll b,ll c)
{
	edge[++cn].t=b;
	edge[cn].l=c;
	edge[cn].next=head[a];
	head[a]=cn;
}
ll n;
ll col[N],siz[N],son[N],cnt[N],ans[N]; 
void init_dfs(ll id,ll fa)
{
	siz[id]=1;
	ll sn=0;
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa) continue;
		init_dfs(y,id);
		siz[id]+=siz[y];
		if(siz[y]>siz[sn])
		{
			sn=y;
		}
	}
	son[id]=sn;
}
void add(ll id,ll fa,ll val)
{
	cnt[col[id]]+=val;
	if(cnt[col[id]]>ma)
	{
		ma=cnt[col[id]];
		sum=col[id];
	}
	else if(cnt[col[id]]==ma)
	{
		sum+=col[id];
	}
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa||y==flag) continue;
		add(y,id,val);
	}
}
void dfs2(ll id,ll fa,ll kp)
{
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa) continue;
		if(y==son[id]) continue;
		dfs2(y,id,0); 
	}
	if(son[id]) dfs2(son[id],id,1),flag=son[id];
	add(id,fa,1);//添加 
	flag=0;//清空以免影响后面的删除操作
	ans[id]=sum;
	if(kp==0)
	{
		add(id,fa,-1);
		sum=0;
		ma=0;
	}
}
void solve()
{
	memset(head,-1,sizeof head);
	cin>>n;
	for(int i=1;i<=n;++i) cin>>col[i];
	for(int i=1;i<n;++i)
	{
		ll a,b;
		cin>>a>>b;
		add_edge(a,b,1);
		add_edge(b,a,1);
	}
	init_dfs(1,0);
	dfs2(1,1,0);
	for(int i=1;i<=n;++i) cout<<ans[i]<<" ";
	cout<<endl;
}
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	solve();
	return 0;
}

这里再来一道差不多的题目

Tree Requests

大意：给定一棵树，以1为根，每一个节点上面有一个字母，定义节点的深度为其到1号节点的路径上的点数。m次查询，查询以a为根的子树内深度为b的节点上的字母重排之后能否构成回文串。

思路：

先考虑一波构成回文串的条件，显然就是要求个数为奇数的字母不超过一个，那么我们只要设一个cnt数组来记录深度为i，字母为j的节点数量即可，其它的就跟上一题没有多大差别了

另外，这里的深度是固定的，而不是对于子树深度要求重排，所以深度也只用记录一次，那么就很简单了

code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=5e5+10;
struct ty
{
	ll t,l,next;
}edge[N<<1];
ll cn=0;
ll head[N];
void add_edge(ll a,ll b,ll c)
{
	edge[++cn].t=b;
	edge[cn].l=c;
	edge[cn].next=head[a];
	head[a]=cn;
}
ll n,m;
ll siz[N],son[N],dep[N],col[N];
vector<pair<ll,ll>> vt[N];
ll cnt[N][30],ans[N];
ll son_flag=0;
void init_dfs(ll id,ll fa)
{
	siz[id]=1;
	ll sn=0;
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa) continue;
		dep[y]=dep[id]+1;
		init_dfs(y,id);
		siz[id]+=siz[y];
		if(siz[y]>siz[sn])
		{
			sn=y;
		}
	}
	son[id]=sn;
}
bool check(ll dep)//深度信息 
{
	ll num=0;
	for(int i=0;i<26;++i)
	{
		num+=(cnt[dep][i]%2);
	}
	return num<=1;
}
void add(ll id,ll fa,ll val)
{
	cnt[dep[id]][col[id]]+=val;
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==son_flag||y==fa) continue;
		add(y,id,val);
	}
}
void dfs2(ll id,ll fa,ll kp)
{
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa||y==son[id]) continue;
		dfs2(y,id,0);
	}
	if(son[id])
	{
		dfs2(son[id],id,1);
		son_flag=son[id];
	}
	add(id,fa,1);
	son_flag=0;
	//统计
	for(auto op:vt[id])
	{
		ans[op.first]=check(op.second);	
	} 
	if(kp==0)
	{
		add(id,fa,-1);
	}
}
void solve()
{
	memset(head,-1,sizeof head);
	cin>>n>>m;
	dep[1]=1;
	for(int i=2;i<=n;++i)
	{
		ll a;
		cin>>a;
		add_edge(a,i,1);
		add_edge(i,a,1);	
	}
	for(int i=1;i<=n;++i){
		char sdd;
		cin>>sdd;
		col[i]=(sdd-'a');
	}
	for(int i=1;i<=m;++i)
	{
		ll a,b;
		cin>>a>>b;
		vt[a].push_back(make_pair(i,b));
	}
	init_dfs(1,0);
//	for(int i=1;i<=n;++i) cout<<dep[i]<<' ';
	dfs2(1,0,0);
	for(int i=1;i<=m;++i) cout<<(ans[i]?"Yes":"No")<<endl;
} 
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	solve();
	return 0;
}

再来一个

Dominant Indices
大意：

给定一棵以 1 为根，n 个节点的树。设 d(u,x) 为 u 子树中到 u 距离为 x 的节点数。

对于每个点，求一个最小的 k，使得d(u,k) 最大。

思路：

跟前面差不多，维护一下深度再记录一下最大值就可以了

考虑到最大值标记ma在add操作中不能重置，我们应该在撤销影响后初始化ma

code

#include<bits/stdc++.h>
using namespace std;
#define ll int
#define endl '\n'
const ll N=1e6+10;
struct ty
{
	ll t,l,next;
}edge[N<<1];
ll cn=0;
ll head[N];
void add_edge(ll a,ll b,ll c)
{
	edge[++cn].t=b;
	edge[cn].l=c;
	edge[cn].next=head[a];
	head[a]=cn;
}
ll n,m;
ll siz[N],son[N],dep[N],col[N];
ll cnt[N],ans[N];
ll son_flag=0;
ll ma=0,p=0;
void init_dfs(ll id,ll fa)
{
	siz[id]=1;
	ll sn=0;
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa) continue;
		dep[y]=dep[id]+1;
		init_dfs(y,id);
		siz[id]+=siz[y];
		if(siz[y]>siz[sn])
		{
			sn=y;
		}
	}
	son[id]=sn;
}
void add(ll id,ll fa,ll val)
{
	cnt[dep[id]]+=val;
	if(cnt[dep[id]]>ma||(cnt[dep[id]]==ma&&dep[id]<p))
	{
		ma=cnt[dep[id]];
		p=dep[id];
	}
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==son_flag||y==fa) continue;
		add(y,id,val);
	}
}
void dfs2(ll id,ll fa,ll kp)
{
	for(int i=head[id];i!=-1;i=edge[i].next)
	{
		ll y=edge[i].t;
		if(y==fa||y==son[id]) continue;
		dfs2(y,id,0);
	}
	if(son[id])
	{
		dfs2(son[id],id,1);
		son_flag=son[id];
	}
	
	add(id,fa,1);
	son_flag=0;
	//统计
	//cout<<id<<' '<<ma<<" "<<p<<' '<<dep[id]<<endl;
	ans[id]=p-dep[id];
	
	if(kp==0)
	{
		add(id,fa,-1);
		ma=0,p=0;
	}
	//
}
void solve()
{
	memset(head,-1,sizeof head);
	cin>>n;
	for(int i=2;i<=n;++i)
	{
		ll a,b;
		cin>>a>>b;
		add_edge(a,b,1);
		add_edge(b,a,1);	
	}
	init_dfs(1,0);
	dfs2(1,0,1);
	for(int i=1;i<=n;++i) cout<<ans[i]<<endl;
} 
int main()
{
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	solve();
	return 0;
}

Tree and Queries

还是板子题

  • 给定一棵 n 个节点的树，根节点为 1。每个节点上有一个颜色ci​。�m 次操作。操作有一种：
    1. u k：询问在以 u 为根的子树中，出现次数 ≥k 的颜色有多少种

唯一可能有点绕的地方应该就是对大于等于k的次数的处理

那么这个其实也很好解决。我们不难发现，大于等于i的数字，一定是从大于等于i-1的地方转移过来的，所以我们只要在每次add操作的时候O(1)去更新一下就可以了

code

#include<bits/stdc++.h>
#include <cstring>
using namespace std;
#define ll long long
#define endl '\n'
const ll N=1e5+10;
struct ty
{
    ll t,next;
}edge[N<<1];
ll head[N];
ll cn=0;
void add_edge(ll a,ll b)
{
    edge[++cn].t=b;
    edge[cn].next=head[a];
    head[a]=cn;
}
ll n,m;
ll Flag;
ll siz[N],son[N],col[N];
pair<ll,ll> q[N];
ll num[N],dk[N];
map<ll,ll> ans[N];
vector<ll> vt[N];
void init_dfs(ll id,ll fa)
{
    siz[id]=1;
    ll sn=0;
    for(int i=head[id];i!=-1;i=edge[i].next)
    {
        ll y=edge[i].t;
        if(y==fa) continue;
        init_dfs(y,id);
        siz[id]+=siz[y];
        if(siz[y]>sn)
        {
            sn=siz[y];
            son[id]=y;
        }
    }
}
void add(ll id,ll fa,ll val)
{
    if(val==-1) dk[num[col[id]]]--;
    num[col[id]]+=val;
    if(val==1) dk[num[col[id]]]++;
    for(int i=head[id];i!=-1;i=edge[i].next)
    {
        ll y=edge[i].t;
        if(y==fa||y==Flag) continue;
        add(y,id,val);
    }
}
void dfs2(ll id,ll fa,ll op)
{
    for(int i=head[id];i!=-1;i=edge[i].next)
    {
        ll y=edge[i].t;
        if(y==fa||y==son[id]) continue;
        dfs2(y,id,0);
    }
    if(son[id]) dfs2(son[id],id,1),Flag=son[id];
    add(id,fa,1);
    Flag=0;
    for(auto s:vt[id])
    {
        ans[id][s]=dk[s];
    }
    if(op==0)
    {
        add(id,fa,-1);
    }
}
void solve()
{
    memset(head,-1,sizeof(head));
    cin>>n>>m;
    for(int i=1;i<=n;++i) cin>>col[i];
    for(int i=1;i<n;++i)
    {
        ll a,b;
        cin>>a>>b;
        add_edge(a,b);
        add_edge(b,a);
    }
    for(int i=1;i<=m;++i)
    {
        ll a,b;
        cin>>a>>b;
        vt[a].push_back(b);
        q[i]=make_pair(a,b);
    }
    init_dfs(1,0);
    dfs2(1,0,0);
    for(int i=1;i<=m;++i)
    {
        ll a=q[i].first;
        ll b=q[i].second;
        cout<<ans[a][b]<<endl;
    }
}
int main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    solve();
    return 0;
}

前面都是小菜，这里再来一个压轴难度的

sophilex
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习笔记】树上启发式合并
繁凡さん的博客
07-26 594
整理的算法模板合集： ACM模板 点我看算法全家桶系列！！！ 实际上是一个全新的精炼模板整合计划 Problem 给定一棵有根树，每条边的权值是 ['a','v'] 的一个字母。现对于每个树上点，求出最长的一条 “回文” 路径。“回文” 路径的含义是将路径上所有的字母取出，可以组成一个回文串。 1≤n≤5×1051\le n\le 5\times 10^51≤n≤5×105 Solution Code ...
启发式算法 TS 用于学习
07-27
**启发式算法与禁忌搜索（TS）** 启发式算法是一种基于经验和直觉的搜索策略，它在解决问题时并不保证找到全局最优解，但通常能在较短的时间内找到近似最优解。这种算法常用于复杂的优化问题，如旅行商问题、车辆...
树上启发式合并（作为初学者的一点领悟）
m0_53430148的博客
08-29 1654
浅谈 启发式合并，顾名思义就是用来处理合并类的问题的。它是数据结构相关问题中的一种重要思想，原则是：把“小的结构”合并到“大的结构”中，并且只增加“小的结构的代价”，因此可以减少时间复杂度 正文 先来一道例题吧！E. Lomsat gelral 大意即为:给定一颗树（以1为根节点）， 每棵树上都有一种颜色， 对于每个顶点v，找出顶点v的子树中所有数量最多的颜色的编号总和。 一个朴素做法的时间复杂度是O(n2)的， 这道题用到的启发式合并就是用来优化这个朴素做法的。 朴素做法：对于每个节点，暴力遍历子树，将它
树上启发式合并学习笔记
CSU_WJJJ
01-27 101
洛谷日报 例题 #include<bits/stdc++.h> using namespace std; typedef long long ll; #define inf 0x3f3f3f3f #define endl '\n' struct edge{ int nxt,to; }e[200050]; ll col[100050],cnt[100050],ans[100050],sum,mx; int head[100050],a[100050],ct,sz[100050],son[1
学习笔记：树上启发式合并（DSU on tree）
weixin_55851276的博客
11-03 536
求每个子树中最长的Dokhtar-kosh路径的长度。这个集合的大小可以认为是集合的高度（在正常情况下），而我们将集合高度小的并到高度大的显然有助于我们找到父亲。在这里，对于两个大小不一样的集合，我们将小的集合合并到大的集合中，而不是将大的集合合并到小的集合中。让高度小的树成为高度较大的树的子树，这个优化可以称为启发式合并算法。启发式算法是基于人类的经验和直观感觉，对一些算法的优化。首先可以分析出来，合法的Dk路径一定是上面的所有。到全局根的路径上的字母信息，新增一个字母改变奇偶性可以通过。
DSU on Tree（树上启发式合并）学习笔记
jinniuzhiguan的博客
01-26 964
DSU on Tree，树上启发式合并，dp 优化
dsu on tree 树上启发式合并 学习笔记
weixin_30562507的博客
12-09 122
近几天跟着dreagonm大佬学习了\(dsu\ on\ tree\)，来总结一下： \(dsu\ on\ tree\)，也就是树上启发式合并，是用来处理一类离线的树上询问问题（比如子树内的颜色种数）的不二法宝。它不仅好想好写，还有着\(O(nlogn)\)的优秀时间复杂度（划重点）。 结合一道例题来讲吧： CF600E Lomsat gelral 题目大意： 一棵树有\(n(n\leqslant...
树上启发式合并——学习笔记
流水
03-01 362
600E - Lomsat gelral
「dsu on tree」树上启发式合并
wzw
06-01 828
dsu on tree-树上启发式合并 这篇博客持续更新，先放一个题目，后续补上个人对树上启发式合并的理解，算法复杂度证明以及更多的例题 hdu4358 解法一 ⇒\Rightarrow⇒ dfs序加莫队 #include<iostream> #include<cstdio> #include<algorithm> #include<vector&gt...
树上启发式合并（dsu on tree）学习笔记
RabbieWjy的博客
02-27 1106
树上启发式合并。
qfs.rar_启发式算法_自主学习
09-20
这里我们将深入探讨这两个主题，并结合"qfs.rar"中的上下文，即八数码问题的启发式搜索。 首先，让我们了解启发式算法。启发式算法是一种通过使用已有的知识或经验来指导搜索过程，从而更有效地找到解决方案的方法...
搜索博弈树的启发式搜索PPT学习教案.pptx
10-01
搜索博弈树的启发式搜索 博弈树是指在博弈过程中，每一个可能的走步都可以衍生出一个新的节点，而这些节点之间通过边相连接，形成一个树形结构。博弈树可以分为双人完备信息博弈和机遇性博弈两种。其中，双人完备...
启发式搜索-TSP.zip
06-28
启发式搜索是一种优化技术，常用于解决复杂度高、难以找到最优解的组合优化问题，如旅行商问题（TSP）。TSP问题的核心是寻找一个城市的最短访问路径，使得每个城市只被访问一次，最后返回起点。在这个问题中，启发式...
基于拉普拉斯特征映射的启发式Q学习
01-14
在基于目标的强化学习任务中, 欧氏距离常作为启发式函数用于策略选择, 其用于状态空间在欧氏空间内不连续的任务效果不理想. 针对此问题, 引入流形学习中计算复杂度较低的拉普拉斯特征映射法, 提出一种基于谱图理论的...
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 685
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
卷积神经网络学习问题总结
weixin_61681867的博客
07-17 429
均方误差函数（MSE）适用于回归任务，如预测房价、预测股票价格等。
kubernetes学习日志（七）
qq_47037022的博客
07-18 440
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
手写简易版Spring IOC容器02【学习】
最新发布
weixin_44794897的博客
07-19 363
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
并查集启发式合并的时间复杂度
07-06
并查集是一种常用的数据结构，用于处理集合分割和合并的问题。其启发式合并策略通常指的是路径压缩（Path Compression），即每次查找操作结束后，都会将找到的根节点的所有路径上的边指向根节点，从而减少了后续查找的时间。 在并查集中，最基础的操作是查找（Find）、合并（Union）。查找操作的时间复杂度是O(log n)，这是因为每次查找都是沿着树形结构向下搜索，而树的高度是log n级别的。当进行合并时，如果两个集合的根节点不是同一个，我们会找到它们的最近公共祖先，并通过路径压缩使得这两个集合的路径直接连接到这个最近公共祖先，所以合并操作也是一次查找加上常数时间的操作。 因此，启发式合并（包括路径压缩）后的平均时间复杂度可以认为接近于查找操作，也就是O(log n)。但是需要注意的是，这只是理论上的理想情况，在实际应用中，由于路径压缩的效果，实际运行效率会更高。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值