BZOJ 2006 && NOI 2010 [优先队列]

2006: [NOI2010]超级钢琴
小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

考试考到一道很像的题目QAQ
%%% wjl

因为要不断地取最大值，那么其实就是一个动态的过程，就可以用优先队列维护一个结构

struct node {
    int from, pos, l, r, sum;
    node(int f = 0, int p = 0, int _l = 0, int _r = 0, int s = 0):from(f), pos(p), l(_l), r(_r), sum(s) {}
};
struct cmp {
    inline bool operator ()(const node &a, const node &b) {
        return a.sum < b.sum;
    }
};

表示从$from$音符开始长度大于等于$l$小于等于$r$的最大值及最大值的位置$pos$。
那么只要用$ST$表预处理一下很快就出来了。
之后只要对每一个$node$取出时，加入$node(from, GETMAXPOS, l, pos - 1, SUM)$ 和 $node(from, GETMAXPOS, pos + 1, r, SUM)$
处理一个前缀和就好啦。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

inline char get(void) {
    static char buf[1000000], *p1 = buf, *p2 = buf;
    if (p1 == p2) {
        p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
        if (p1 == p2) return EOF;
    }
    return *p1++;
}
inline void read(int &x) {
    x = 0; char c = get(); int sign = 1;
    for (; c < '0' || c > '9'; c = get()) if(c == '-') sign = 0;
    for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = get());
    x = sign ? x : -x;
}

const int N = 500010;

int f[30][N << 1], fp[30][N << 1];
struct node {
    int from, pos, l, r, sum;
    node(int f = 0, int p = 0, int _l = 0, int _r = 0, int s = 0):from(f), pos(p), l(_l), r(_r), sum(s) {}
};
struct cmp {
    inline bool operator ()(const node &a, const node &b) {
        return a.sum < b.sum;
    }
};
priority_queue<node, vector<node>, cmp> Q;
int n, k, l, r, x, y, ll, rr;
long long ans;
int a[N];
node X;

void Prep(void) {
    for (int k = 1, base = 1; base * 2 <= n; k++, base <<= 1) {
        for (int i = 1; i <= n; i++) {
            x = f[k - 1][i]; y = f[k - 1][i + base];
            if (x > y) {
                f[k][i] = x; fp[k][i] = fp[k - 1][i];
            } else {
                f[k][i] = y; fp[k][i] = fp[k - 1][i + base];
            }
        }
    }
}
inline void Query(int l, int r, int &x, int &y) {
    static int len, p, q, base, cnt;
    len = r - l + 1; cnt = 0;
    for (base = 1; (base <<= 1) <= len; cnt++);
    base >>= 1;
    p = f[cnt][l]; q = f[cnt][r - base + 1];
    if (p > q) {
        x = p; y = fp[cnt][l];
    } else {
        x = q; y = fp[cnt][r - base + 1];
    }
}

int main(void) {
    read(n); read(k); read(l); read(r); --l; --r;
    for (int i = 1; i <= n; i++) {
        read(a[i]); a[i] += a[i - 1];
        f[0][i] = a[i]; fp[0][i] = i;
    }
    Prep();
    for (int i = 1; i <= n - l; i++) {
        ll = i + l; rr = min(n, i + r);
        Query(ll, rr, x, y);
        x-= a[i - 1];
        Q.push(node(i, y, ll, rr, x));
    }
    for (int i = 0; i < k; i++) {
        X = Q.top(); Q.pop();
        ans += X.sum;
        if (X.pos + 1 <= X.r) {
            Query(X.pos + 1, X.r, x, y);
            x -= a[X.from - 1];
            Q.push(node(X.from, y, X.pos + 1, X.r, x));
        }
        if (X.l + 1 <= X.pos) {
            Query(X.l, X.pos - 1, x, y);
            x -= a[X.from - 1];
            Q.push(node(X.from, y, X.l, X.pos - 1, x));
        }
    }
    cout << ans << endl;
    return 0;
}