uvalive 3938 "Ray, Pass me the dishes!" 线段树 区间合并

题意：求q次询问的静态区间连续最大和起始位置和终止位置 输出字典序最小的解.

思路：刘汝佳白书 每个节点维护三个值

pre, sub, suf 最大的前缀和, 连续和, 后缀和 然后这个题还要记录解的位置所以还要区间总和sum

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdlib>
 #include<cstdio>
 #include<set>
 #include<map>
 #include<vector>
 #include<cstring>
 #include<stack>
 #include<cmath>
 #include<queue>
 #include <bits/stdc++.h>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define ll long long
 #define clc(a,b) memset(a,b,sizeof(a))

 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; // 利用pair自带的字典序
 }

 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);

             // 递推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], 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 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 ;
 }