BZOJ2006 [NOI2010]超级钢琴 【堆 + RMQ】

2006: [NOI2010]超级钢琴

Time Limit: 20 Sec  Memory Limit: 552 MB
Submit: 3446  Solved: 1692
[Submit][Status][Discuss]

Description

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

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

和弦”由若干个编号连续的音符组成，包含的音符个数不少于L且不多于R。我们定义超级和弦的美妙度为其包含的

所有音符的美妙度之和。两个超级和弦被认为是相同的，当且仅当这两个超级和弦所包含的音符集合是相同的。 

小Z决定创作一首由k个超级和弦组成的乐曲，为了使得乐曲更加动听，小Z要求该乐曲由k个不同的超级和弦组成。

我们定义一首乐曲的美妙度为其所包含的所有超级和弦的美妙度之和。小Z想知道他能够创作出来的乐曲美妙度最

大值是多少。

Input

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

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

N<=500,000

k<=500,000

-1000<=Ai<=1000,1<=L<=R<=N且保证一定存在满足条件的乐曲

Output

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

Sample Input

4 3 2 3
3
2
-6
8

Sample Output

11

【样例说明】
共有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。

我们利用前缀和可以很快得到最大的答案

对于每个点i，我们只要求出sum[i + L - 1] 到 sum[i + R - 1]中最大的值就可以得到以i为左端点的最大值

我们设这样一个值为三元组(i,l,r)的值，表示以i开头右端点在[l,r]内的区间最大和

利用这个，我们求出最大值后，求第二大的值可能以其它i开头，也可能仍然以当前i开头，我们就把当前(i,l,r)分裂成

(i,l,t - 1)和(i,t + 1,r)就可以了

重复K次，即得结果

但是如何做到快速求区间最大值呢？

这就用到了RMQ算法【ST表】

ST表是用以解决区间最大值无修改的算法，预处理O(nlogn),查询O(1)

可以说在没有修改的情况下比线段树优很多

具体实现：

预处理

我们设mx[i][j]表示以[i,i + 2^j - 1]，也就是以i开头长度为2^j的区间的最大值

利用倍增的方法，mx[i][j] = max(mx[i][j - 1],mx[i + 2^(j - 1)][j - 1]);

我们可以处理出所有的mx【但是要注意数组不要越界】

查询

我们要查询的区间长度是2的n次方很好办，就是mx[i][n]

但是如果不是呢？

我们可以把原区间分成两个相交的2^n的区间，求二者的最大值即可

具体区间为[l,r]，我们令t = log2(r - l + 1)，则ans = max(mx[l][t],mx[r - 2^t + 1][t]);

最后我们就可以A啦

【STL似乎不会T】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
#define mp(a,b,c,d) (node){a,b,c,d}
#define LL long long int
#define REP(i,n) for (int i = 1; i <= (n); i++)
using namespace std;
const int maxn = 500005,maxm = 100005,INF = 1000000000;
inline int RD(){
	int out = 0,flag = 1; char c = getchar();
	while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
	while (c >= 48 && c <= 57) {out = (out << 1) + (out << 3) + c - '0'; c = getchar();}
	return out * flag;
}
int N,K,L,R,sum[maxn],mx[maxn][30],Log[maxn];
LL ans = 0;
struct node{int i,l,r,t;};
inline bool operator <(const node& a,const node& b){return sum[a.t] - sum[a.i - 1] < sum[b.t] - sum[b.i - 1];}
priority_queue<node,vector<node> > q;
void RMQ(){
	Log[0] = -1;
	for (int i = 1; i <= N; i++) Log[i] = Log[i >> 1] + 1;
	int t = Log[N];
	REP(i,N) mx[i][0] = i;
	for (int i = N; i; i--){
		for (int j = 1; j <= t; j++){
			if (i + (1 << j) - 1 > N) break;
			int t1 = mx[i][j - 1],t2 = mx[i + (1 << j - 1)][j - 1];
			mx[i][j] = sum[t1] > sum[t2] ? t1 : t2;
		}
	}
}
inline int Query(int l,int r){
	if (l == r) return l;
	int t = Log[r - l + 1],t1 = mx[l][t],t2 = mx[r - (1 << t) + 1][t];
	return sum[t1] > sum[t2] ? t1 : t2;
}
void solve(){
	node u;
	REP(i,N){
		if (i + L - 1 > N) break;
		int r = min(i + R - 1,N);
		q.push(mp(i,i + L - 1,r,Query(i + L - 1,r)));
	}
	for (int i = 1; i <= K; i++){
		u = q.top(); q.pop();
		ans += sum[u.t] - sum[u.i - 1];
		if (u.t - 1 >= u.l) q.push(mp(u.i,u.l,u.t - 1,Query(u.l,u.t - 1)));
		if (u.t + 1 <= u.r) q.push(mp(u.i,u.t + 1,u.r,Query(u.t + 1,u.r)));
	}
}
int main(){
	N = RD(); K = RD(); L = RD(); R = RD();
	REP(i,N) sum[i] = sum[i - 1] + RD();
	RMQ();
	solve();
	cout<<ans<<endl;
	return 0;
}