UVa 1400 (线段树) "Ray, Pass me the dishes!"

求一个区间的最大连续子序列，基本想法就是分治，这段子序列可能在区间的左半边，也可能在区间的右半边，也有可能是横跨区间中点，这样就是左子区间的最大后缀加上右子区间的最大前缀之和。

线段树维护三个信息：区间最大前缀、最大后缀、最大连续子区间的下标。

最大前缀可以通过递推来求：要么是左子区间的最大前缀和、要么是左子区间的和 加上 右子区间的最大前缀和

最大后缀和的递推类似。

递推之前要预处理整个序列的前缀和。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define MP make_pair
 #define lch(o) (o*2)
 #define rch(o) (o*2+1)
 using namespace std;

 typedef long long LL;
 typedef pair<int, int> Interval;
 const int maxn =  + ;
 const int maxnode =  + ;

 LL prefix_sum[maxn];

 LL sum(int a, int b) { return prefix_sum[b] - prefix_sum[a-]; }

 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自带字典序
 }

 int qL, qR; //查询区间

 struct IntervalTree
 {
     int max_prefix[maxnode], max_suffix[maxnode];
     Interval max_sub[maxnode];

     void build(int o, int L, int R)
     {
         if(L == R) { max_prefix[o] = max_suffix[o] = L; max_sub[o] = MP(L, L); }
         else
         {
             int M = (L + R) >> ;
             int lc = lch(o), rc = rch(o);
             build(lc, L, M);
             build(rc, M+, R);

             //递推max_prefix
             LL v1 = sum(L, max_prefix[lc]);
             LL 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_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_sub
             max_sub[o] = better(max_sub[lc], max_sub[rc]);
             max_sub[o] = better(max_sub[o], MP(max_suffix[lc], max_prefix[rc]));
         }
     }

     Interval query_prefix(int o, int L, int R)
     {
         if(max_prefix[o] <= qR) return MP(L, max_prefix[o]);
         int M = (L + R) >> ;
         int lc = lch(o), rc = rch(o);
         if(qR <= M) return query_prefix(lc, L, M);
         Interval i = query_prefix(rc, M+, R);
         i.first = L;
         return better(i, MP(L, max_prefix[lc]));
     }

     Interval query_suffix(int o, int L, int R)
     {
         if(max_suffix[o] >= qL) return MP(max_suffix[o], R);
         int M = (L + R) >> ;
         int lc = lch(o), rc = rch(o);
         if(qL > M) return query_suffix(rc, M+, R);
         Interval i = query_suffix(lc, L, M);
         i.second = R;
         return better(i, MP(max_suffix[rc], R));
     }

     Interval query(int o, int L, int R)
     {
         if(qL <= L && R <= qR) return max_sub[o];
         int M = (L + R) >> ;
         int lc = lch(o), rc = rch(o);
         if(qR <= M) return query(lc, L, M);
         if(qL > M) return query(rc, M+, R);
         Interval i1 = query_suffix(lc, L, M);//左子区间的最大后缀
         Interval i2 = query_prefix(rc, M+, R);//右子区间的最大前缀
         Interval i3 = better(query(lc, L, M), query(rc, M+, R));//两个子区间的最大连续和
         return better(i3, MP(i1.first, i2.second));
     }
 }tree;

 int main()
 {
     //freopen("in.txt", "r", stdin);

     int kase = , n, a, Q;
     while(scanf("%d%d", &n, &Q) == )
     {
         prefix_sum[] = ;
         for(int i = ; i <= n; i++) { scanf("%d", &a); prefix_sum[i] = prefix_sum[i-] + a; }
         tree.build(, , n);
         printf("Case %d:\n", ++kase);
         while(Q--)
         {
             int L, R;
             scanf("%d%d", &L, &R);
             qL = L; qR = R;
             Interval ans = tree.query(, , n);
             printf("%d %d\n", ans.first, ans.second);
         }
     }

     return ;
 }

代码君