UVa 1400（LA 3938）动态最大连续和

【题目链接】
http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=36216

【解题报告】
刘汝佳的《训练指南》里，我觉得这道题目讲的不够详细（并且书上貌似有一点印刷错误？）。

在网上找了很多题解，不过觉得代码写的很丑。直到我看到了这篇题解，觉得代码写的非常漂亮，就虚心学习了。
http://blog.csdn.net/u012997373/article/details/39609271
《UVA - 1400”Ray, Pass me the dishes!”(线段树) 》 –miss_minor

这道题目的算法本身并没有太多困难的令人感到棘手的地方，虽然是普通的线段树单点更新，区间查询，但实现起来，对我来说却非常有困难。原因在于数据的组织能力实在太弱。而这道题又恰恰由繁复的数据及其相应操作组织而成。
对于线段树的每个节点（这本身是一个类）要保存三个线段信息（注意这里又抽象出了一个类：线段），最大前缀，最大后缀，最大子序列。同时还要保存节点相对应的序列左端点和右端点。
对于每条线段，同样要保存左右节点，并且题目中有合并两条线段的操作，还有需要进行线段“优先级”的比较。
因此，如何在有限时间内写出结构清晰，层次完整，便于调试和扩展的代码，是十分考验编码能力的。

【参考代码】

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;

const int maxn=500000+10;
typedef  long  long LL;

int A[maxn];
long long S[maxn];
int n,m;


struct Segment
{
      LL v;
      int l,r;

      Segment (  int l=0, int r=0, LL v=0 )
      {
            this ->l=l;
            this ->r=r;
            this ->v=v;
      }

      Segment operator + (   const Segment& a  )const
      {
            Segment ans;
            ans.l=min(  l,a.l );
            ans.r=max( r,a.r );
            ans.v=v+a.v;
            return ans;
      }

      bool operator < ( const Segment& a )const
      {
            if(    v==a.v  )
            {
                  if(  l==a.l  )
                  {
                        return r>a.r;
                  }
                  return l>a.l;
            }
            return v<a.v;
      }
};


struct node
{
      int l,r;
      Segment max_sub,max_pre,max_suf;
      void set(   int l, int r, Segment max_sub, Segment max_pre, Segment max_suf )
      {
            this->l=l;
            this->r=r;
            this->max_sub=max_sub;
            this->max_pre=max_pre;
            this->max_suf=max_suf;
      }
};

node tree[maxn*4];

void build(    int O, int L, int R )
{
      if(  L>R )return;
      if(  L==R )
      {
            Segment temp(  L,L,A[L]  );
            tree[O].set(    L,R,temp,temp,temp );
            return ;
      }
      int mid=L+(R-L)/2;
      build(  O*2,   L, mid );
      build( O*2+1, mid+1,R );

      Segment now_left(   L,mid,S[mid]-S[L-1]  );
      Segment now_right(  mid+1, R, S[R]-S[mid] );

      tree[O].max_sub=max(       tree[O*2].max_suf+tree[O*2+1].max_pre    ,   max(tree[O*2].max_sub , tree[O*2+1].max_sub)          );
      tree[O].max_pre=max(    tree[O*2].max_pre ,    now_left+tree[O*2+1].max_pre  );
      tree[O].max_suf=max(   tree[O*2+1].max_suf,  now_right+tree[O*2].max_suf );
      tree[O].l=tree[O*2].l;
      tree[O].r=tree[O*2+1].r;
}


node query(   int O, int qL, int qR  )
{
      int L=tree[O].l,R=tree[O].r;
      int mid=(L+R)/2;

   //   cout<<L<<"  "<<R<<endl;

      if(     qL<=L && R<=qR  ) return tree[O];
      if(  qR<=mid  )return query(   O*2, qL, qR   );
            else if(     qL>mid  ) return query(  O*2+1,  qL, qR    );
                  else  //if(   qR>=L &&  qL<=R  )
                  {
                        node nL=query(  O*2, qL,qR );
                        node nR=query(  O*2+1,  qL, qR );
                        node ret;
                        LL S_L=S[nL.r] - S[nL.l-1],   S_R=S[nR.r]-S[nR.l-1];
                        Segment L_seg(   L,mid,S_L  );
                        Segment R_seg(  mid+1, R, S_R );
                        ret.max_pre=max(       nL.max_pre,   L_seg+nR.max_pre    );
                        ret.max_sub=max(      max(  nL.max_sub,nR.max_sub ),  nL.max_suf+nR.max_pre    );
                        ret.max_suf=max(    nR.max_suf, R_seg+nL.max_suf  );
                        ret.l=nL.l; ret.r=nR.r;
                        return ret;
                  }
}


int main(   )
{
      int kase=0;
      while(~scanf(   "%d%d", &n, &m ))
      {
            printf(  "Case %d:\n",++kase );
            for(  int i=1; i<=n; i++ )
            {
                  scanf(  "%d",&A[i] );
                  S[i]=S[i-1]+A[i];
            }
            build(  1, 1, n );
            for(   int i=1; i<=m; i++ )
            {
                  int  qL, qR;
                  scanf("%d%d",&qL,&qR);
                  node ans=query(   1, qL, qR );
                  printf(  "%d %d\n", ans.max_sub.l, ans.max_sub.r );
               //   cout<<tree[1].max_sub.l<<"  "<<tree[4].max_sub.r<<endl;

            }

      }



      return 0 ;
}