SPOJ - GSS1 —— 线段树 （结点信息合并）

题目链接：https://vjudge.net/problem/SPOJ-GSS1

GSS1 - Can you answer these queries I

#tree

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

题意：

给出一个序列。有m个询问：区间[L,R]里的最大连续和是多少？

题解：

1.线段树的结点信息合并。将这n个数按线段树的形式分割下去，然后再从最底层的小区间，往上合并得到大区间：两个对应的小区间有四种合并结果（得到一段连续的区间）：1.左连续、右连续、左右不连续、全连续。记录每种合并结果的最大值。

2.对于询问区间，依旧如普通的查询操作一样，拿到线段树里与对应区间，但是需要注意的是：当询问区间被mid分成两段时，需要单独单出来，然后再尝试将两段进行信息合并。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const double EPS = 1e-;
 const int INF = 2e9;
 const LL LNF = 2e18;
 const int MAXN = 5e4+;

 struct node
 {
     int a[];
 };
 node sum[MAXN<<];

 /*
     0：两边不连续
     1：左连续
     2：右连续
     3：全连续
 */
 void push_up(int fa[], int s1[], int s2[])
 {
     fa[] = max(max(s1[], s2[]),max(max(s1[],s2[]), s1[]+s2[]));
     fa[] = max(max(s1[],s1[]), s1[]+s2[]);
     fa[] = max(max(s2[],s2[]), s1[]+s2[]);
     fa[] = s1[] + s2[];
 }

 void build(int u, int l, int r)
 {
     if(l==r)
     {
         scanf("%d", &sum[u].a[]);  //只有一个点，当然是全连续
         sum[u].a[] = sum[u].a[] = sum[u].a[] = -;   //其他情况设为不可能
         return;
     }

     int mid = (l+r)>>;
     build(u*, l, mid);
     build(u*+, mid+, r);
     push_up(sum[u].a, sum[u*].a, sum[u*+].a);
 }

 node query(int u, int l, int r, int x, int y)
 {
     if(x<=l && r<=y)
         return sum[u];

     int mid = (l+r)>>;
     node ret;
     if(y<=mid)  //询问区间在左边
         ret = query(u*, l, mid, x, y);
     else if(x>=mid+)   //询问区间在右边
         ret = query(u*+, mid+, r, x, y);
     else    //询问区间被分割成两段，因而还要调用push_up尝试将两子区间合并
     {
         node t1 = query(u*, l, mid, x, mid);
         node t2 = query(u*+, mid+, r, mid+, y);
         push_up(ret.a, t1.a, t2.a);
     }
     return ret;
 }

 int main()
 {
     int n, m;
     scanf("%d", &n);
     build(,,n);
     scanf("%d", &m);
     while(m--)
     {
         int l, r;
         scanf("%d%d", &l,&r);
         node ret = query(,,n,l,r);
         int t1 = max(ret.a[], ret.a[]);   //取四种连续情况的最大值
         int t2 = max(ret.a[], ret.a[]);
         printf("%d\n", max(t1,t2));
     }
 }