uva 1400 Ray, Pass me the dishes!(线段树， 分治法求最大连续和)

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <limits>
#include <set>
#include <time.h>
#include <errno.h>

using namespace std;

#define MIN(a, b) a < b ? a : b
#define MAX(a, b) a > b ? a : b
#define F(i, n) for (int i=0;i<(n);++i)
#define REP(i, s, t) for(int i=s;i<=t;++i)
#define UREP(i, s, t) for(int i=s;i>=t;--i)
#define REPOK(i, s, t, o) for(int i=s;i<=t && o;++i)
#define MEM0(addr, size) memset(addr, 0, size)
#define LBIT(x) x&-x

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398
#define eps 1e-15

#define MAXN 500000
#define MAXM 1000
#define MOD 20071027

typedef long long LL;

const double maxdouble = numeric_limits<double>::max();
const int INF = 0x7FFFFFFF;

typedef pair<int,int> Interval;

LL prefix_sum[MAXN + 10];

LL sum(int L, int R) {
return prefix_sum[R] - prefix_sum[L-1];
}

LL sum(Interval p) {
return sum(p.first, p.second);
}

Interval better(Interval a, Interval b) {
if(sum(a) != sum(b)) return sum(a) > sum(b) ? a : b;
return a < b ? a : b; // 利用pair自带的字典序
}

const int maxnode = 1 << 21; // 修改以确保足够大
struct IntervalTree {
int max_suffix[maxnode+1];
int max_prefix[maxnode+1];
Interval max_sub[maxnode+1];
int length;
int p, v;
int qL, qR;

void init(int n) {
length = n;
//memset(minv, 0, sizeof(int) * (n + 5));
}
//_query的封装
Interval query(int L, int R) {
qL = L;
qR = R;
return _query(1, 1, length);
}

void build(int o, int L, int R) {
if (L == R) {
max_sub[o] = make_pair(L, L);
max_prefix[o] = L;
max_suffix[o] = L;
} else {
int M = L + (R-L)/2;
int lc = 2*o, rc = 2*o+1;
LL v1, v2; // 注意 sum 会溢出int，要用LL
build(lc, L, M);
build(rc, M+1, R);

// 递推preffix
v1 = sum(L, max_prefix[lc]);
v2 = sum(L, max_prefix[rc]);
//if(v1 == v2) max_prefix[o] = min(max_prefix[lc], max_prefix[rc]);
//else max_prefix[o] = v1 > v2 ? max_prefix[lc] : max_prefix[rc];
max_prefix[o] = v1 >= v2 ? max_prefix[lc] : max_prefix[rc];// 因为要求字典序最小

// 递推suffix
v1 = sum(max_suffix[lc], R);
v2 = sum(max_suffix[rc], R);
//if(v1 == v2) max_suffix[o] = min(max_suffix[lc], max_suffix[rc]);
//else max_suffix[o] = v1 > v2 ? max_suffix[lc] : max_suffix[rc];
max_suffix[o] = v1 >= v2 ? max_suffix[lc] : max_suffix[rc];

max_sub[o] = better(max_sub[lc], max_sub[rc]);
max_sub[o] = better(max_sub[o], make_pair(max_suffix[lc], max_prefix[rc]));
}
}

Interval _query_preffix(int o, int L, int R) {
if (max_prefix[o] <= qR) // L 是一定包含在查询区间中的
return make_pair(L, max_prefix[o]);
int M = L + (R-L)/2;
int lc = 2*o, rc = 2*o+1;
if (qR <= M)
return _query_preffix(lc, L, M);
Interval i = _query_preffix(rc, M+1, R);
i.first = L;
return better(i, make_pair(L, max_prefix[lc]));
}

Interval _query_suffix(int o, int L, int R) {
if (max_suffix[o] >= qL)
return make_pair(max_suffix[o], R);
int M = L + (R-L)/2;
int lc = 2*o, rc = 2*o+1;
if (qL > M)
return _query_suffix(rc, M+1, R);
Interval i = _query_suffix(lc, L, M);
i.second = R;
return better(i, make_pair(max_suffix[rc], R));
}

Interval _query(int o, int L, int R) {
if (qL <= L && qR >= R)
return max_sub[o];
int M = L + (R-L)/2;
int lc = 2*o, rc = 2*o + 1;
if (qR <= M)
return _query(lc, L, M);
if (qL > M)
return _query(rc, M+1, R);

Interval suffix = _query_suffix(lc, L, M); // 左半的后缀和
Interval preffix = _query_preffix(rc, M+1, R); // 右半的前缀和

Interval ret = better(_query(lc, L, M), _query(rc, M+1, R));
ret = better(ret, make_pair(suffix.first, preffix.second)); // 和最大区间过中点的情况
return ret;
}
};

IntervalTree tree;

int main()
{
int n, m;
int tmp;
int cases = 0;

while(scanf("%d%d", &n, &m) != EOF) {
prefix_sum[0] = 0;
F(i, n) {
scanf("%d",&tmp);
prefix_sum[i+1] = prefix_sum[i] + tmp;
}
// build tree
tree.init(n);
tree.build(1, 1, n);

printf("Case %d:\n", ++cases);

F(i, m) {
int l, r;
scanf("%d%d",&l, &r);
Interval interval = tree.query(l, r);
printf("%d %d\n", interval.first, interval.second);
}
}
return 0;
}