1、题意：给一个序列，让你取出k个不同的区间，要求长度在之间，问所有区间和的最大值

2、分析：这道题拿过来就能知道是要拿出前k个最大的区间，我们思考最暴力的做法，就是把这个所有的区间枚举出来算，取出前k个最大的，这个思路的复杂度很高，达到 很明显，这会超时，我们尝试换个角度，我们维护一个大根堆我们枚举所有的区间的左端点，然后我在 这个区间中选一个区间最大的，和大根堆中的最小数比较，如果大，那就加入堆，然后比较次大的，这样的复杂度呢？ 是不是感觉卵用没有，但是这个算法的复杂度远远达不到上界，虽然说卡这个算法还是比较容易的，然后进一步思考，我们每次都是固定左端点的选一个，那么能不能再全局中选呢？依旧是这样，我们维护一个大根堆，这次我们要将每一个左端点的最大值先加入堆中，然后我们每次取出最大值，将这个区间分成左右两段，这样就等于拿走次左端点的最大值，加入次大值和第三大….那么如此类推，我们搞到前k大，加起来就是answer了，时间复杂度，，空间嘛，我们思考一下，每一次我们都会将一个区间分裂成两个，但是只会分裂两次，所以空间是，完美解决，撒花QAQ，另附一组小数据，藏在代码中ovo

//myy orz
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
#define M 2000010
#define LL long long
#define inf 214748364

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

int a[M], sum[M];

struct Node{
    int i, L, id, R, res;

    inline bool operator < (const Node& rhs) const{
        return res < rhs.res;
    }
};
priority_queue<Node> Q;

struct myh{
    int val, id;

    inline bool operator < (const myh& rhs) const{
        return val < rhs.val;
    }
} q[M]; 

inline myh max(myh q1, myh q2){
    if(q1 < q2) return q2;
    return q1;
}

inline void build(int l, int r, int o){
    if(l == r){
        q[o].val = sum[l];
        q[o].id = l;
        return;
    }
    int mid = (l + r) / 2;
    build(l, mid, 2 * o);
    build(mid + 1, r, 2 * o + 1);
    q[o] = max(q[2 * o], q[2 * o + 1]);
}

inline myh query(int l, int r, int o, int x, int y){
    if(x <= l && r <= y) return q[o];
    int mid = (l + r) / 2;
    myh mx; mx.val = -inf;
    if(x <= mid) mx = max(mx, query(l, mid, 2 * o, x, y));
    if(y > mid) mx = max(mx, query(mid + 1, r, 2 * o + 1, x, y));
    return mx;
}

int main(){
    int n = read(), k = read(), L = read(), R = read();
    for(int i = 1; i <= n; i ++) a[i] = read(), sum[i] = a[i] + sum[i - 1];
    build(1, n, 1);
    for(int i = 1; i <= n; i ++){
        if(i + L - 1 > n) break;
        myh yy = query(1, n, 1, i + L - 1, min(n, i + R - 1));
        Node c = (Node){i, L, yy.id - i + 1, min(n, i + R - 1) - i + 1, yy.val - sum[i - 1]};
        Q.push(c);
    //  printf("%d\n", yy.id);
    }
    LL ans = 0;
    for(int i = 1; i <= k; i ++){
        Node x = Q.top(); Q.pop();
        ans += x.res;
        //printf("%d::", x.res);
        if(x.id > x.L){
            myh yy = query(1, n, 1, x.i + x.L - 1, x.i + x.id - 2);
            Node c = (Node){x.i, x.L, yy.id - x.i + 1, x.id - 1, yy.val - sum[x.i - 1]};
            Q.push(c);
        //  printf("%d %d\n", yy.val - sum[x.i - 1], x.id);
        }
        if(x.id < x.R){
            myh yy = query(1, n, 1, x.i + x.id, x.i + x.R - 1);
            Node c = (Node){x.i, x.id + 1, yy.id - x.i + 1, x.R, yy.val - sum[x.i - 1]};
            Q.push(c);
        //  printf("%d\n", yy.val - sum[x.i - 1]);
        }
    }
    printf("%lld\n", ans);
    return 0;
}
/*
10 13 3 7
595
384
-435
-197
-677
661
4
-100
-653
220

*/