uvalive 3938 Ray, Pass me the dishes!（线段树）

题目链接：https://vjudge.net/problem/UVALive-3938

题意：

给一个数组，多次查询，询问区间[l, r]最大连续和。

思路：

线段树。
查询一个区间的最大连续和，可以找一个mid，这个最大连续和的起点和终点，
可能在mid的左边，或者在mid的右边，或者横跨mid。

左区间和右区间的最大值是递归定义的，维护起来也是容易的。

横跨mid的最大值如何计算？等于左区间最大后缀+右区间最大前缀。

如何维护区间最大前缀和区间最大后缀？

设一个区间为[l, r],
设它的左区间最大前缀为[l, idx1]，右区间最大前缀为[(l+r)/2+1, idx2]
那么区间最大前缀为比较前缀和在区间[l, idx1]和[l, idx2]中哪一个比较大，
选择大的那个前缀和对应的那个idx。

最大后缀同理。

如何查询最大前缀？
设一个区间[l, r]，它的最大前缀为prefix,
如果prefix<=query_r(要查询的区间的右端点值)，
满足条件，直接return [l, prefix]

若prefix > query_r，那么最大前缀在当前区间的左区间或者右区间。
当mid = (l+r)/2 >= query_r，那么要查询的最大前缀在区间[l, mid];
当mid < query_r，那么可以得到当前区间的右区间的最大前缀prefix2，
当前区间的最大前缀要在左区间最大前缀prefix1和右区间最大前缀prefix2中选择大的。

最大后缀同理。

注意当区间和相同时，取坐标比较小的那位。

代码：

（写法来源：http://www.cnblogs.com/zyb993963526/p/6547946.html）

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <utility>
#include <cstdlib>

using namespace std;

const int maxn = 1000000 + 5;
typedef long long ll;
typedef pair<int, int> Interval;

int n, m, QL, QR;
ll sum[maxn];

struct Node
{
    Interval max_sub; //最大连续和, 一个区间
    int prefix;
    int suffix;
}tree[maxn];

ll calc(int L, int R){
    return sum[R] - sum[L-1];
}

Interval better(const Interval &a, const Interval &b){
    if(calc(a.first, a.second) != calc(b.first, b.second))  // not equal
        return calc(a.first, a.second) > calc(b.first, b.second)?a:b;
    return a<b?a:b;  // 返回最左边的那个区间
}

void build(int L, int R, int rt){
    if(L==R){
        tree[rt].prefix = L;
        tree[rt].suffix = L;
        tree[rt].max_sub = make_pair(L, R);
    }
    else{
        int mid = (L+R)>>1;
        int lc = rt<<1;
        int rc = rt<<1|1;
        build(L, mid, lc);
        build(mid+1, R, rc);


        ll x1 = calc(L, tree[lc].prefix);
        ll x2 = calc(L, tree[rc].prefix);
        if(x1==x2)
            tree[rt].prefix = min(tree[lc].prefix, tree[rc].prefix);
        else
            tree[rt].prefix = x1>x2?tree[lc].prefix:tree[rc].prefix;


        x1 = calc(tree[lc].suffix, R);
        x2 = calc(tree[rc].suffix, R);
        if(x1==x2)
            tree[rt].suffix = min(tree[lc].suffix, tree[rc].suffix);
        else
            tree[rt].suffix = x1>x2?tree[lc].suffix:tree[rc].suffix;

        tree[rt].max_sub = better(tree[lc].max_sub, tree[rc].max_sub);
        tree[rt].max_sub = better(tree[rt].max_sub, make_pair(tree[lc].suffix, tree[rc].prefix));
    }
}


Interval query_prefix(int L, int R, int rt){
    if(QR >= tree[rt].prefix) 
        return make_pair(L, tree[rt].prefix);
    int mid = (L+R)>>1;
    int lc = rt<<1;
    int rc = rt<<1|1;
    if(QR<=mid) 
        return query_prefix(L, mid, lc);
    Interval x = query_prefix(mid+1, R, rc);
    x.first = L;
    return better(x, make_pair(L, tree[lc].prefix));
}



Interval query_suffix(int L, int R, int rt){
    if(QL<=tree[rt].suffix) 
        return make_pair(tree[rt].suffix, R);
    int mid = (L+R)>>1;
    int lc = rt<<1;
    int rc = rt<<1|1;
    if(QL>mid)
        return query_suffix(mid+1, R, rc);
    Interval x = query_suffix(L, mid, lc);
    x.second = R;
    return better(x, make_pair(tree[rc].suffix, R));

}


Interval query(int L, int R, int rt){
    if(QL<=L && R<=QR)
        return tree[rt].max_sub;
    int mid = (L+R)>>1;
    int lc = rt<<1;
    int rc = rt<<1|1;
    if(QR <= mid) return query(L, mid, lc); 
    if(QL > mid)  return query(mid+1, R, rc); 
    Interval x1 = query_suffix(L, mid, lc);
    Interval x2 = query_prefix(mid+1, R, rc);
    Interval x3 = better(query(L, mid, lc), query(mid+1, R, rc));
    return better(make_pair(x1.first, x2.second), x3);
}

int main(){
    int x, kase=0;
    ios::sync_with_stdio(false);
    while(cin>>n>>m){
        sum[0] = 0;
        for(int i=1; i<=n; ++i){
            cin>>x;
            sum[i] = sum[i-1] + x;
        }
        build(1, n, 1);
        cout<<"Case "<<++kase<<":"<<endl;
        for(int i=0; i<m; ++i){
            cin>>QL>>QR;
            Interval ans = query(1, n, 1);
            cout<<ans.first<<" "<<ans.second<<endl;
        }
    }
    return 0;
}