[NOI2010]超级钢琴解题报告

最新推荐文章于 2021-05-12 14:10:41 发布

TA201314

最新推荐文章于 2021-05-12 14:10:41 发布

阅读量1.9k

点赞数

分类专栏：线段树 DP heap 前缀和 Code 分治文章标签：线段树 heap Code 前缀和 dp

本文链接：https://blog.csdn.net/TA201314/article/details/42804971

版权

DP 同时被 3 个专栏收录

43 篇文章 1 订阅

订阅专栏

线段树

23 篇文章 0 订阅

订阅专栏

分治

12 篇文章 0 订阅

订阅专栏

超级钢琴

【问题描述】

小Z是一个小有名气的钢琴家，最近C博士送给了小Z一架超级钢琴，小Z希望能够用这架钢琴创作出世界上最美妙的音乐。

这架超级钢琴可以弹奏出n个音符，编号为1至n。第i个音符的美妙度为Ai，其中Ai可正可负。

一个“超级和弦”由若干个编号连续的音符组成，包含的音符个数不少于L且不多于R。我们定义超级和弦的美妙度为其包含的所有音符的美妙度之和。两个超级和弦被认为是相同的，当且仅当这两个超级和弦所包含的音符集合是相同的。

小Z决定创作一首由k个超级和弦组成的乐曲，为了使得乐曲更加动听，小Z要求该乐曲由k个不同的超级和弦组成。我们定义一首乐曲的美妙度为其所包含的所有超级和弦的美妙度之和。小Z想知道他能够创作出来的乐曲美妙度最大值是多少。

【输入格式】

输入文件名为piano.in。

输入文件第一行包含四个正整数n, k, L, R。其中n为音符的个数，k为乐曲所包含的超级和弦个数，L和R分别是超级和弦所包含音符个数的下限和上限。

接下来n行，每行包含一个整数Ai，表示按编号从小到大每个音符的美妙度。

【输出格式】

输出文件为piano.out。

输出文件只有一个整数，表示乐曲美妙度的最大值。

【样例输入】

4 3 2 3

-6

【样例输出】

【样例说明】

共有5种不同的超级和弦：

音符1 ~ 2，美妙度为3 + 2 = 5
音符2 ~ 3，美妙度为2 + (-6) = -4
音符3 ~ 4，美妙度为(-6) + 8 = 2
音符1 ~ 3，美妙度为3 + 2 + (-6) = -1
音符2 ~ 4，美妙度为2 + (-6) + 8 = 4

最优方案为：乐曲由和弦1，和弦3，和弦5组成，美妙度为5 + 2 + 4 = 11。

【运行时限】

2秒。

【运行空限】

512M。

【数据规模和约定】

总共10个测试点，数据范围满足：

所有数据满足：-1000 ≤ Ai ≤ 1000，1 ≤ L ≤ R ≤ n且保证一定存在满足要求的乐曲。

这道题我觉得还是非常好的，代表了一类题的思想；就是在一坨有序集中取出最小的K个数。

思路也比较简单，唯一需要我学习的一点就是取区间最小值的问题：

①一个简单的思路是取过之后将原区间分成不包含最小值的两部分重新加入到堆中，这样的时间复杂度度是O(nlogn+klog[(n+k)!/(n-1)!])；另一个思路（我的思路）是建N棵线段树，作单点修改。。这样时间复杂度是O((n+k)logn)，看上去好像低了点，但不仅多出去好几十行，而且线段树的常数。。呵呵。总之，我们要看到，题解裂解区间的思路还是非常优秀的！也给我们做其他区间题以许多启示。

②此外，我还发现原来开-O2优化以后会让STL跑得比手写数据结构快好多。

③也算是真正学了一遍ST，说STO(1)查询真TM纯属谣言，明明就是log(n)的，还要注意边界各种+-1；你可以用log函数，但那要比位运算慢太多了。

④Code Trick：起初我在ST中保存了两个量，下标和最小值；但看了别人的代码之后才明白，最小值存起来是完全没有意义的，仅存下标就可以了呀。

⑤注意事项：数组开小啦！！但是在改STL之前不知道为什么数组根本就没影响，虽然小了也A了。。呵呵。但是！TM一定要注意数组，查了我一下午；+1-1一定要想清楚了！

代码（线段树+堆）：

#include<iostream>
using namespace std;
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
char * ptr=(char *)malloc(7000000);
inline void in(int &x){
	bool flag=0;
	while(*ptr<'0'||*ptr>'9')
		if(*ptr++=='-')
			flag=1;
	x=0;
	while(*ptr>47&&*ptr<58)x=x*10+*ptr++-'0';
	if(flag)x=-x;
}
 
struct SS{
	int min,x;
}st[500000][19];
inline SS min(SS a,SS b){
	if(a.min<b.min)return a;
	else return b;
}
inline SS St(int l,int r){
	int i=log(r-l+1)/log(2);
	return min(st[l][i],st[r-(1<<i)+1][i]);
}
 
struct TS{
	TS * l,* r;
	int min,x;
}*root[500000];
inline void update(TS * node,int l,int r){
	if(l==r){
		node->min=0x7fffffff;
		return;
	}
	int m=(l+r)>>1;
	if(node->l==0){
		SS tmp=St(l,m);
		node->l=new TS((TS){0,0,tmp.min,tmp.x});
		tmp=St(m+1,r);
		node->r=new TS((TS){0,0,tmp.min,tmp.x});
	}
	if(node->x>m)update(node->r,m+1,r);
	else update(node->l,l,m);
	if(node->l->min<node->r->min){
		node->min=node->l->min;
		node->x=node->l->x;
	}
	else{
		node->min=node->r->min;
		node->x=node->r->x;
	}
	if(node->min==0x7fffffff){
		delete node->l;
		delete node->r;
		node->l=0;
		node->r=0;
	}
}
 
struct HS{
	int key,x;
	inline bool operator > (const HS a) const{
		return key>a.key;
	}
}heap[500000];
int heapsize=1;
inline void down(int now){
	for(int next=now<<1;next<heapsize;now=next,next<<=1){
		if(next+1<heapsize&&heap[next+1]>heap[next])++next;
		if(heap[now]>heap[next])return;
		swap(heap[now],heap[next]);
	}
}
inline void up(int now){
	for(int next=now>>1;next&&heap[next]>heap[now];now=next,next>>=1)swap(heap[now],heap[next]);
}
int main(){
	freopen("piano.in","r",stdin);
	freopen("piano.out","w",stdout);
	fread(ptr,1,7000000,stdin);
	int n,k,L,R;
	in(n),in(k),in(L),in(R);
	/*--ST--*/
	st[0][0].x=0;
	for(int i=1;i<=n;++i){
		in(st[i][0].min);
		st[i][0].min+=st[i-1][0].min;
		st[i][0].x=i;
	}
	for(int i=1;i<=log(n)/log(2);++i)
		for(int j=0;j<=n-(1<<i)+1;++j)
			st[j][i]=min(st[j][i-1],st[j+(1<<i-1)][i-1]);
	/*--Make heap and Tree---*/
	SS tmp;
	for(int i=L;i<=n;++i){
		tmp=St(max(i-R,0),i-L);
		root[i]=new TS((TS){0,0,tmp.min,tmp.x});
		heap[heapsize++]=(HS){st[i][0].min-root[i]->min,i};
		//cout<<root[i]->x<<"->"<<i<<"="<<root[i]->min<<"->"<<st[i][0].min<<"="<<heap[heapsize-1].key<<endl;
	}
	for(int i=heapsize>>1;i;--i)down(i);
	/*--Work--*/
	long long ans=0;
	int x;
	while(k--){
		ans+=heap[1].key;
		x=heap[1].x;
		//cout<<k<<":"<<heap[1].key<<" "<<x<<"->";
		update(root[x],max(x-R,0),x-L);
		if(root[x]->min==0x7fffffff)heap[1]=heap[--heapsize];
		else heap[1].key=st[x][0].min-root[x]->min;
		//cout<<heap[1].key<<endl;
		down(1);
	}
	cout<<ans;
}

代码（手写堆）：

#include<iostream>
using namespace std;
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
char * ptr=(char *)malloc(5000000);
inline void in(int &x){
	bool flag=0;
	while(*ptr<'0'||*ptr>'9')
		if(*ptr++=='-')
			flag=1;
	x=0;
	while(*ptr>47&&*ptr<58)x=x*10+*ptr++-'0';
	if(flag)x=-x;
}
 
struct SS{
	int min,x;
}st[500000][19];
inline SS min(SS a,SS b){
	if(a.min<b.min)return a;
	else return b;
}
inline SS St(int l,int r){
	int i=log(r-l+1)/log(2);
	return min(st[l][i],st[r-(1<<i)+1][i]);
}
 
struct HS{
	int i,key,l,r,x;
	inline bool operator > (const HS a) const{
		return key>a.key;
	}
}heap[1000005];
int heapsize=1;
inline void down(int now){
	for(int next=now<<1;next<heapsize;now=next,next<<=1){
		if(next+1<heapsize&&heap[next+1]>heap[next])++next;
		if(heap[now]>heap[next])return;
		swap(heap[now],heap[next]);
	}
}
inline void up(int now){
	for(int next=now>>1;next&&heap[now]>heap[next];now=next,next>>=1)swap(heap[now],heap[next]);
}
inline void nn(int i,int l,int r){
	SS tmp=St(l,r);
	heap[heapsize++]=(HS){i,st[i][0].min-tmp.min,l,r,tmp.x};
}
int main(){
	freopen("piano.in","r",stdin);
	freopen("piano.out","w",stdout);
	fread(ptr,1,5000000,stdin);
	int n,k,L,R;
	in(n),in(k),in(L),in(R);
	/*--ST--*/
	st[0][0].x=0;
	for(int i=1;i<=n;++i){
		in(st[i][0].min);
		st[i][0].min+=st[i-1][0].min;
		st[i][0].x=i;
	}
	for(int i=1;i<=log(n)/log(2);++i)
		for(int j=0;j<=n-(1<<i)+1;++j)
			st[j][i]=min(st[j][i-1],st[j+(1<<i-1)][i-1]);
	/*--Make heap and Tree---*/
	for(int i=L;i<=n;++i)nn(i,max(i-R,0),i-L);
	for(int i=heapsize>>1;i;--i)down(i);
	/*--Work--*/
	long long ans=0;
	int tmp;
	while(k--){
		ans+=heap[1].key;
		if(heap[1].x>heap[1].l){
			nn(heap[1].i,heap[1].l,heap[1].x-1);
			up(heapsize-1);
		}
		if(heap[1].x<heap[1].r){
			nn(heap[1].i,heap[1].x+1,heap[1].r);
			up(heapsize-1);
		}
		heap[1]=heap[--heapsize];
		down(1);
	}
	cout<<ans;
}

代码（priority_queue）：

#include<iostream>
using namespace std;
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
char * ptr=(char *)malloc(5000000);
inline void in(int &x){
	bool flag=0;
	while(*ptr<'0'||*ptr>'9')
		if(*ptr++=='-')
			flag=1;
	x=0;
	while(*ptr>47&&*ptr<58)x=x*10+*ptr++-'0';
	if(flag)x=-x;
}
int st[500001][19],a[500001];
inline int St(int l,int r){
	int i=0;
	while(1<<i+1<r-l+1)++i;
	int p=st[l][i],q=st[r-(1<<i)+1][i];
	return a[p]<a[q]?p:q;
}
struct HS{
	int i,key,l,r,x;
	inline bool operator < (const HS a) const{
		return key<a.key;
	}
};
priority_queue<HS> q;
inline void nn(int i,int l,int r){
	int x=St(l,r);
	q.push((HS){i,a[i]-a[x],l,r,x});
}
int main(){
	freopen("piano.in","r",stdin);
	freopen("piano.out","w",stdout);
	fread(ptr,1,5000000,stdin);
	int n,k,L,R,i,j;
	in(n),in(k),in(L),in(R);
	/*--ST--*/
	for(i=1;i<=n;++i){
		in(a[i]);
		a[i]+=a[i-1];
		st[i][0]=i;
	}
	{
		int p,q;
		for(i=1;1<<i<n+1;++i)
			for(j=0;j<=n-(1<<i)+1;++j){
				p=st[j][i-1];
				q=st[j+(1<<i-1)][i-1];
				st[j][i]=a[p]>a[q]?q:p;
			}
	}
	/*--Make heap and Tree---*/
	for(i=L;i<=n;++i)nn(i,max(i-R,0),i-L);
	/*--Work--*/
	long long ans=0;
	HS tmp;
	while(k--){
		tmp=q.top();
		q.pop();
		ans+=tmp.key;
		if(tmp.x>tmp.l)nn(tmp.i,tmp.l,tmp.x-1);
		if(tmp.x<tmp.r)nn(tmp.i,tmp.x+1,tmp.r);
	}
	cout<<ans;
}

TA201314

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
[NOI2010]超级钢琴解题报告

超级钢琴【问题描述】小Z是一个小有名气的钢琴家，最近C博士送给了小Z一架超级钢琴，小Z希望能够用这架钢琴创作出世界上最美妙的音乐。这架超级钢琴可以弹奏出n个音符，编号为1至n。第i个音符的美妙度为Ai，其中Ai可正可负。一个“超级和弦”由若干个编号连续的音符组成，包含的音符个数不少于L且不多于R。我们定义超级和弦的美妙度为其包含的所有音符的美妙度之和。两个超级和弦被认为是相同的
复制链接

扫一扫