Lomsat gelral

最新推荐文章于 2021-07-06 20:52:03 发布
原创 最新推荐文章于 2021-07-06 20:52:03 发布 · 207 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线段树合并 #CF

本文提供CF600E题目的详细解答过程，包括使用线段树进行区间更新和查询的操作，以及如何通过递归实现树形结构上的动态规划。文章重点介绍了空间复杂度为O(nlogn)的解决方案，并分享了在合并子树时节省空间的技巧。

Lomsat gelral
CF 600E

写几个注意点

  1. push_up操作直接在函数内做，不然不好统计
  2. 空间复杂度是O(nlogn)，所以在合并子树时要尽量节省空间
#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e5+5;
int tnt=0,rt[N];
int n,colr[N],cnt=0,head[N];
struct edge{
	int link,v;
}q[N<<1];
ll ans[N];
struct node{
	int l,r;
	int mx;
	ll val; 
}tree[N*20];//这里一定要注意
void put(int u,int v){
	q[++cnt].v=v;
	q[cnt].link=head[u];
	head[u]=cnt;
}
void merge(int u,int v,int l,int r){
	if(l==r){
		tree[u].val=l;
		tree[u].mx+=tree[v].mx;
		return;
	}
	int ls=tree[u].l,rs=tree[u].r,lss=tree[v].l,rss=tree[v].r;
	int mid=(l+r)>>1;
	if(lss){
		if(!ls){
			ls=lss;
			tree[u].l=lss;
		}
		else merge(ls,lss,l,mid);
	}
	if(rss){
		if(!rs){
			rs=rss;
			tree[u].r=rss;
		}
		else merge(rs,rss,mid+1,r);
	}
	if(tree[ls].mx<tree[rs].mx){
		tree[u].val=tree[rs].val;
	    tree[u].mx=tree[rs].mx;
	}
	else if(tree[rs].mx<tree[ls].mx){
		tree[u].val=tree[ls].val;
		tree[u].mx=tree[ls].mx;
	}
	else {
		tree[u].val=tree[ls].val+tree[rs].val;
		tree[u].mx=tree[ls].mx;
	}
}
void add(int u,int k,int l,int r){
	if(l==r){
		tree[u].mx++;
		tree[u].val=l;
		return;
	}
	int mid=(l+r)>>1,ls=tree[u].l,rs=tree[u].r;
	if(k<=mid){
		if(!ls){
			ls=++tnt;
			tree[u].l=ls;
		}
		add(ls,k,l,mid);
	}
	else{
		if(!rs){
			rs=++tnt;
			tree[u].r=rs;
		}
		add(rs,k,mid+1,r);
	}
	if(tree[ls].mx<tree[rs].mx){
		tree[u].val=tree[rs].val;
	    tree[u].mx=tree[rs].mx;
	}
	else if(tree[rs].mx<tree[ls].mx){
		tree[u].val=tree[ls].val;
		tree[u].mx=tree[ls].mx;
	}
	else {
		tree[u].val=tree[ls].val+tree[rs].val;
		tree[u].mx=tree[ls].mx;
	}
}
void dfs(int s,int fa){
	for(int i=head[s];i;i=q[i].link){
		int v=q[i].v;
		if(v==fa) continue;
		dfs(v,s);
		merge(rt[s],rt[v],1,n);
	}
	add(rt[s],colr[s],1,n);
	ans[s]=tree[rt[s]].val;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) {
	     rt[i]=++tnt;
		 scanf("%d",&colr[i]);
}
	for(int i=1;i<n;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		put(u,v),put(v,u);
	}
	dfs(1,0);
	for(int i=1;i<=n;i++){
		printf("%lld ",ans[i]);
	}
}
树上启发式合并入门-Lomsat gelral
g3125976202的博客
05-17 401
简述： 树上启发式合并又叫 dsu on tree ，是解决可以离线的子树问题的一种方法。 优点：时间复杂度优秀O(nlogn)O(n logn)O(nlogn)，在一些可以使用 dfs 序 + 莫队 算法O(nn)O(n\sqrt{n})O(nn​)的题目中有很强的优越性，相比线段树码量要小的多。 ...
【CF600E Lomsat gelral】（DSU on Tree | 树上并查集 | 重链刨分 | 启发式搜索）
RFoer的博客
01-12 461
【代码】【CF600E Lomsat gelral】（DSU on Tree | 树上并查集 | 重链刨分 | 启发式搜索）
[CF600E]Lomsat gelral
weixin_30732487的博客
11-30 145
题意翻译 一棵树有n个结点，每个结点都是一种颜色，每个颜色有一个编号，求树中每个子树的最多的颜色编号的和。 线段树合并板子题，没啥难度，注意开long long 不过这题$dsu$ $on$ $tree$确实更快 代码： 1 #include<iostream> 2 #include<cstdio> 3 #define ls ch[node][0] ...
E - Lomsat gelral
傻的让人心疼
07-17 429
思维题
Lomsat gelral（树上启发式合并）
g21wcr的博客
12-29 259
例题 轻重链剖分暴力。主要是skip数组有点蒙。 对于一个点A，一定是先把A的轻儿子先全部搜完然后搜A的重儿子。 轻儿子搜完之后记录都清空了。最后搜重儿子的时候搜完了要保留。if(son[u]) dfs(son[u],v,1),skip[son[u]]=1;通过skip保留。 然后是统计整个A的子树，这个时候calc就会把A的重儿子跳过。calc完了之后就得到ans[A]。 然后把A的重...
E. Lomsat gelral(dsu on tree)
qq_43750980的博客
11-18 472
文章目录[E. Lomsat gelral](https://codeforces.com/contest/600/problem/E)题意解题思路代码 E. Lomsat gelral 题意 统计每棵子树的最多的颜色节点的和是说少。 解题思路 最近刚学的 dsu on tree 这道题刚好是一道模板题。我们通过一次dfs搜索后，标记出每个节点的重儿子，然后遍历的时候先遍历亲儿子再遍历重儿子。 附加一个大佬的博客和B站的视频讲解吧。 博客链接 视频连接 代码 #include<bits/stdc++.
【ybt金牌导航6-2-2】【luogu CF600E】树上众数 / Lomsat gelral（树上启发式合并）
欢迎您的光顾awa
07-06 257
给你一个树，树上点有颜色编号。 对于每个子树，问你在这个子树中，出现次数最多的颜色的编号和。
【算法讲20：Dsu on Tree】树上数颜色 | Lomsat gelral
溢流眼泪的博客
03-19 863
【算法讲20：Dsu on Tree】【例一：树上数颜色】· 暴力做法 ·· 考虑优化 ·⌈Dsu on Tree⌋\lceil Dsu\ on\ Tree\rfloor⌈Dsu on Tree⌋【代码】【例二：Lomsat gelralLomsat\ gelralLomsat gelral】 【例一：树上数颜色】 【链接】 树上数颜色 | 洛谷 U41492 【题意】 给定一棵有根树，有 nnn 个节点，每个节点有一个颜色 cic_ici​
D - Lomsat gelral
evilwind2000的博客
01-11 275
You are given a rooted tree with root in vertex 1. Each vertex is coloured in some colour. Let’s call colour c dominating in the subtree of vertex v if there are no other colours that appear in the su...
Codeforces 600E Lomsat gelral
P.H.S
09-05 392
Codeforces 600E Lomsat gelral树上启发式合并题意一棵树，每一个点有一个颜色，统计以每一个节点为根的子树中出现次数最多的颜色的编号，如果有多个颜色，统计他们的和。思路学习了一下dsu on the tree，安利一下良心博客1，博客2，以及CF官方解答。 算法的大致过程： 首先将树轻重链剖分，在dfs的过程中先dfs轻儿子，再dfs重儿子。 假设某一个点的儿子都已
CF600E E. Lomsat gelral
tobe_numberone的博客
03-22 341
E. Lomsat gelral //#include <bits/stdc++.h> //#pragma GCC optimize(2) #include <stdio.h> #include <cstring> #include <algorithm> #include <vector> #include <stack> #include <queue> #include <iostream> #includ
【CF600E】Lomsat gelral
01-26 197
【CF600E】Lomsat gelral 题面 给你一颗\(n\)个节点的树，每个节点都有一种颜色，\(m\)次询问，每次询问求每个子树中出现次数最多的颜色(们)的编号之和。 其中\(n\leq10^5,m\leq10^5\) 题解 \(dsu\;on\;tree\)板子题 不会的推荐看\(gsy\)的博客 其实还是挺简单的 代码 #include<iostream> #i...
E. Lomsat gelral(dsu)
IQ^QI的博客
10-23 414
E. Lomsat gelral 题意： 输入n(1e5)n(1e5)n(1e5) 输入c1,c2,…,cnc_1,c_2,\dots,c_nc1​,c2​,…,cn​表示节点颜色 接下来n−1n-1n−1行，每行输入u,vu,vu,v，表示树边。 注意 树根为1 求对于每一个节点所对应的子树，求出现颜色次数最多的贡献。 题解： 直接上dsu就好了 代码： #pragma GCC optimize...
Lomsat gelral（启发式合并）
qq_44866969的博客
03-17 331
#include<bits/stdc++.h> #define ll long long using namespace std; const int N=1e5+10; const int M=2*N; int h[N],e[M],ne[M],idx; int color[N]; int sz[N]; int son[N]; int cnt[N]; int mx; ll sum,ans[N]; void add(int a,int b){ e[idx]=b,ne[idx]=h[a],h[a.
Lomsat gelral【Dsu on Tree】
既然弱小，就只顾变强就是了
12-30 240
http://codeforces.com/contest/600/problem/E 题意：有N个结点构成的一棵树，其中每个结点都有一个颜色，现在我们想知道每个结点的统治色是哪种或者哪几种颜色，如果存在多种统治色的话，就是这几种统治色的颜色权值和。 思路：这是一道Dsu on Tree的模板题，但是作为初学Dsu on Tree的小白，我还是想分享一下我的认知。 首先，Dsu的...
我正在学习算法竞赛，请由浅入深给我讲解一下启发式合并，并用C++举例说明
最新发布
02-24
<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、付费专栏及课程。

余额充值