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