NOI 2010 COGS 468 BZOJ 2006 超级钢琴 RMQ 堆 => 乱搞 （脑洞要大大的）

感觉做这种乱搞式的题脑洞一定要大，不然想不出来解法。而且这种题解法经常有很多。然而自己脑洞小得可怜，也没想出来哪个新的解法，所以还是看了看题解按照大众解法写的这道题。 T^T

我们把多个区间构成的集合看成一个状态，(i, l, r, v, p)一个五元组，代表区间左端点为i，右端点在[l,r]中，这些区间中和最大的为v，这个和最大的区间的右端点是p。
我们把这些状态放进堆中，每次取出v最大的状态，然后“裂解”这个状态，变成(i, l, p-1, v, p)和(i, p+1, r, v, p)，裂解之前的原状态中包含r-l+1个区间，取出最优的一个，分成两个小状态之后，两个小状态一共包含r-l个区间。如此，从堆中取k次就得到了答案。
最初放进堆中的状态当然是包含了所有区间的状态，即(i, i+L-1, i+R-1, v, p)枚举i即可。

那么，还剩下最后一个问题，解出v，p。因为i，l，r都是很容易得到的，而v，p不能直接得到。设A是原序列的前缀和，每次求v相当于求max{A[p] - A[i-1]} p ∈ [l,r]，即max{A[p]} - A[i-1]，这就变成了赤裸裸的RMQ问题，用ST算法解决很好。为了方便，这次ST算法中不直接保存最大值，保存最大值下标，方便求p。

自己还是比较喜欢这样没有固定算法的题的，它比较锻炼思(nao)考(dong)能(da)力(xiao)，像这道题中这样的“状态”的设计，自己就想不出来，仍需要锻(kai)炼(nao)呐(dong)。T^T

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;
typedef long long LL;

int N, K, L, R;
LL ans, f[500005][25], a[500005];

struct Node{
    int i, l, r, p; LL v;
    bool operator < (Node K) const
    {
        return v < K.v;
    }
    void calc()
    {
        int m = floor(log(r-l+1.0)/log(2.0));
        p = a[f[l][m]] > a[f[r-(1<<m)+1][m]] ? f[l][m] : f[r-(1<<m)+1][m];
        v = a[p] - a[i-1];
    }
};

priority_queue <Node> q;

int main()
{
    scanf("%d %d %d %d", &N, &K, &L, &R);
    for(int i = 1; i <= N; i++)
    {
        scanf("%lld", a+i); 
        a[i] += a[i-1]; f[i][0] = i;
    }
    for(int i = 1; (1<<i) <= N; i++)
    {
        for(int j = 1; j+(1<<i)-1 <= N; j++)
        {
            f[j][i] = f[j+(1<<i-1)][i-1];
            if(a[f[j][i]] < a[f[j][i-1]]) f[j][i] = f[j][i-1];
        }
    }

    for(int i = 1; i+L-1 <= N; i++)
    {
        Node t; t.i = i, t.l = i+L-1, t.r = min(i+R-1, N);
        t.calc(); q.push(t);
    }

    for(int i = 1; i <= K; i++)
    {
        Node nx, t = q.top(); q.pop();
        ans += t.v;

        nx = t; nx.r = t.p - 1;
        if(nx.r >= nx.l) {nx.calc(); q.push(nx);}
        nx = t; nx.l = t.p + 1;
        if(nx.r >= nx.l) {nx.calc(); q.push(nx);}
    }

    printf("%lld", ans);
    return 0;
}