UVA1400----线段树的单点更新（十分的搞人啊）

题目地址：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=501&page=show_problem&problem=4146

题意：

给你n个数字，然后有Q次查询

每次查询，给出两个数字a,b

要你找出满足a<=x<=y<=b的条件下，【x,y】的连续和最大

因为有多次查询，所以用暴力的方法肯定承受不了

而线段树可以解决这个问题

刘汝佳的那本大白上有一点介绍，但是我觉得那个说的不完全，故我再说一遍

首先是建树的问题

我们先用一个pre_sum的数组来表示前i个数字的和，那么要求i,j的和直接用pre_sum[j]-pre[i-1]就可以了

然后就是建树了，我们还要用到三个一个是sub(x,y)，一个是前缀prex，一个是后缀suffx

分别是什么意思呢？

sub(x,y)表示的在一个（x,y）的区间中的连续子段和的左右端点，所以这是一个pair结构

prex表示的在一个区间(a,b)中从左端点开始的最大子段和的右端点

suffx表示的在一个区间(a,b)中从右端点往左的最大子段和的左端点

然后在线段树中这三个变量是可以互相递推得到的

首先是sub，对于左子树和右子树来说，一共就三种情况，左子树的sub，右子树sub，以及左子树的后缀和加上右子树的前缀和

然后根据这三个的和来决定当前的sub取哪个

然后就是前缀prex，对于左子树和右子树来说，就是两种情况，直接就是左子树的前缀，以及左子树的前缀加上右子树的前缀

然后就是后缀suffx，也是两种情况，直接就是右子树的后缀，或者是右子树的全部加上左子树的后缀

根据各自的和的大小来决策递推，这样就可以把树建好。由叶子节点网上递推

我们把树建好了之后就是要查询了。

对于每次查询，例如区间[a,b]

如果正好该区间是一个完整的，也就是不是被两棵子树截断的，那么直接就是该树的sub了

如果被截断，怎么办？

那么我们就是要查出左子树的后缀，右子树的前缀，以及左右子树的sub

左右子树最好的sub构成了一个答案区间，但是这还没完，我们可以根据刚刚求出的左子树的后缀加上右子树的前缀构成另外一个新的解答区间

然后再比较这两个区间，看哪个更加好，选择，即为答案。

至于怎么查前缀和后缀，在代码里面，这里不再赘述。上代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

#define LL long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn =  500000;
LL pre_sum[maxn];
typedef pair<int,int> PP;
struct node
{
    LL prex;
    LL suffx;
    PP sub;
}tree[maxn<<2];
int n,q;

void read()
{
    pre_sum[0] = 0;
    int a;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a);
        pre_sum[i] = pre_sum[i-1]+a;
    }
}

LL summ(int l,int r)
{
    return pre_sum[r]-pre_sum[l-1];
}

LL summ(PP a)
{
    return pre_sum[a.second] - pre_sum[a.first-1];
}

PP judge(PP a,PP b)
{
    if(summ(a) != summ(b))
        return summ(a)>summ(b)?a:b;
    return a<b?a:b;//pair 自带的字典序比较
}

void pushup(int l,int r,int rt)
{
    //递推sub
    int m = (l+r)>>1;
    int lc = rt<<1;
    int rc = rt<<1|1;
    tree[rt].sub = judge(tree[lc].sub,tree[rc].sub);
    tree[rt].sub = judge(tree[rt].sub,make_pair(tree[lc].suffx,tree[rc].prex));

    //递推prex
    LL lc_pre = summ(l,tree[lc].prex);
    LL lc_rc_pre = summ(l,tree[rc].prex);
    if(lc_pre == lc_rc_pre)
        tree[rt].prex = tree[lc].prex;
    else
        tree[rt].prex = lc_pre > lc_rc_pre ? tree[lc].prex : tree[rc].prex;

    //递推suffx
    LL rc_suff = summ(tree[rc].suffx,r);
    LL lc_rc_suff = summ(tree[lc].suffx,r);
    if(rc_suff == lc_rc_suff)
        tree[rt].suffx = tree[lc].suffx;
    else
        tree[rt].suffx = rc_suff > lc_rc_suff ? tree[rc].suffx : tree[lc].suffx;

}

void build(int l,int r,int rt)
{
    if(l==r)
    {
        tree[rt].prex = tree[rt].suffx = l;
        tree[rt].sub = make_pair(l,l);
        return;
    }

    int m = (l+r)>>1;
    build(lson);
    build(rson);
    pushup(l,r,rt);
}

PP query_pre(int l,int r,int rt,int L,int R)
{
    if(tree[rt].prex <= R)
        return make_pair(L,tree[rt].prex);
    int m = (l+r)>>1;
    if(R<=m)
        return query_pre(lson,L,R);
    PP t = query_pre(rson,L,R);
    t.first = l;
    return judge(t,make_pair(l,tree[rt<<1].prex));
}

PP query_suff(int l,int r,int rt,int L,int R)
{
    if(tree[rt].suffx >=L)
        return make_pair(tree[rt].suffx,R);
    int m = (l+r)>>1;
    if(L>m)
        return query_suff(rson,L,R);
    PP t = query_suff(lson,L,R);
    t.second = r;
    return judge(t,make_pair(tree[rt<<1|1].suffx,r));
}

PP query(int l,int r,int rt,int L,int R)
{
    if(L<=l && r<=R)
        return tree[rt].sub;
    int m = (l+r)>>1;
    if(R<=m)
        return query(lson,L,R);
    if(L>m)
        return query(rson,L,R);
    PP t1 = query_pre(rson,L,R);
    PP t2 = query_suff(lson,L,R);
    PP t3 = judge(query(lson,L,R),query(rson,L,R));
    return judge(make_pair(t2.first,t1.second),t3);
}

int main()
{
    int ca = 1;
    while(~scanf("%d%d",&n,&q))
    {
        read();
        build(1,n,1);
        int L,R;
        printf("Case %d:\n",ca++);
        while(q--)
        {
            scanf("%d%d",&L,&R);
            PP ans = query(1,n,1,L,R);
            printf("%d %d\n",ans.first,ans.second);
        }
    }
    return 0;
}