Dsu on tree树上启发式合并经典例题算法代码剖析

本文介绍了一种称为树上启发式合并的优化算法,通过对子树进行轻重儿子划分及相应的桶操作,将时间复杂度从N²降低到NlogN。文章提供了两种实现方式的代码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目链接:E. Lomsat gelral
树上启发式合并,初见这个名字,我和大部分人一样望文生义觉得应该是子树信息的合并使用了一种“启发式”,相当于区间操作的线段树的Lzay标志一般,仅仅启发而不去真的合并。

然后我兴高采烈的学了一下发现其实就是一个暴力。一个优雅的暴力优化。

dsu on tree,dsu就是并查集,直译为树上并查集。(某L称该算法为静态链分治。

首先我们审视一下题目暴力的写法:
对于每个子树开一个桶或者对每个子树都清空一次桶,然后暴力跑得出空间为 N 2 N^2 N2 或者时间为 N 2 N^2 N2 。这明显是不可取的。然后考虑暴力的优化,那就是当k结点需要求解的时候,可以保留一个重儿子求解之后的桶不给他清空,然后合并其他轻儿子,也就是说
轻儿子会经历:求解,清空共2次
重儿子会经历:求解,共1次。

然后发现如果有轻儿子重儿子之分则树链不超过 l o g 2 N log_2N log2N高度,于是可以得出这个小小的优化竟然能够让 N 2 N^2 N2变成 N l o g 2 N Nlog_2N Nlog2N

这个题写法可以有两种:

#define X first
#define Y second
const int maxn = 1e5+10;
ll a[maxn];
vector <int >g[maxn];
int tong[maxn] ,sz[maxn] ;
ll ans[maxn] ;
bool cmp(int a,int b){return sz[a]<sz[b];}
int dfs1(int k,int last)
{
	sz[k]=1;
	for(int i =0;i<g[k].size();++i)if(g[k][i]!=last)sz[k]+=dfs1(g[k][i],k);
	return sz[k];
}
void add(int k,int last,int cut,pair<int ,ll>& rem)
{//把k子树所有结点存入桶中
	//cut =1表示入桶,0表示出桶
	tong[a[k] ]+=cut;
	if(tong[a[k] ]==rem.X&&cut==1)
	{
		rem.Y+=a[k];
	}
	else if(tong[a[k] ]>rem.X&&cut==1){rem.X=tong[a[k] ];rem.Y=a[k];}
	for(int i=0;i<g[k].size();++i)
		if(g[k][i]!=last)add(g[k][i],k,cut,rem);
}
pair<int ,ll> dfs2(int k,int last)
{
	//printf("to : %d\n",k);
	//对于k结点子树求答案;
	//函数返回值:_max 和 答案;对应rem.X和rem.Y
	//先对k儿子子树求答案,然后对最重儿子最后处理;
	sort(g[k].begin(),g[k].end(),cmp);
	if(sz[k]==1){tong[a[k]]++;ans[k] = a[k];return (pii ){ 1,a[k] };}
	pair<int ,ll> rem ={0,0};
	for(int i=0;i<g[k].size()-1+(k==1);++i)
	{
		rem = dfs2(g[k][i] ,k);//除了最后一步都为轻儿子,最后一步不清除.则rem保证为最后一个重儿子的结果,则可以支持后续操作
		if(i!=g[k].size()-2+(k==1))add(g[k][i],k,-1,rem);
	}
	//printf("%d %d %d\n",k,rem.X,rem.Y);
	tong[a[k]]++;
	if(tong[a[k] ]==rem.X)
	{
		rem.Y+=a[k];
	}
	else if(tong[a[k] ]>rem.X){rem.X=tong[ a[k] ];rem.Y=a[k];}
	for(int i =0;i<g[k].size()-2+(k==1);++i)
	{
		add(g[k][i],k,1,rem);
	}
	ans[k] = rem.Y;
	return rem;
}
int main()
{
	int n;read(n);
	for(int i= 1;i<=n;++i)read(a[i]);
	for(int i =1;i<n;++i)
	{
		int u,v;read(u);read(v);
		g[u].push_back(v);g[v].push_back(u);
	}
	//input finished
	//树上启发式合并
	dfs1(1,1);
	dfs2(1,1);
	for(int i =1;i<=n;++i)printf(" %lld"+(i==1),ans[i]);printf("\n");

}

#include<cstdio>
using namespace std;
typedef long long LL;
const int maxn=100000,maxe=maxn<<1;

int n,col[maxn+5],fa[maxn+5];
int E,lnk[maxn+5],son[maxe+5],nxt[maxe+5];
int si[maxn+5],SH[maxn+5];bool vis[maxn+5];
int MAX,num[maxn+5];LL sum,ans[maxn+5];

#define Add(x,y) son[++E]=y,nxt[E]=lnk[x],lnk[x]=E
void Dfs(int x,int pre=0)
{
    si[x]=1;fa[x]=pre;
    for (int j=lnk[x];j;j=nxt[j]) if (son[j]!=pre)
    {
        Dfs(son[j],x);si[x]+=si[son[j]];
        if (si[son[j]]>si[SH[x]]) SH[x]=son[j];
    }
}
void Update(int x,int f)
{
    if ((num[col[x]]+=f)>=MAX)  if (num[col[x]]>MAX)
        MAX=num[col[x]],sum=col[x]; else sum+=col[x];
    for (int j=lnk[x];j;j=nxt[j]) if (son[j]!=fa[x])
        if (!vis[son[j]]) Update(son[j],f);
}
void Solve(int x,bool fl=true)
{
    for (int j=lnk[x];j;j=nxt[j]) if (son[j]!=fa[x])
        if (son[j]!=SH[x]) Solve(son[j],false);
    if (SH[x]) Solve(SH[x],true),vis[SH[x]]=true;
    Update(x,1);ans[x]=sum;if (SH[x]) vis[SH[x]]=false;
    if (!fl) Update(x,-1),MAX=sum=0;
}
int main()
{
    freopen("program.in","r",stdin);
    freopen("program.out","w",stdout);
    scanf("%d",&n);for (int i=1;i<=n;i++) scanf("%d",&col[i]);
    for (int i=1,x,y;i<n;i++) scanf("%d%d",&x,&y),Add(x,y),Add(y,x);
    Dfs(1);Solve(1);for (int i=1;i<=n;i++) printf("%I64d ",ans[i]);
    return 0;
}

除去注释和下面的压行,下面仍然要多一点语句,主要是第一个代码使用了rem去处理合并轻儿子过程对父亲整个子树的答案更新情况,而下面的代码使用了一个数组记录每个节点的rem,使用额外的数组存储对于空间有一点占用,两边都可以的。下面空间多了N个pair,但是更加简短,推荐使用。

以第一个代码来说:
过程先使用dfs1求子树size。
然后add函数为增加整个子树信息进入桶中,或者从桶中删除整个子树信息。然后就是dfs2过程了
dfs2代码先:重载cmp函数然后sort排个序,先对轻儿子求答案,然后剩下最后一个重儿子求完答案并没有清空,也就是这一小段:

rem = dfs2(g[k][i] ,k);
 //除了最后一步都为轻儿子,最后一步不清除.则rem保证为最后一个重儿子的结果,则可以支持后续操作
 if(i!=g[k].size()-2+(k==1))add(g[k][i],k,-1,rem);

可以看到当出了这个循环,rem保存的是重儿子的答案,_max 和cnt都存在这个pair变量中了,然后桶中也仍保留重儿子的信息。
然后就是add轻儿子,并且add函数当cut为1,会更新通过引用传进去的rem,作为父亲节点子树的答案,然后返回父亲节点子树答案当做函数返回值。

至此,完成树上启发式合并这个名字听起来和算法过程没什么大关系的算法啦。

<think>嗯,用户现在在学习算法竞赛,想要了解启发式合并,并且希望由浅入深地讲解,还要用C++的例子来说明。那我得先理清楚启发式合并的基本概念,然后逐步深入,最后给出代码示例。 首先,启发式合并是什么?可能用户之前学过并查集,或者普通的合并方法,但遇到某些情况下效率不高的问题。启发式合并应该是一种优化合并操作的方法,可能通过选择合并的顺序或方式,减少时间复杂度。比如在并查集中的按秩合并,可能就是一种启发式合并的应用。不过用户可能指的是更一般的数据结构合并时的优化策略。 那启发式合并的核心思想应该是每次合并两个集合时,总是将较小的集合合并到较大的集合中,这样可以减少总的操作次数。比如,如果每次合并时都把小集合的元素移动到大集合里,那么每个元素被移动的次数不会超过logN次,因为每次移动后所在的集合大小至少翻倍。这样总的时间复杂度就能控制在O(N logN)级别。 接下来需要解释为什么这种方法有效。比如,假设有两个集合A和B,大小分别为|A|和|B|,且|A|<=|B|。那么将A合并到B中,这样A中的每个元素所在的集合大小至少是原来的两倍(因为B的大小比A大)。因此,每个元素最多被合并logN次,总操作次数就是O(N logN)。 接下来,可能需要举一个具体的例子,比如合并链表或者树结构的时候使用启发式合并。或者是在处理并查集的时候,按大小合并的情况。用户可能需要具体的应用场景,比如并查集的优化,或者在处理某些数据结构(比如平衡树、链表)时的合并操作。 然后,需要用C++来举例说明。比如,可以用并查集的例子,或者用其他数据结构,比如集合的合并。例如,维护多个集合,每个集合用某种结构存储,合并的时候总是将小的合并到大的里面,这样可以减少时间。 比如,可以举一个并查集的例子。并查集的按秩合并就是启发式合并的一种。在并查集的实现中,每个集合有一个父节点,还有一个秩(rank)或者大小。合并的时候,总是将秩较小的根指向秩较大的根。这样能保证树的高度较低,提高查找效率。这时候可以给出具体的代码示例,比如并查集的实现,包含路径压缩和按秩合并。 或者,举一个更通用的例子,比如合并两个链表,或者合并两个平衡二叉搜索树的时候,如何选择合并顺序以减少时间复杂度。例如,合并两个集合的时候,总是遍历较小的集合,将其元素逐个插入到较大的集合中,这样总的时间复杂度较低。 比如,用C++中的std::set来举例。假设有多个set,每次合并两个set的时候,总是将较小的set中的元素插入到较大的set中。这样可以保证每个元素被插入的次数不超过logN次,因为每次插入后所在的集合大小至少翻倍。这样总的时间复杂度是O(N logN logM),其中M是元素的大小?或者可能更优? 例如,代码可能如下: void merge(set<int> &a, set<int> &b) { if (a.size() > b.size()) { swap(a, b); } for (auto x : a) { b.insert(x); } a.clear(); } 这样每次合并的时候,总是将较小的集合合并到较大的里面。这样每个元素被插入的次数是logN次,每次插入的时间复杂度是O(logM),所以总的时间复杂度是O(N logN logM)。不过这可能适用于元素可排序的情况,比如使用平衡树结构的集合。 另一个例子是并查集的实现,其中按秩合并启发式合并的一种应用。例如: class DSU { vector<int> parent; vector<int> size; public: DSU(int n) { parent.resize(n); size.resize(n, 1); for (int i=0; i<n; ++i) parent[i] = i; } int find(int x) { if (parent[x] != x) parent[x] = find(parent[x]); return parent[x]; } void unite(int x, int y) { x = find(x); y = find(y); if (x == y) return; if (size[x] < size[y]) swap(x, y); parent[y] = x; size[x] += size[y]; } }; 这里,unite函数中总是将较小的集合合并到较大的集合里。这里的大小指的是集合的元素个数。这样可以保证树的高度较低,从而find操作的时间复杂度几乎是常数。 但用户可能想了解的不仅仅是并查集中的情况,而是更广泛的启发式合并应用。比如在处理某些数据结构时,比如链表、数组或者树结构的合并,如何利用启发式合并来优化。 比如,在解决某些问题时,比如动态连接问题,或者离线查询处理,可能需要多次合并不同的数据结构,这时候使用启发式合并可以显著减少时间。 另一个例子是,在树上处理子树问题的时候,比如每个节点维护一个颜色的集合,当处理子树时,将子节点的集合合并到父节点。这时候如果采用启发式合并,每次将较小的子树集合合并到较大的,可以降低总的时间复杂度。 例如,解决树上每个节点的颜色数量问题。每个节点有一个颜色集合,初始时只有自己的颜色。然后从叶子节点向上合并,每个父节点收集所有子节点的颜色集合。这时候,如果每次合并时将较小的集合合并到较大的集合,就能有效减少总操作次数。 这时候可以用C++中的unordered_set来举例: void dfs(int node, int parent, vector<unordered_set<int>> &colors) { for (auto child : children[node]) { if (child != parent) { dfs(child, node, colors); // 合并子节点的colors到当前节点 if (colors[node].size() < colors[child].size()) { swap(colors[node], colors[child]); // 保证node的集合较大 } for (int color : colors[child]) { colors[node].insert(color); } colors[child].clear(); // 可选,释放内存 } } } 这样,每个节点的合并操作都是将较小的集合合并到较大的,从而减少总的插入次数。每个颜色被插入的次数最多是logN次,所以总时间复杂度是O(N logN)。 总结一下,启发式合并的关键点在于每次合并时,总是将较小的结构合并到较大的结构中,这样每个元素被处理的次数减少,从而降低总的时间复杂度。应用场景包括并查集、树上的子树问题、集合合并等。代码示例可以根据不同的应用场景来展示,比如并查集、颜色集合的合并等。 现在需要考虑用户的学习阶段。用户可能在算法竞赛中遇到需要高效合并的问题,比如某些题目需要处理大量合并操作,而普通的暴力合并会导致超时。这时候启发式合并就能派上用场。例如,Codeforces或ACM竞赛中的某些题目,可能需要处理子树信息合并,这时候启发式合并可以优化时间复杂度。 可能用户的问题点在于理解为什么这样合并能优化时间,或者如何在实际问题中应用。因此,在讲解时,需要强调时间复杂度分析,以及具体例子中的操作步骤。 可能还需要比较暴力合并启发式合并的时间复杂度差异。例如,如果每次合并都是简单地将一个集合的所有元素插入另一个,那么最坏情况下,每次合并都是O(n)时间,总的时间复杂度可能是O(n²)。而使用启发式合并后,总的时间复杂度降低到O(n logn)。 最后,C++的例子需要具体且易于理解。可能用户对STL比较熟悉,所以使用std::set或unordered_set的例子会更直观。或者使用并查集的例子,因为并查集是算法竞赛中的常见结构。 综上所述,我的回答结构应该是: 1. 定义启发式合并:将较小的集合合并到较大的集合,减少操作次数。 2. 解释原理:每个元素被移动的次数最多logN次,总复杂度O(N logN)。 3. 应用场景:并查集按秩合并、子树信息合并、集合合并等。 4. C++示例: a. 并查集的实现(按大小合并)。 b. 树上颜色统计问题的启发式合并。 5. 分析时间复杂度和优势。</think>好的!我将由浅入深为你讲解启发式合并(Heuristic Merge),并用 C++ 举例说明其实现。 --- ### **一、基础概念** **启发式合并** 是一种优化合并操作的策略,核心思想是:**每次合并两个集合时,总是将较小的集合合并到较大的集合中**。这样能减少重复操作次数,从而降低整体时间复杂度。 #### **为什么需要它?** 假设直接合并两个大小为 `n` 和 `m` 的集合(`n < m`),若将大的合并到小的,后续操作可能需要频繁处理更大的集合。而将小的合并到大的,后续操作会更高效。 --- ### **二、时间复杂度分析** - **普通合并**:最坏情况每次合并都需要 `O(n)` 时间,合并 `n` 次的总时间为 `O(n²)`。 - **启发式合并**:每个元素最多被合并 `O(log n)` 次(因为每次合并后集合大小至少翻倍),总时间优化为 `O(n log n)`。 --- ### **三、应用场景** 1. **并查集(按秩合并)** 2. **树上的子树信息合并**(如统计子树颜色) 3. **集合合并问题**(如动态维护多个集合) --- ### **四、C++ 代码示例** #### **1. 并查集的启发式合并(按大小合并)** ```cpp class DSU { vector<int> parent; vector<int> size; public: DSU(int n) { parent.resize(n); size.resize(n, 1); for (int i = 0; i < n; i++) parent[i] = i; } int find(int x) { if (parent[x] != x) parent[x] = find(parent[x]); // 路径压缩 return parent[x]; } void unite(int x, int y) { x = find(x), y = find(y); if (x == y) return; // 启发式合并:小集合合并到大集合 if (size[x] < size[y]) swap(x, y); parent[y] = x; size[x] += size[y]; } }; ``` #### **2. 树上统计子树颜色(启发式合并应用)** 假设树节点有颜色,求每个节点的子树中颜色种类数: ```cpp #include <vector> #include <unordered_set> using namespace std; void dfs(int u, int parent, vector<vector<int>>& tree, vector<unordered_set<int>>& subtreeColors, vector<int>& color) { subtreeColors[u].insert(color[u]); // 当前节点的颜色 for (int v : tree[u]) { if (v == parent) continue; dfs(v, u, tree, subtreeColors, color); // 启发式合并:将小子树合并到大子树 if (subtreeColors[u].size() < subtreeColors[v].size()) { swap(subtreeColors[u], subtreeColors[v]); } // 合并子树颜色 for (int c : subtreeColors[v]) { subtreeColors[u].insert(c); } subtreeColors[v].clear(); // 可选,释放内存 } // 此时 subtreeColors[u] 包含子树所有颜色 } int main() { int n = 100; // 节点数 vector<vector<int>> tree(n); vector<int> color(n); vector<unordered_set<int>> subtreeColors(n); // 假设 tree 和 color 已初始化 dfs(0, -1, tree, subtreeColors, color); return 0; } ``` --- ### **五、关键点总结** 1. **合并方向**:总是小集合合并到大集合。 2. **复杂度保证**:每个元素最多被合并 `O(log n)` 次。 3. **实现技巧**:使用 `swap` 确保操作对象始终是小集合。 4. **适用问题**:需要频繁合并的场景(如并查集、树上统计)。 --- ### **六、习题推荐** 1. [Codeforces 600E - Lomsat gelral](https://codeforces.com/problemset/problem/600/E)(经典启发式合并应用题) 2. 并查集相关题目(如动态连通性问题) 希望这些内容能帮助你掌握启发式合并!如果有更多问题,欢迎继续提问~ 😊
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值