[洛谷P2048] [NOI2010] 超级钢琴

洛谷题目链接:[NOI2010]超级钢琴

题目描述

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

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

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

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

输入输出格式

输入格式：

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

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

输出格式：

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

输入输出样例

输入样例#1：

4 3 2 3
3
2
-6
8

输出样例#1：

11

说明

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

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

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

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

一句话题意: 在一个长度为\(n\)的序列中,要求出其中的最大的\(k\)段不同的子序列,并且满足这个子序列的长度∈\([l,r]\).

题解: 既然限定了区间的长度,所以可以考虑枚举区间的左端点,那么这样合法的右端点就组成了一个区间,对于同一个左端点,它的合法右端点的前缀和的最大值显然是这个左端点能取得的最大值,并且合法右端点的区间的第2大,第3大减去左端点的前缀和也一定是单调递减的.这让我们联想到[洛谷P1631] 序列合并.

通过枚举左端点,在合法右端点中查找第1大的前缀和,然后将它减去左端点的前缀和,再将这个值加入堆中,这样每次取出堆中的最大值,加入答案,这样堆维护的事实上就是一个区间.它具有左端点,并且记录了查找到第几大,以这个区间的权值作为键值维护堆.

然后每次取出堆中的最大值,也就是取出了这个区间,然后就可以将这个左端点对应的合法右端点的前缀和的下一个最大值加入堆中,这样维护出的前\(k\)大一定是最优的.

静态区间第\(k\)大可以用主席树实现,其他的参数注意不要打错,要开long long.

#include<bits/stdc++.h>
using namespace std;
const int N=500000+5;
typedef int _int;
#define int long long

int n, k, l, r, a[N], s[N], rk[N], root[N], temp[N], vis[N], size, cnt = 0, ans = 0;

struct president_tree{
    int ls, rs, cnt;
}t[N*20];

struct number{
    int id1, id2, val;
    bool operator < (const number &a) const{
        return val < a.val;
    }
};

priority_queue <number> h;

inline int gi(){
    int ans = 0, f = 1; char i = getchar();
    while(i<'0' || i>'9'){ if(i == '-') f = -1; i = getchar(); }
    while(i>='0' && i<='9') ans = ans*10+i-'0', i = getchar();
    return ans * f;
}

inline void update(int &x, int last, int pos, int l = 1, int r = size){
    x = ++cnt; t[x] = t[last]; t[x].cnt++;
    if(l == r) return; int mid = (l+r>>1);
    if(pos <= mid) update(t[x].ls, t[last].ls, pos, l, mid);
    else update(t[x].rs, t[last].rs, pos, mid+1, r);
}

inline int query(int x, int last, int k, int l = 1, int r = size){
    if(l == r) return vis[l];
    int mid = (l+r>>1), sum = t[t[x].ls].cnt-t[t[last].ls].cnt;
    if(k <= sum) return query(t[x].ls, t[last].ls, k, l, mid);
    return query(t[x].rs, t[last].rs, k-sum, mid+1, r);
}

_int main(){
    // freopen("sequence.in", "r", stdin);
    // freopen("sequence.out", "w", stdout);
    n = gi(), k = gi(), l = gi(), r = gi();
    for(int i=1;i<=n;i++) a[i] = gi(), s[i] = s[i-1]+a[i];
    memcpy(temp, s, sizeof(s));
    sort(temp+1, temp+n+1); size = unique(temp+1, temp+n+1)-temp-1;
    for(int i=1;i<=n;i++){
        rk[i] = lower_bound(temp+1, temp+size+1, s[i])-temp;
        vis[rk[i]] = s[i];
    }
    for(int i=1;i<=n;i++) update(root[i], root[i-1], rk[i]);
    for(int tmp, i=1;i<=n-l+1;i++){
        int lim = min(n, i+r-1);
        h.push((number){ i, lim-i-l+2, query(root[lim], root[i+l-2], lim-i-l+2)-s[i-1] });
    }
    for(int i=1;i<=k;i++){
        number top, tmp; top = h.top(); h.pop();
        ans += top.val;
        if(top.id2 <= 1) continue;
        tmp.id2 = top.id2-1, tmp.id1 = top.id1;
        int lim = min(n, top.id1+r-1);
        tmp.val = query(root[lim], root[tmp.id1+l-2], tmp.id2)-s[top.id1-1];
        h.push(tmp);
    }
    cout << ans << endl;
    return 0;
}

转载于:https://www.cnblogs.com/BCOI/p/9338648.html