Can you answer these queries I (線段樹)

You are given a sequence A[1], A[2], ..., A[N] . ( |A[i]| ≤ 15007 , 1 ≤ N ≤ 50000 ). A query is defined as follows:
Query(x,y) = Max { a[i]+a[i+1]+...+a[j] ; x ≤ i ≤ j ≤ y }.
Given M queries, your program must output the results of these queries.
Input

    The first line of the input file contains the integer N.
    In the second line, N numbers follow.
    The third line contains the integer M.
    M lines follow, where line i contains 2 numbers xi and yi.

Output

    Your program should output the results of the M queries, one query per line. 

Example

Input:
3 
-1 2 3
1
1 2
Output:
2

/*
  最長區間子序列的和
  線段樹
  這裏給定一個區間 求出來 這個區間連續子序列和的最大值
  解題思路:

  lsum 代表這以這個數開始的最大和
  rsum 代表着以這個數結尾的最大和
  ans 代表這最優解
  lsum 有可能就是取左子樹的lsum 還有可能是 就是左子樹取滿 再加上 右子樹取lsum
  rsum 有可能就是取右子樹的rsum 還有可能是 右子樹全部都是最大子序列 那麼此時需要 加上 左子樹的rsum
  ans 那麼就可能去 左子樹的ans 還有可能就是取右子樹的ans 不過還有一種可能是最優解
  就是 答案如果取到左子樹的rsum + 右子樹的 lsum 這種情況在上面的lsum 和 rsum 沒有考慮到
   L:[----------------]:R
   https://vjudge.net/contest/13207#problem/A
*/


#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<stdlib.h>
#include<string.h>

using namespace std;

struct LNode
{
    int l,r;
    long long sum;//區間和
    long long lsum;//以左端點開頭的最大連續區間和
    long long rsum;//以右端點結尾的最大連續區間和
    long long ans ;//l - r 上的最大連續和
}node[50007 * 4];
void push_up(int rt)
{
    node[rt].sum = node[rt *2].sum + node[rt*2+1].sum;//更新區間和
    /*
    lsum 一共有兩種情況 就是直接取左子樹的lsum 另外一種就是取 左子樹.sum + 右子樹.lsum
    */
    node[rt].lsum = max(node[rt*2].lsum , node[rt*2].sum + node[rt*2+1].lsum);
    /*
    rsum 一共有兩種情況 就是直接取右子樹的rsum 另外一種就是取 右子樹.sum + 左子樹.rsum
    */
    node[rt].rsum = max(node[rt*2+1].rsum,node[rt*2+1].sum + node[rt*2].rsum);
    /*
    ans 一共有三種情況 第一種就是取 lusm 第二種就是 取rsum 第三種就是取 左子樹的rsum + 右子樹.lsum
    */
   node[rt].ans = node[rt*2].rsum + node[rt*2+1].lsum;
   node[rt].ans = max(node[rt].ans, max(node[rt * 2].ans,node[rt * 2 +1].ans));
}
void build(int l,int r,int rt)
{
    node[rt].l = l;//左區間
    node[rt].r = r;//右區間
    if(l == r)//達到葉子節點
    {
        scanf("%lld",&node[rt].sum);
        node[rt].lsum = node[rt].rsum = node[rt].ans = node[rt].sum;
        return ;
    }
    int mid = (l + r) /2;
    build(l,mid,rt*2);//遞歸創建左子樹
    build(mid + 1,r,rt*2+1);//遞歸創建右子樹
    push_up(rt);
}
LNode getres(int l,int r,int rt)
{
    if(node[rt].l == l && node[rt].r == r)//找到一個完全重合的區間
    {
        return node[rt];
    }
    int mid = (node[rt].l + node[rt].r)/2;
    if(mid >= r)//查詢區間完全位於左子樹
    {
        return getres(l,r,rt*2);
    }
    else if(mid < l)//完全位於右子樹
    {
        return getres(l,r,rt*2+1);
    }
    else//位於這個區間內部
    {
        LNode res;
        LNode lres,rres;
        //如果不滿足以上的情況 那麼就是說明了所查區間就是tree[rt]的一個子集
        lres = getres(l,mid,rt*2);
        rres = getres(mid+1,r,rt*2+1);
        res.sum = lres.sum + rres.sum;
        res.lsum = max(lres.lsum,lres.sum + rres.lsum);
        res.rsum = max(rres.rsum,rres.sum + lres.rsum);
        res.ans = max(lres.rsum + rres.lsum,max(lres.ans,rres.ans));
        return res;
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    build(1,n,1);
    int k;
    scanf("%d",&k);
    while(k--)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        if(l > r)
            swap(l,r);
        LNode res = getres(l,r,1);
        printf("%lld\n",res.ans);
    }
    return 0;
}