转载：最大子段和问题(Maximum Interval Sum)

一.问题描述

 

      给定长度为n的整数序列，a[1...n], 求[1,n]某个子区间[i , j]使得a[i]+…+a[j]和最大.或者求出最大的这个和.

      例如(-2,11,-4,13,-5,2)的最大子段和为20,所求子区间为[2,4].

      如果该序列的所有元素都是负整数时定义其最大子段和为0。

 

 二. 问题分析

      1、最大子段和问题的简单算法：

 

 

 

 

      2、最大子段和问题的分治法：

 

      求子区间及最大和，从结构上是非常适合分治法的，因为所有子区间[start, end]只可能有以下三种可能性:

      在[1, n/2]这个区域内

      在[n/2+1, n]这个区域内

      起点位于[1,n/2],终点位于[n/2+1,n]内

 int DAC(int * array, int left, int right)
 {
     if (left == right)
         return array[left]> ? array[left] : ;

     int center = ( left + right ) / ;
     int leftSum = DAC(array, left, center);
     int rightSum = DAC(array, center+, right);

     int temp = ;
     int leftHalfMaxSum = ;
     for (int i=center;i>=left;--i)
     {
         temp += array[i];
         if (leftHalfMaxSum < temp)
             leftHalfMaxSum = temp;
     }
     temp = ;
     int rightHalfMaxSum = ;
     for (int i=center+;i<=right;++i)
     {
         temp += array[i];
         if (rightHalfMaxSum  < temp)
             rightHalfMaxSum = temp;
     }

     int max = leftSum > rightSum ? leftSum : rightSum;
     return max > leftHalfMaxSum + rightHalfMaxSum ? max : leftHalfMaxSum + rightHalfMaxSum;
 }

分治法的难点在于第三种情形的理解，这里应该抓住第三种情形的特点，也就是中间有两个定点，然后分别往两个方向扩张，以遍历所有属于第三种情形的子区间，求的最大的      一个，如果要求得具体的区间，稍微对上述代码做点修改即可. 分治法的计算时间复杂度为O(nlogn).

    3、最大子段和问题的动态规划算法：

      令b[j]表示以位置 j 为终点的所有子区间中和最大的一个

      子问题:如j为终点的最大子区间包含了位置j-1,则以j-1为终点的最大子区间必然包括在其中

      如果b[j-1] >0, 那么显然b[j] = b[j-1] + a[j]，用之前最大的一个加上a[j]即可，因为a[j]必须包含

      如果b[j-1]<=0,那么b[j] = a[j]。

 

      对于这种子问题结构和最优化问题的证明，可以参考算法导论上的“剪切法”，即如果不包括子问题的最优解，把你假设的解粘帖上去，会得出子问题的最优化矛盾.证明如下：

      令a[x,y]表示a[x]+…+a[y] , y>=x

      假设以j为终点的最大子区间 [s, j] 包含了j-1这个位置，以j-1为终点的最大子区间[ r, j-1]并不包含其中

      即假设[r,j-1]不是[s,j]的子区间

      存在s使得a[s, j-1]+a[j]为以j为终点的最大子段和,这里的 r != s 

      由于[r, j -1]是最优解, 所以a[s,j-1]<a[r, j-1],所以a[s,j-1]+a[j]<a[r, j-1]+a[j]

      与[s,j]为最优解矛盾.

 int DP(int *a, int size)
 {
     int *b = new int[size];
     b[] = a[];
     int max = b[];
     for (int i=;i<size;++i)
     {
         if (b[i-] > )
             b[i] = b[i-] + a[i];
         else
             b[i] = a[i];

         if(b[i]>max)
             max = b[i];
     }
     return max;
 }

测试代码：

 #include "stdafx.h"
 #include <stdlib.h>
 #include "DivideAndConquer.h"
 #include "DynamicProgramming.h"

 int _tmain(int argc, _TCHAR* argv[])
 {
     int array[] = {-, , -, , -, -};
     //int result = DAC(array, 0, 5);
     int result = DP(array, );
     printf("%d", result);
     system("pause");
     return ;
 }

转自：http://blog.csdn.net/jiyanfeng1/article/details/8058604