LA 3938

经历无数次RE 最后来了一个TLE 先放着以后在做 o(︶︿︶)o 唉
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 500100;
struct node1 {
    int max_sub_x, max_sub_y;
    ll max_sub, max_suffix, max_prefix;
    int max_suffix_x;
    int max_prefix_x;
}N[4 * maxn];
int val[maxn], sum[maxn];

void build_prefix(int o, int l, int r) {
    int m = (l + r) / 2;
    if(l == r) {
        N[o].max_prefix = val[l];
        N[o].max_prefix_x = l;
    }
    else {
        build_prefix(o * 2, l, m);
        build_prefix(o * 2 + 1, m + 1, r);
        int max1 = sum[m] - sum[l - 1] + N[o * 2 + 1].max_prefix;
        if(N[o * 2].max_prefix >= max1) {
            N[o].max_prefix = N[o * 2].max_prefix;
            N[o].max_prefix_x = N[o * 2].max_prefix_x;
        }
        else {
            N[o].max_prefix = max1;
            N[o].max_prefix_x = N[o * 2 + 1].max_prefix_x;
        }
    }
}

void build_suffix(int o, int l, int r) {
    int m = (l + r) / 2;
    if(l == r) {
        N[o].max_suffix = val[l];
        N[o].max_suffix_x = l;
    }
    else {
        build_suffix(o * 2, l, m);
        build_suffix(o * 2 + 1, m + 1, r);
        int max1 = sum[r] - sum[m] + N[o * 2].max_suffix;
        if(max1 >= N[o * 2 + 1].max_suffix) {
            N[o].max_suffix = max1;
            N[o].max_suffix_x = N[o * 2].max_suffix_x;
        }
        else {
            N[o].max_suffix = N[o * 2 + 1].max_suffix;
            N[o].max_suffix_x = N[o * 2 + 1].max_suffix_x;
        }
    }
}

struct node2 {
    ll val;
    int x, y;
}c[10];

bool cmp(node2 A, node2 B) {
    if(A.val != B.val) return A.val > B.val;
    else if(A.x != B.x) return A.x < B.x;
    else return A.y < B.y;
}

void build_max_sub(int o, int l, int r) {
    int m = (l + r) / 2;
    if(l == r) {
        N[o].max_sub = val[l];
        N[o].max_sub_x = N[o].max_sub_y = l;
    }
    else {
        build_max_sub(o * 2, l, m);
        build_max_sub(o * 2 + 1, m + 1, r);
        c[0].val = N[o * 2].max_sub;
        c[0].x = N[o * 2].max_sub_x;
        c[0].y = N[o * 2].max_sub_y;
        c[1].val = N[o * 2 + 1].max_sub;
        c[1].x = N[o * 2 + 1].max_sub_x;
        c[1].y = N[o * 2 + 1].max_sub_y;
        c[2].val = N[o * 2].max_suffix + N[o * 2 + 1].max_prefix;
        c[2].x = N[o * 2].max_suffix_x;
        c[2].y = N[o * 2 + 1].max_prefix_x;
        sort(c, c + 3, cmp);
        N[o].max_sub = c[0].val;
        N[o].max_sub_x = c[0].x;
        N[o].max_sub_y = c[0].y;
    }
}

node2 query_prefix(int o, int l, int r, int ql, int qr) {
    int m = (l + r) / 2;
    if(N[o].max_prefix_x <= ql) {
        c[0].x = l;
        c[0].y = N[o].max_prefix_x;
        c[0].val = N[o].max_prefix;
    }
    else if(qr <= m) {
        c[0] = query_prefix(o * 2, l, m, ql, qr);
    }
    else {
        c[0] = query_prefix(o * 2, l, m, ql, qr);
        c[2] = query_prefix(o * 2 + 1, m + 1, r, m + 1, qr);
        c[1].x = l;
        c[1].val = c[2].val + sum[m] - sum[l - 1];
        c[1].y = c[2].y;
        sort(c, c + 2, cmp);
    }
    return c[0];
}

node2 query_suffix(int o, int l, int r, int ql, int qr) {
    int m = (l + r) / 2;
    if(N[o].max_suffix_x >= ql) {
        c[0].x = N[o].max_suffix_x;
        c[0].y = r;
        c[0].val = N[o].max_suffix;
    }
    else if(ql > m) {
        c[0] = query_suffix(o * 2 + 1, m + 1, r, ql, qr);
    }
    else {
        c[0] = query_suffix(o * 2 + 1, m + 1, r, ql, qr);
        c[2] = query_suffix(o * 2, l, m, ql, m);
        c[1].x = c[2].x;
        c[1].val = c[2].val + sum[r] - sum[m];
        c[1].y = r;
        sort(c, c + 2, cmp);
    }
    return c[0];
}

node2 query_sub(int o, int l, int r, int ql, int qr) {
    int m = (l + r) / 2;
    node2 a, b;
    if(ql <= l && qr >= r) {
        c[0].val = N[o].max_sub;
        c[0].x = N[o].max_sub_x;
        c[0].y = N[o].max_sub_y;
        return c[0];
    }
    if(qr <= m) return query_sub(o * 2, l, m, ql, qr);
    else if(ql > m) return query_sub(o * 2 + 1, m + 1, r, ql, qr);
    else {
        c[0] = query_sub(o * 2, l, m, ql, m);
        c[1] = query_sub(o * 2 + 1, m + 1, r, m + 1, qr);
        a = query_suffix(o * 2, l, m, ql, m);
        b = query_prefix(o * 2 + 1, m + 1, r, m + 1, qr);
        c[2].val = a.val + b.val;
        c[2].x = a.x;
        c[2].y = b.y;
        sort(c, c + 3, cmp);
        return c[0];
    }
}

int main() {
    int n, m, kase = 0, ql, qr, num = 0;
    while(scanf("%d%d", &n, &m) != EOF) {
        sum[0] = 1;
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &val[i]);
            sum[i] = sum[i - 1] + val[i];
        }
        build_prefix(1, 1, n);
        build_suffix(1, 1 ,n);
        build_max_sub(1, 1, n);
        printf("Case %d:\n", ++kase);
        while(m--) {
            scanf("%d%d", &ql, &qr);
            node2 ans = query_sub(1, 1, n, ql, qr);
            printf("%lld %lld\n", ans.x, ans.y);
        }
    }
    return 0;
}