题目描述

给定一棵n个节点的有根树，编号依次为1到n，其中1号点为根节点。每个点有一个权值v_i。

你需要将这棵树转化成一个大根堆。确切地说，你需要选择尽可能多的节点，满足大根堆的性质：对于任意两个点i,j，如果i在树上是j的祖先，那么v_i>v_j。

请计算可选的最多的点数，注意这些点不必形成这棵树的一个连通子树。

输入格式
第一行包含一个正整数n(1<=n<=200000)，表示节点的个数。

接下来n行，每行两个整数v_i,p_i(0<=v_i<=10^9,1<=p_i<i,p_1=0)，表示每个节点的权值与父亲。

输出格式
输出一行一个正整数，即最多的点数。

样例
样例输入
6
3 0
1 1
2 1
3 1
4 1
5 1
样例输出
5

~~私货：~~
~~摆了，~~有时间在详细写。

思路历程(建议跳过太乱了）：

1.最开始想最暴力的方法，我先把树建出来，然后对每一个点固定为树根，我暴力搜它的子树，pushup再pushup，存进去我的数组，赢！
~~今天你赢赢赢，明天我输光光~~
~~但是专题的名字叫线段树合并啊~~
2.或许dp可以解决这个问题，我还是固定一个点作为树根，但是我用 $f_u,_i$ 表示以u为树根的子树里的节点权值小于i的个数。 $i$ <= $v_u$ .
我们用 $size_u$ 表示u的子节点大小。
就有了转移方程：
ok现在我们得到了转移方程，（感 $K_8He$ 老师的博客对这个fw的大力支持）
$1....$ $f_u,_i=\sum\limits_{size_u}^{}$ $f_u,_i$ , $i<=v_u$
$2....$ $f_u,_i=max(\sum\limits_{size_u}^{}f_u,_i,\sum\limits_{size_u}^{}$ $f_u,_{i+1}$ -1) , $i>=v_u$

贴贴（链接）
ps：没有贴错人也没有贴错题，详见下（）
再贴

代码实现：

嗯我刚刚去学习了一下（）
如果说我们将一棵树转换为一条链。
那么我们求的不就是LIS吗（最长上升子序列）
LIS的做法一般我们都是使 $f_i$ 表示以i结尾的子序列的长度，初始值为1，看看能否更新，可以的话++

 int count(){
	int ans=0;					//记录答案 
	for(int i=1;i<=N;++i){
		f[i]=1;
		for(int j=1;j<i;++j){
			if(num[i]>num[j]){		//递增 
				if(f[i]<f[j]+1){	//能够更新 
					f[i]=f[j]+1;
					save[i]=j;	//记录路径,i由j走来
				}
			}
		}
		ans=max(ans,f[i]);
	}
	return ans;
}

如何维护它？
我没想到，但有人想到了set:

 首先介绍一下multiset和set的区别
1.set 内部元素不能重复，而 multiset 允许元素重复。
2.multiset 支持插入、删除和查找操作的平均时间复杂度均为 O(log n)，而 set 只支持插入和查找操作的平均时间复杂度为 O(log n)，删除操作的平均时间复杂度为 O(1)。
3.使用 multiset 时可以保存重复元素，但需要注意如果要删除某个元素，只能删除 multiset 中所有相同元素中任意一个，而不能只删其中的一些。
 
相同处：
都是有序排序且都是升序
 
通常情况下，如果不需要保存重复元素，优先使用 set，因为 set 的查找操作更快；如果需要保存重复元素，或者需要使用 multiset 特有的功能（如保留相同元素），则使用 multiset。

那么这道题一定应该使用multiset了。

 multiset<int>f[maxn];			//f[i]用于保存当前节点i所对应的线段树的所有节点的权值

那么我们在dfs中将所有x的子树节点都放入f[x]，并且只保存不大于x节点权值的节点不就好了吗？
tips：
$f_i$ .size()表示节点i的集合大小（包括自己），可以用来找出父节点。
swap( $f_i$ , $f_j$ )表示交换两个set容器
$f_i$ .lower_bound(key_value) ，返回 $f_i$ 中第一个大于等于key_value的迭代器
$f_i$ .erase(iterator),删除定位器iterator指向的值
$f_i$ .begin()返回 $f_i$ 中第一个元素的迭代器
$f_i$ .end()返回最后一个元素的迭代器
更多：科技--set

 for(int i=head[now];i;i=e[i].next_){
		int to=e[i].v;
		if(to==fa)	continue;
		dfs(to,now);
		if(f[now].size()<f[to].size())	swap(f[now],f[to]);	//父结点的区间一定比子节点区间大
		for(int j:f[to]){				//直接遍历，此时j就是元素而不是迭代器
			f[now].insert(j);
			//将子节点合并到父亲节点上去
			//对于int j:f[to]  以及另一种写法   *j和set<int>::iterator的解释见下
		}
	}
	
	if(f[now].size()>0&&f[now].lower_bound(v[now])!=f[now].end())
		//如果子节点权值没有大于父亲节点的，那么根据set的单调性，父亲节点的权值对应的地址应该等于最后一个元素
		f[now].erase(f[now].lower_bound(v[now]));
		//否则删去
		//需要注意，f[now]此时里面没有当前节点的权值，
		//所以应该删除第一个大于当前节点权值的数，迭代器不用变
		/*关于为什么应该使用if而不能不能使用while：
		我能够理解为什么会认为是while，因为我们担心小于父亲节点的点没有删尽
		但是当使用 while 循环删除 multiset 中所有小于当前节点权值的元素时，
		由于删除后可能会改变迭代器的指向，
		因此在遍历 multiset 的过程中会出现一些问题。
		具体来说，当使用迭代器遍历 multiset 时，
		迭代器指向 multiset 中的某个元素，如果在这个元素之前删除了其他元素，
		那么这个迭代器就不再有效，再使用它会出错。
 
		为了解决这个问题，我们可以使用 if 判断语句来替换 while 循环，
		只需要删除一个小于当前节点权值的元素即可。
		因为对于同一颗子树中的所有节点，
		它们都会执行这个删除操作，所以最终答案是正确的。
		*/
	f[now].insert(v[now]);
	//我们最初f里什么都没有,以上语句都是回溯执行的，也就是说我们会一路走到黑先走到叶子节点
	//然后将叶子节点的权值放进去
}

至于这道题和线段树合并有什么关系呢……？
其实这是直接用set优化后的，以下代码就运用了线段树合并的思想或者说就是线段树合并。
见代码.

 if(f[now].size()<f[to].size())	swap(f[now],f[to]);
		for(int j:f[to]){
			f[now].insert(j);
		}

好了我来解释一下迭代器，会的可以跳过：
我对迭代器的理解并不深刻，只是认为类似于指针，有会的大佬可以评论。

 /*`set<int>::iterator` 表示 `set<int>` 类型的迭代器，
用于遍历 `set` 中的元素。具体来说，
它是一个指向 `set<int>` 中元素的指针，
可以通过迭代器访问 `set<int>` 中的元素，
并能够进行迭代器运算，如自增等操作。
 
例如，对于一个 `set<int> s`，要遍历其中的元素，
可以使用 `set<int>::iterator it` 定义迭代器，
然后使用 `begin()` 和 `end()` 函数获取 `set` 中第一个元素和尾后元素的迭代器,
再通过循环遍历 `set` 中的所有元素，示例代码如下：*/
 
set<int>::iterator it;
for (it = s.begin(); it != s.end(); ++it) {
    cout << *it << " ";
}
 
/*上述代码中，`it` 是 `set<int>` 的迭代器，
`s.begin()` 和 `s.end()` 分别返回 `set<int>` 的第一个元素和尾后元素的迭代器，
`*it` 则是获取当前迭代器指向的元素的值。*/

 针对题目中代码
for(int j:f[to]){
			f[now].insert(j);
		}
//----------------------------------//
for(set<int>::iterator j=f[to].begin();j!=f[to].end();++j){
			f[now].insert(*j);
		}
是等价的。

最后我们输出就完力！

 printf("%d\n",f[1].size());

完整代码

Miku's Code:

 #include<bits/stdc++.h>
using namespace std;
 
const int maxn=2e5+50;
 
int n,v[maxn],p[maxn];
 
int head[maxn],t;
struct edge{
	int u,v;
	int next_;
};edge e[maxn<<1];
void add_edge(int u,int v){
	e[++t].u=u;
	e[t].v=v;
	e[t].next_=head[u];
	head[u]=t;
}
 
multiset<int>f[maxn];			//f[i]用于保存当前节点i的所有节点的权值 
 
void input(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
		scanf("%d%d",&v[i],&p[i]);
		if(i!=1){
			add_edge(i,p[i]);
			add_edge(p[i],i);
		}
	}
}
 
void dfs(int now,int fa){
	for(int i=head[now];i;i=e[i].next_){
		int to=e[i].v;
		if(to==fa)	continue;
		dfs(to,now);
		if(f[now].size()<f[to].size())	swap(f[now],f[to]);
		for(set<int>::iterator j=f[to].begin();j!=f[to].end();++j){
			f[now].insert(*j);
		}
		f[to].clear();
	}
	while(f[now].size()>0&&f[now].lower_bound(v[now])!=f[now].end())
		f[now].erase(f[now].lower_bound(v[now]));
	f[now].insert(v[now]);
}
 
int main(){
	input();
	dfs(1,0);
	printf("%d\n",f[1].size());
	return 0;
}

类似题目

题目链接
[FJOI2018] 领导集团问题

题目描述

一个公司的组织领导架构可以用一棵领导树来表示。公司的每个成员对应于树中一个结点 $v_i$ ，且每个成员都有响应的级别 $w_i$ 。越高层的领导，其级别值 $w_i$ 越小。树中任何两个结点之间有边相连，则表示与结点相应的两个成员属于同一部门。领导集团问题就是根据公司的领导树确定公司的最大部门。换句话说，也就是在领导树中寻找最大的部门结点子集，使得的结点 $v_i$ 和 $v_j$ ，如果 $v_i$ 是 $v_j$ 的子孙结点，则 $w_i \ge w_j$ 。

编程任务：对于任意对于给定的领导树，计算出领导树中最大的部门结点子集。

输入格式

第一行有一个正整数 $n$ ，表示领导树的结点数。

接下来的一行中有 $n$ 个整数。第 $i$ 个数表示 $w_i$ 。

再接下来的 $n-1$ 行中，第 $i$ 行有一个整数 $v_i$ 表示 $v_i$ 是 $i+1$ 的双亲结点。

输出格式

输出找到的最大的部门的成员数。

样例 #1

样例输入 #1

 6
2 5 1 3 5 4
1
1
2
2
4

样例输出 #1

提示

对于 $10\%$ 的数据， $n\le 20$ ；

对于 $40\%$ 的数据， $n\le 2000$ ；

对于 $100\%$ 的数据， $1\le n\le 2\times 10 ^ 5$ ， $0 < w_i \le 10 ^ 9$ 。

点击查看Miku的小提示

 1.与上一道题不同，这一道题要查小根堆，那么我们查到的迭代器f[now].lower_bound(w[now])还是不等于f[now].end()就不合法吗？
2.与上一道题不同，我们查到的迭代器不用变，是因为v[now]当时没在f[]容器里，现在是小根堆了，v[now]还是不在在f[]容器里，那么迭代器还不用变吗？

Miku's Code

 #include<bits/stdc++.h>
using namespace std;
 
const int maxn=2e6+50;
 
int n,v[maxn],w[maxn];
 
int head[maxn],t;
struct edge{
	int u,v;
	int next_;
};edge e[maxn<<1];
void add_edge(int u,int v){
	e[++t].u=u;
	e[t].v=v;
	e[t].next_=head[u];
	head[u]=t;
}
 
multiset<int>f[maxn];
 
void input(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
		scanf("%d",&w[i]);
	}
	for(int i=2;i<=n;++i){
		scanf("%d",&v[i]);
		add_edge(i,v[i]);
		add_edge(v[i],i);
	}
}
 
void dfs(int now,int fa){
	for(int i=head[now];i;i=e[i].next_){
		int to=e[i].v;
		if(to==fa)	continue;
		dfs(to,now);
		if(f[now].size()<f[to].size())	swap(f[now],f[to]);
		for(int j:f[to]){
			f[now].insert(j);
		}
		f[to].clear();
	}
	multiset<int> :: iterator it=f[now].lower_bound(w[now]);
	if(f[now].size()>0&&it!=f[now].begin()){
		--it;
		f[now].erase(it);
	}
	f[now].insert(w[now]);
} 
 
int main(){
	input();
	dfs(1,0);
	printf("%d\n",f[1].size());
	return 0;
}

上一篇 CodeForces Karen and Supermarket [tarjan]

下一篇【自反】每日单曲推荐||心理日记

posted @ 2023-06-09 08:54 Sonnety 阅读(265) 评论(17) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

$\mathcal{Namanyi\ Bruce}$

如果说，生命的脚步终有一天被时间的尘埃掩埋，那么我们就永远不能停下脚步。

【题解/学习笔记】HZOI 大根堆 &&P4577 [FJOI2018] 领导集团问题线段树合并思想+set优化

题目描述

思路历程(建议跳过太乱了）：

代码实现：

完整代码

类似题目

公告

常用链接

我的标签

随笔档案

相册

	int count(){
	int ans=0; //记录答案
	for(int i=1;i<=N;++i){
	f[i]=1;
	for(int j=1;j<i;++j){
	if(num[i]>num[j]){ //递增
	if(f[i]<f[j]+1){ //能够更新
	f[i]=f[j]+1;
	save[i]=j; //记录路径,i由j走来
	}
	}
	}
	ans=max(ans,f[i]);
	}
	return ans;
	}

	首先介绍一下multiset和set的区别
	1.set 内部元素不能重复，而 multiset 允许元素重复。
	2.multiset 支持插入、删除和查找操作的平均时间复杂度均为 O(log n)，而 set 只支持插入和查找操作的平均时间复杂度为 O(log n)，删除操作的平均时间复杂度为 O(1)。
	3.使用 multiset 时可以保存重复元素，但需要注意如果要删除某个元素，只能删除 multiset 中所有相同元素中任意一个，而不能只删其中的一些。

	相同处：
	都是有序排序且都是升序

	通常情况下，如果不需要保存重复元素，优先使用 set，因为 set 的查找操作更快；如果需要保存重复元素，或者需要使用 multiset 特有的功能（如保留相同元素），则使用 multiset。

	for(int i=head[now];i;i=e[i].next_){
	int to=e[i].v;
	if(to==fa) continue;
	dfs(to,now);
	if(f[now].size()<f[to].size()) swap(f[now],f[to]); //父结点的区间一定比子节点区间大
	for(int j:f[to]){ //直接遍历，此时j就是元素而不是迭代器
	f[now].insert(j);
	//将子节点合并到父亲节点上去
	//对于int j:f[to] 以及另一种写法 *j和set<int>::iterator的解释见下
	}
	}

	if(f[now].size()>0&&f[now].lower_bound(v[now])!=f[now].end())
	//如果子节点权值没有大于父亲节点的，那么根据set的单调性，父亲节点的权值对应的地址应该等于最后一个元素
	f[now].erase(f[now].lower_bound(v[now]));
	//否则删去
	//需要注意，f[now]此时里面没有当前节点的权值，
	//所以应该删除第一个大于当前节点权值的数，迭代器不用变
	/*关于为什么应该使用if而不能不能使用while：
	我能够理解为什么会认为是while，因为我们担心小于父亲节点的点没有删尽
	但是当使用 while 循环删除 multiset 中所有小于当前节点权值的元素时，
	由于删除后可能会改变迭代器的指向，
	因此在遍历 multiset 的过程中会出现一些问题。
	具体来说，当使用迭代器遍历 multiset 时，
	迭代器指向 multiset 中的某个元素，如果在这个元素之前删除了其他元素，
	那么这个迭代器就不再有效，再使用它会出错。

	为了解决这个问题，我们可以使用 if 判断语句来替换 while 循环，
	只需要删除一个小于当前节点权值的元素即可。
	因为对于同一颗子树中的所有节点，
	它们都会执行这个删除操作，所以最终答案是正确的。
	*/
	f[now].insert(v[now]);
	//我们最初f里什么都没有,以上语句都是回溯执行的，也就是说我们会一路走到黑先走到叶子节点
	//然后将叶子节点的权值放进去
	}

	if(f[now].size()<f[to].size()) swap(f[now],f[to]);
	for(int j:f[to]){
	f[now].insert(j);
	}

	/*`set<int>::iterator` 表示 `set<int>` 类型的迭代器，
	用于遍历 `set` 中的元素。具体来说，
	它是一个指向 `set<int>` 中元素的指针，
	可以通过迭代器访问 `set<int>` 中的元素，
	并能够进行迭代器运算，如自增等操作。

	例如，对于一个 `set<int> s`，要遍历其中的元素，
	可以使用 `set<int>::iterator it` 定义迭代器，
	然后使用 `begin()` 和 `end()` 函数获取 `set` 中第一个元素和尾后元素的迭代器,
	再通过循环遍历 `set` 中的所有元素，示例代码如下：*/

	set<int>::iterator it;
	for (it = s.begin(); it != s.end(); ++it) {
	cout << *it << " ";
	}

	/*上述代码中，`it` 是 `set<int>` 的迭代器，
	`s.begin()` 和 `s.end()` 分别返回 `set<int>` 的第一个元素和尾后元素的迭代器，
	`it` 则是获取当前迭代器指向的元素的值。/

	针对题目中代码
	for(int j:f[to]){
	f[now].insert(j);
	}
	//----------------------------------//
	for(set<int>::iterator j=f[to].begin();j!=f[to].end();++j){
	f[now].insert(*j);
	}
	是等价的。

	#include<bits/stdc++.h>
	using namespace std;

	const int maxn=2e5+50;

	int n,v[maxn],p[maxn];

	int head[maxn],t;
	struct edge{
	int u,v;
	int next_;
	};edge e[maxn<<1];
	void add_edge(int u,int v){
	e[++t].u=u;
	e[t].v=v;
	e[t].next_=head[u];
	head[u]=t;
	}

	multiset<int>f[maxn]; //f[i]用于保存当前节点i的所有节点的权值

	void input(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
	scanf("%d%d",&v[i],&p[i]);
	if(i!=1){
	add_edge(i,p[i]);
	add_edge(p[i],i);
	}
	}
	}

	void dfs(int now,int fa){
	for(int i=head[now];i;i=e[i].next_){
	int to=e[i].v;
	if(to==fa) continue;
	dfs(to,now);
	if(f[now].size()<f[to].size()) swap(f[now],f[to]);
	for(set<int>::iterator j=f[to].begin();j!=f[to].end();++j){
	f[now].insert(*j);
	}
	f[to].clear();
	}
	while(f[now].size()>0&&f[now].lower_bound(v[now])!=f[now].end())
	f[now].erase(f[now].lower_bound(v[now]));
	f[now].insert(v[now]);
	}

	int main(){
	input();
	dfs(1,0);
	printf("%d\n",f[1].size());
	return 0;
	}

	1.与上一道题不同，这一道题要查小根堆，那么我们查到的迭代器f[now].lower_bound(w[now])还是不等于f[now].end()就不合法吗？
	2.与上一道题不同，我们查到的迭代器不用变，是因为v[now]当时没在f[]容器里，现在是小根堆了，v[now]还是不在在f[]容器里，那么迭代器还不用变吗？

	#include<bits/stdc++.h>
	using namespace std;

	const int maxn=2e6+50;

	int n,v[maxn],w[maxn];

	int head[maxn],t;
	struct edge{
	int u,v;
	int next_;
	};edge e[maxn<<1];
	void add_edge(int u,int v){
	e[++t].u=u;
	e[t].v=v;
	e[t].next_=head[u];
	head[u]=t;
	}

	multiset<int>f[maxn];

	void input(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
	scanf("%d",&w[i]);
	}
	for(int i=2;i<=n;++i){
	scanf("%d",&v[i]);
	add_edge(i,v[i]);
	add_edge(v[i],i);
	}
	}

	void dfs(int now,int fa){
	for(int i=head[now];i;i=e[i].next_){
	int to=e[i].v;
	if(to==fa) continue;
	dfs(to,now);
	if(f[now].size()<f[to].size()) swap(f[now],f[to]);
	for(int j:f[to]){
	f[now].insert(j);
	}
	f[to].clear();
	}
	multiset<int> :: iterator it=f[now].lower_bound(w[now]);
	if(f[now].size()>0&&it!=f[now].begin()){
	--it;
	f[now].erase(it);
	}
	f[now].insert(w[now]);
	}

	int main(){
	input();
	dfs(1,0);
	printf("%d\n",f[1].size());
	return 0;
	}

Namanyi BruceNamanyi Bruce\mathcal{Namanyi\ Bruce}

如果说，生命的脚步终有一天被时间的尘埃掩埋，那么我们就永远不能停下脚步。

【题解/学习笔记】HZOI 大根堆 &&P4577 [FJOI2018] 领导集团问题 线段树合并思想+set优化

题目描述

思路历程(建议跳过太乱了）：

代码实现：

完整代码

类似题目

公告

常用链接

我的标签

随笔档案

相册

$\mathcal{Namanyi\ Bruce}$

【题解/学习笔记】HZOI 大根堆 &&P4577 [FJOI2018] 领导集团问题线段树合并思想+set优化