最大连续子段和

最近在学习动态规划，将自己的所思所想所得记录下来，检验自己是否真正懂了。

 

问题描述：

给定一个数组，记录一串数字，可正可负，现要求出其中最大的连续子段和。

 

用数组A[N]记录所要求的数组，用数组B[N]来记录连续子段和的状态

通过分析，可以知道：

当B[K]>0时，无论B[K]为何值，B[K]=B[K-1]+A[K]

当B[K]<0时，也就是B[K]记录到一个A[J]是负的，可以把B[K]变成负的，那么B[J]记录的这一段应该截掉，应为无论后面的A[K]多大，加上个负数总不可能是最大的子段和，因此将B[K]=A[K]，重新开始记录。

 

故动态转移方程便可得出

B[K] = MAX(B[K-1]+A[K] , A[K])

 

看个实例

k      1       2       3        4
a[k]  3     -4       2        10
b[k]  3     -1       2        12

 

必须记住B[K]是状态量，要获得最大连续子段和，只需在数组B中扫描一遍得到最大的数即可。

 一个有N个整数元素的一维数组{A[0],A[1],....,A[N-1],A[N]},这个数组有很多连续的子数组，那么连续子数组之和的最大的一个的值是什么？

   先给出一个时间复杂度为O(N^2)的求解程序实现，思想很简单，就是遍历数组中所有的子数组，代码如下：

[java] view plaincopy

1. /** 
2.  * 计算数组的最大子序列 
3.  * @author win7 
4.  * 
5.  */  
6. public class MaxSubArraySum {  
7.       
8.     public static int sumN2(int [] array){  
9.         int sum=0,maxSum=Integer.MIN_VALUE;  
10.         int n=array.length;  
11.         int count=0;  
12.         for(int i=0;i<n;i++){  
13.             sum=0;  
14.             for(int j=i;j<n;j++){  
15.                 sum+=array[j];  
16.                 if(sum>maxSum){  
17.                     maxSum=sum;  
18.                 }  
19.                 count++;  
20.             }  
21.         }  
22.         System.out.println("length="+n+"||count="+count);  
23.         return maxSum;  
24.     }  
25.     public static void main(String [] args){  
26. //      System.out.println("MIN_VALUE="+Integer.MIN_VALUE);  
27.         int [] array={-5,-2,-3,-5,-3,-2};  
28.         int sum=MaxSubArraySum.sumN2(array);  
29.         System.out.println("最大子序列和="+sum);  
30.     }  
31.   
32. }  

因为子数组求和满足动态规划的后无效特性，所以可以使用动态规划的思想，从分治的算法中得到提示：可以考虑数组的第一个元素A[0]，以及最大的一段数组(A[i],...A[j])跟A[0]之间的关系，有一下几种情况：

1.当0=i=j时，元素A[0]元素本身构成和最大的一段；

2.当0=i<j时，和最大的一段以A[0]开始；

3.当0<i时，元素A[0]跟和最大的一段没有关系。

从上面的三种情况可以将一个大问题(N个元素的数组)转化为一个较小的问题(n-1个元素的数组)。假设知道(A[1],...,A[N-1])中包含A[1]的和最大的一段的和为start[1]。那么，根据上面分析的三种情况，不难看出(A[0],...,A[N-1])中问题的解all[0]是三种情况的最大值max{A[0],A[0]+start[1],all[1]}。通过问题分析，可以看到问题满足无后效性，可以使用动态规划的方法来解决。

程序代码实现如下：

[java] view plaincopy

1. /** 
2.  * 在时间复杂度为O(N)内找出数组中最大的子序列的累加和 
3.  * @param array 
4.  * @return 
5.  */  
6. public static int sumN(int [] array){  
7.     int n=array.length;  
8.     int all=array[n-1],start=array[n-1];  
9.     int count=0;  
10.     for(int i=n-2;i>=0;i--){  
11.         if((start+array[i])>array[i]){  
12.             start=start+array[i];  
13.         }else{  
14.             start=array[i];  
15.         }  
16.         if(all<start){  
17.             all=start;  
18.         }  
19.         count++;  
20.     }  
21.     System.out.println("数组长度="+array.length+"||时间复杂度="+count);    
22.     return all;