LA 3938 动态最大连续和

题目链接：https://vjudge.net/contest/146667#problem/C

题意：动态的求一个区间的最大连续和。

分析：

看上去可以RMQ去做，但是，当分成两个部分，原来的部分的解可能是跨越这两个区间的。原问题的解不能通过RMQ分成的两个部分的解而得到。

线段树：

线段树很早之前就有学习，那个时候只会套模板，而这个题目几乎就是线段树的一个理解应用。

就在刚刚之前提到的那个问题一样，可以利用线段树维护3个信息：

max_prefix（最大前缀和的标号）

max_suffix（最大后缀和的标号）

有了这两个信息，就可以跨区间找到丢失的信息了。

还有一个就是结果 max_sub（最大连续和的标号，其中是一个pair类型）

建树时：

建好左右子树后，递推max_prefix,max_suffix，这两个都不用跨区间，递推max_sub需要跨区间。

这里没有更新操作。

询问时：

同样分三种情况，左半边，右半边，跨区间。

跨区间这里，就用到了我们之前维护的最大前缀和标号，和最大后缀和标号。

那么如何得到最大前缀和标号，和最大后缀和标号呢？

同理：也是分区间查找，但是右半部分的左边的标号必须是L，左半部分简单一点，就是左孩子的最大前缀和的标号。

同理最大后缀和的标号。

 #include <bits/stdc++.h>
 
 using namespace std;
 
 const int maxn =  + ;
 const int maxnode =  + ;
 typedef long long LL;
 typedef pair<int,int> Interval;
 
 LL prefix_sum[maxn];
 
 //求区间和
 LL sum(int L,int R) {
     return prefix_sum[R] - prefix_sum[L-];
 }
 
 //求区间和
 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;
 }
 
 int qL,qR;
 
 struct IntervalTree
 {
     int max_prefix[maxnode];    //最大前缀和对应的标号
     int 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] = make_pair(L,L);
         }
         else
         {
             int M = L+(R-L)/;
             int lc = o*,rc = o*+;
             build(lc,L,M);
             build(rc,M+,R);
 
             //递推最大前缀和
             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];
 
             //递推最大后缀和
             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[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_prefix(int o,int L,int R)
     {
         if(max_prefix[o]<=qR) return make_pair(L,max_prefix[o]);
         int M = L + (R-L)/;
         int lc = o*,rc = o* + ;
         if(qR<=M) return query_prefix(lc,L,M);
         Interval i = query_prefix(rc,M+,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) /;
         int lc = o*,rc = o*+;
         if(qL>M) return query_suffix(rc,M+,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&&R<=qR) return max_sub[o];
         int M = L + (R - L) /;
         int lc = o*,rc = o*+;
         if(qR<=M) return query(lc,L,M);
         if(qL>M) return query(rc,M+,R);
         Interval i1 = query_prefix(rc,M+,R);
         Interval i2 = query_suffix(lc,L,M);
         Interval i3 = better(query(lc,L,M),query(rc,M+,R));    //分开
         return better(make_pair(i2.first,i1.second),i3);        //跨区间
     }
 
 };
 
 IntervalTree tree;
 
 int main()
 {
     int n,q,a;
     int cases = ;
     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",cases++);
 
         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 ;
 }