最大子段和问题分析

---

问题：

  给定n个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值。当所给的整均为负数时定义子段和为0，依此定义，所求的最优值为：
 
    Max{0,a[i]+a[i+1]+…+a[j]},1<=i<=j<=n
    例如，当（a1,a2,a3,a4,a4,a6）=(-2,11,-4,13,-5,-2)时，最大子段和为20。

---

 

此问题最常见，也是最容易想到的办法：

 

long long sum(int s,int e) { long long cnt = 0; for(int i = s;i <= e;i++) cnt += a[i]; return cnt; } //算法1，效率为o(n^3) long long f1(int n) { long long max = a[0]; long long tmp; for(int i = 0;i < n;i++) for(int j = 0;j < n;j++) if(j < i) continue; else if((tmp = sum(i,j)) > max) max = tmp; return max; }

 

对这种三层循环的解法进行初步的优化，因为数列和具有如下性质：

 

S[i] = S[i-1]+a[i];

 

//算法2，效率为o(n^2) S[i] means sum of a[0...i] long long f2(int n) { long long max = 0; max = Sum[1]; long long tmp = 0; for(int i = 0;i <= n;i++) for(int j = i+1;j <= n;j++) if((tmp=(Sum[j]-Sum[i])) > max) max = tmp; return max; }

再对上面的算法进行如下优化：

 

1.空间优化，由于没有必要把所有的子段和保存下来，因为直接用一个变量sum保存最大子段和便可

2.时间优化，由于S[i] = S[i-1]+a[i]因此不需要把所有的S求出来

 

代码如下：

 

__int64 fun2(int &start,int &end) { __int64 sum = 0; __int64 max = a[0]; for(int i = 0; i < n;i++){ sum = 0; for(int j = i;j < n;j++){ sum += a[j]; if(sum > max){ max = sum; start = i; end = j; } } } return max; }

 

以上已经是属于o(n^2)中最优的算法了，但对于1W+级的数据，处理速度仍然太慢。

 

于是思考以分治法:

 

1.把整个段分成两部分,m = (left+right)/2

 

2.最大子段和要么属于左边部分，要么属于右边部分，要么属于包含a[m],a[m+1]的某个中间部分

 

3.对于属于左右两部分的，可以递归求出，重点是处理中间部分。

 

4.由于中间部分必然包含a[m],a[m+1]。因此把a[m]~a[0]倒过来求和，最大者即为左边必然包括a[m]的最大子段和lmax,同理可得右边rmax,所以lmax+rmax必然是包含a[m],a[m+1]的最大子段和。

 

5.以上三者，返回其较大值

 

代码如下：

 

 //o(nlogn),分治法 __int64 fun2(int left,int right) { if(left > right) return 0; if(left == right) return a[left]; int m = (left+right)/2; __int64 lmax = a[m]; __int64 rmax = a[m+1]; __int64 sum = 0; __int64 max = 0; for(int i = m;i >= left;i--){ sum += a[i]; if(sum > lmax) lmax = sum; } sum = 0; for(int j = m+1;j <= right;j++){ sum += a[j]; if(sum > rmax) rmax = sum; } max = lmax+rmax; __int64 ltmp = fun2(left,m); __int64 rtmp = fun2(m+1,right); if(max < ltmp) max = ltmp; if(max < rtmp) max = rtmp; return max; }

 

再思考这个问题，实际上是典型的子结构问题，可以使用动态规划来解。

定义b[i]为 子段结束位置为 i 时的最大子段和，那么当b[i-1]>0时，b[i] = b[i-1]+a[i]否则b[i] = a[i]

 

最后，数组b[i]中最大值必然为最大子段和 ：

 

//o(n),DP __int64 fun(int &start,int &end) { int bstart,bend; //用于记录当前临时的子向量的起始位置 __int64 b = 0; //记录当前子向量和 __int64 sum = a[0]; bstart = bend = 0; for(int i = 0;i < n;i++){ if(b>0){ //若之前的最大子向量和为正,可继续加 b += a[i]; bend = i; }else{ //若之前的最大子向量和已为负,则需要重新开始记录 b = a[i]; bstart = i; bend = i; } if(b > sum){ //找到更优的解 start = bstart; end = bend; sum = b; } } return sum; }