动态规划典型例题--连续子数组的最大和

题目描述：给定一个数组arr，数组中的元素有整数也有负数，数组中的一个或者连续多个数组成一个子数组。

求所有子数组里面的最大和。例如现在有数组 {1 ， -2 ， 3 ， 10 ， -4 ， 7 ， 2 ， -5 }。

思路：

1.用暴力的方法，找出所有可能的子数组，然后找和最大的那个。这是可行的，但是时间复杂度为 n*n，显然是不够理想的。

2.动态规划思想。状态方程 ： max( dp[ i ] )  = getMax(  max( dp[ i -1 ] ) + arr[ i ] ,arr[ i ] ) 。上面式子的意义是：我们从头开始遍历数组，遍历到数组元素 arr[ i ] 时，连续的最大的和 可能为 max( dp[ i -1 ] ) + arr[ i ] ，也可能为 arr[ i ] ，做比较即可得出哪个更大，取最大值。时间复杂度为 n

3.不需要动态规划，时间复杂度也为 n 。我们从头开始累加数组的元素，初始值 sum 为 0 。第一步 把 1 累加 则 sum = 1,接着 -2 累加 sum  = -1，再接着 3 累加 sum = 2，但是此时我们发现 sum < 3，也就是说从第一个元素开始累加到第三个元素的 和 sum  比 第三个元素还要小，那么我们舍去前面的累加值，从第三个元素开始累加 ，此时 sum = 3。

继续上述步骤，直至遍历到数组的最后一个元素。

具体代码：

import java.util.Scanner;

/**
 * 
 * 连续子数组的和
 * 
 * @author luzi
 *
 */
public class findMaxSum {
	
	public int FindGreatestSumOfSubArray(int[] array) {
        
		if(array == null || (array.length == 1 && array[0] <= 0))
        	return 0;
        
        int cur = array[0];
        int sum = array[0];
        for(int i = 1;i < array.length;i++){
        	if(cur < 0)
        		cur = 0;
        	cur = cur + array[i];
        	if(sum <= cur)
        		sum = cur;
        }		
		return sum;
    }
	
	//用动态规划
	public int FindGreatestSumOfSubArray2(int[] arr,int n){
		int sum = arr[0];
		int max = arr[0];
		for(int i = 1; i < n; i++){
			sum = getMax(sum+arr[i],arr[i]);
			if(sum >= max)
				max = sum;
		}
		
		return max;
	}
	
	public int getMax(int a,int b){
		return a > b ? a: b;
	}
	
	public static void main(String args[]){
		findMaxSum ts = new findMaxSum();
		Scanner scan = new Scanner(System.in);
		while(scan.hasNext()){
			int n = scan.nextInt();
			int[] a = new int[n];
			for(int i = 0; i < n; i++)
				a[i] = scan.nextInt();
			System.out.println(ts.FindGreatestSumOfSubArray(a));
			System.out.println(ts.FindGreatestSumOfSubArray2(a,a.length));
		}
	}
}