cdoj844-程序设计竞赛 （线段树的区间最大连续和）【线段树】

http://acm.uestc.edu.cn/#/problem/show/844

程序设计竞赛

Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

Submit Status

“你动规无力，图论不稳，数据结构松散，贪心迟钝，没一样像样的，就你还想和我同台竞技，做你的美梦！今天这场比赛，就是要让你知道你是多么的无能！！”

不训练，无以为战。有n项能力是ACM竞赛要求的，训练则能提升，忽略则会荒废。

这m天，你能做到如何。

Input

第一行两个整数n，m,分别表示有n项能力要求，共有m天。

第二行n个整数，第i个整数ai表示第i项能力的数值。

接下来m行，每行开始先读入一个整数si，表明这是一次询问还是一次能力变化。

si=0，表明这是一次询问，然后读入两个整数li,ri，表示询问在[li，ri]区间中任选一段连续序列，这段序列中所有能力值之和最大能是多少。

si=1，表明这是一次能力变化，然后读入两个整数xi,wi，表示第xi项能力变为了wi。

1≤n,m≤100000,−10000≤ai≤10000,1≤li≤ri≤n,1≤xi≤n,−10000≤wi≤10000

Output

有多少询问就输出多少行，每行输出一个整数，作为对该询问的回答。

Sample input and output

Sample Input	Sample Output
4 4 1 2 3 4 0 1 3 1 3 -3 0 2 4 0 3 3	6 4 -3

思路：

每个节点维护4个值：
summ:此区间内的最大连续和
sum_:该节点以下的节点值得总和
suml:此区间的从左端开始的最大连续和
sumr:此区间的从右端开始的最大连续和
合并区间时，该区间的最大连续和为：max(左子节点的最大连续和，右子节点的最大连续和，左子节点的最大右连续和+右子节点的最大左连续和)

查询时返回一个整节点。因为每次要查询左子节点和右子节点，并且要比较它们的右连续最大和和左连续最大和，所以需要返回整个节点以便求值。

代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>

 using namespace std;

 #define INF 0x7fffffff
 const int N=;
 int n,m,a[N];
 struct node
 {
     int left,right;
     int sum_,summ,suml,sumr;
 }tree[*N];

 void build(int id,int l,int r);//建一棵线段树
 node query_sum(int id,int l,int r);//查询区间和
 void update(int id,int pos,int val);//更新位置pos的值

 int main()
 {
     //freopen("D:\\input.in","r",stdin);
     //freopen("D:\\output.out","w",stdout);
     int bo,t1,t2;
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++)
         scanf("%d",&a[i]);
     build(,,n);
     for(int i=;i<=m;i++)
     {
         scanf("%d%d%d",&bo,&t1,&t2);
         if(bo)
             update(,t1,t2);
         else{
             node tmp=query_sum(,t1,t2);
             printf("%d\n",tmp.summ);
         }
     }
     return ;
 }
 void build(int id,int l,int r)
 {
     tree[id].left=l;
     tree[id].right=r;
     if(l==r)
     {
         tree[id].sum_=a[l];
         tree[id].summ=a[l];
         tree[id].suml=a[l];
         tree[id].sumr=a[l];
     }
     else
     {
         int mid=(l+r)/;
         build(*id,l,mid);
         build(*id+,mid+,r);
         tree[id].sum_=tree[*id].sum_+tree[*id+].sum_;
         tree[id].summ=max(max(tree[*id].summ,tree[*id+].summ),(tree[*id].sumr+tree[*id+].suml));
         tree[id].suml=max(tree[*id].suml,tree[*id].sum_+tree[*id+].suml);
         tree[id].sumr=max(tree[*id+].sumr,tree[*id].sumr+tree[*id+].sum_);
     }
 }
 node query_sum(int id,int l,int r)
 {
     if(tree[id].left==l&&tree[id].right==r)
         return tree[id];
     else
     {
         node tmp,k1,k2;
         int flag1=,flag2=;
         int mid=(tree[id].left+tree[id].right)/;
         if(r<=mid)  return query_sum(*id,l,r);
         if(l>mid)   return query_sum(*id+,l,r);
         if(l<=mid){
             k1=query_sum(*id,l,mid);
             flag1=;
         }
         if(r>mid){
             k2=query_sum(*id+,mid+,r);
             flag2=;
         }
         if(flag1&flag2){
             tmp.sum_=k1.sum_+k2.sum_;
             tmp.suml=max(k1.suml,k1.sum_+k2.suml);
             tmp.sumr=max(k2.sumr,k1.sumr+k2.sum_);
             tmp.summ=max(max(k1.summ,k2.summ),k1.sumr+k2.suml);
         }else{
             if(flag1)   tmp=k1;
             else  tmp=k2;
         }
         return tmp;
     }
 }
 void update(int id,int pos,int val)
 {
     if(tree[id].left==tree[id].right)
     {
         tree[id].sum_=val;
         tree[id].summ=val;
         tree[id].suml=val;
         tree[id].sumr=val;
     }
     else
     {
         int mid=(tree[id].left+tree[id].right)/;
         if(pos<=mid)    update(*id,pos,val);
         else update(*id+,pos,val);
         tree[id].sum_=tree[*id].sum_+tree[*id+].sum_;
         tree[id].summ=max(max(tree[*id].summ,tree[*id+].summ),(tree[*id].sumr+tree[*id+].suml));
         tree[id].suml=max(tree[*id].suml,tree[*id].sum_+tree[*id+].suml);
         tree[id].sumr=max(tree[*id+].sumr,tree[*id].sumr+tree[*id+].sum_);
     }
 }