Can you answer these queries V(线段树区间和问题)

You are given a sequence A[1], A[2], ..., A[N] . ( |A[i]| <= 10000 , 1 <= N <= 10000 ). A query is defined as follows: Query(x1,y1,x2,y2) = Max { A[i]+A[i+1]+...+A[j] ; x1 <= i <= y1 , x2 <= j <= y2 and x1 <= x2 , y1 <= y2 }. Given M queries (1 <= M <= 10000), your program must output the results of these queries.
Input

The first line of the input consist of the number of tests cases <= 5. Each case consist of the integer N and the sequence A. Then the integer M. M lines follow, contains 4 numbers x1, y1, x2 y2.
Output

Your program should output the results of the M queries for each test case, one query per line.
Example

Input:
2
6 3 -2 1 -4 5 2
2
1 1 2 3
1 3 2 5
1 1
1
1 1 1 1

Output:
2
3
1

//看代码注释都写在代码里面了

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#define MAXN 10007 *4

using namespace std;

struct Node
{
    int left,right;
    long long lsum,rsum,ans,sum;//lsum 就是以这个节点为起点的最大连续只 ans是这个区间内最大连续区间的值
}node[MAXN];
int n,num[MAXN];
void build(int l,int r,int rt)
{
    node[rt].left = l;
    node[rt].right = r;
    if(l==r)//达到叶子节点
    {
        scanf("%lld",&node[rt].ans);
        node[rt].sum = node[rt].lsum = node[rt].rsum = node[rt].ans;
        num[l] = node[rt].ans;
        return;
    }
    int mid = (l+r)/2;
    build(l,mid,rt*2);
    build(mid+1,r,rt*2+1);
    //从下往上更新
    node[rt].sum = node[rt*2].sum + node[rt*2+1].sum;
    //lsum 有两种情况就是从左子树的lsum里面取 或者就是左子树所在区间全部都取 此时需要考虑右子树的lsum
    node[rt].lsum = max(node[rt*2].lsum,node[rt*2].sum + node[rt*2+1].lsum);
    node[rt].rsum = max(node[rt*2+1].rsum,node[rt*2+1].sum + node[rt*2].rsum);
    //最大的连续区间和有三种情况 第一种就是取左子树的最大连续区间和 第二种就是取右子树的最大连续区间和
    //第三种就是最大连续区间在这两个都有 呢么就是左子树的rsum + 右子树的lsum
    node[rt].ans = max(node[rt*2].ans,node[rt*2+1].ans);
    node[rt].ans = max(node[rt].ans,node[rt*2].rsum + node[rt*2+1].lsum);
}
Node query(int l,int r,int rt)
{
    if(r<l)
    {
        return node[0];
    }
    if( node[rt].left == l && node[rt].right == r )//找到完全重叠的区间
    {
        return node[rt];
    }
    int mid = (node[rt].left + node[rt].right)/2;
    if(r<= mid)//在左子树 不一定是其子区间
        return query(l,r,rt*2);
    else if(l > mid )
        return query(l,r,rt*2+1);
    else
    {
        //在l，r 是node[rt].left ,node[rt].right 的子集
        Node res,lans,rans;
        lans = query(l,mid,rt*2);
        rans = query(mid + 1,r,rt*2+1);
        res.sum = lans.sum + rans.sum;
        res.lsum = max(lans.lsum,lans.sum + rans.lsum);
        res.rsum = max(rans.rsum,rans.sum + lans.rsum);
        res.ans = max(lans.rsum + rans.lsum ,max(lans.ans,rans.ans));
        return res;
    }
}
int main()
{
    int ncase,m;
    int x1,y1,x2,y2;
    scanf("%d",&ncase);
    while(ncase--)
    {
        memset(node,0,sizeof(node));
        memset(num,0,sizeof(num));
        scanf("%d",&n);
        build(1,n,1);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            if(y1<x2)
            {
                long long ans = query(x1,y1,1).rsum + query(x2,y2,1).lsum + query(y1+1,x2-1,1).sum;
                printf("%lld\n",ans);
            }
            else
            {
                long long ans = query(x2,y1,1).ans;
                ans = max(ans,max(query(x2,y1,1).rsum + query(y1,y2,1).lsum - num[y1],query(x1,x2,1).rsum + query(x2,y2,1).lsum - num[x2]));
                printf("%lld\n",ans);
            }
        }
    }
    return 0;
}