求最大子数组和问题

一个有N个整数元素的一维数组（A[0],A[1],…A[N-1]），这个数组有很多子数组，求子数组和的最大值？注意：子数组必须是连续的、不需要返回子数组的具体位置、数组中包含：正、负、零整数、子数组不能空。
例如：
int A[5] = {-1,2,3,-4,2};
符合条件的子数组为2，3，即答案为5；
穷举法：

public static int MaxSubStringSum(int[] array,int n) {
        int sum,MaxSum =array[0];
        /*i是数组的最左端*/
        for(int i=0;i<n;i++) {
            /*j是数组的最右端*/
            for(int j =i;j<n;j++) {
                //sum是array[i]到array[j]的子数组的和
                sum = 0;
                for (int k = i; k <= j; k++)
                    sum += array[k];
                    if(sum > MaxSum)//如果刚得到的这个子数组和更大
                        MaxSum = sum;//则更新结果
                }
            }
        return MaxSum;
    }
    public static void main(String[] args) {
        int[] array= new int[] {-1,2,3,-4,2};
        int n = array.length;
        int result= MaxSubStringSum(array,n);
        System.out.println(result);
    }

算法的时间复杂度为O(n^3)

优化： k在[i,j]区间内其实可以根据第二个区间算出sum

public static int MaxSubStringSum(int[] array,int n) {
        int sum,MaxSum =array[0];
        /*i是数组的最左端*/
        for(int i=0;i<n;i++) {
            /*j是数组的最右端*/
            sum = 0;
            for(int j =i;j<n;j++) {
                sum += array[j];
               MaxSum = Math.max(MaxSum,sum);
            }
        return MaxSum;
    }

时间复杂度为O(n^2)

进一步分析：
我们利用穷举法虽然简单易懂，但是其时间复杂度很大，我们试着优化。现在考虑数组的第一个元素A[0]，与和最大的子数组(A[i],……A[j])之间的关系，有以下三种关系：
1) i = j = 0;A[0]本身构成和最大的子数组 max {A[0]}
2) j > i = 0;和最大的子数组以A[0]开头 max{A[0]+TempMaxSum[1]}
3) i > 0;A[0]与和最大子数组没有关系 max{MaxSum[1]}

从上面3中情况可以看出，可以将一个大问题（N个元素的数组）转化为一个较小的问题（N - 1个元素的数组）。假设已经知道(A[1],……A[N-1])中和最大的子数组和为MaxSum[1]，并且知道，(A[1],……A[N-1])中包含A[1]的和最大的子数组为TempMaxSum[1]。我们就可以把(A[0],……A[N-1])求和最大子数组问题转换为，MaxSum[0] = max{A[0],A[0]+TempMaxSum[1],MaxSum[1]}。

public static int MaxSubStringSum(int[] array,int n) {
            int MaxSum = array[0];    
            int sum = array[0];  
            /*i从1开始*/
            for(int i = 1;i < n;i++)  
            {  
                sum = Math.max(array[i],sum + array[i]);  
                MaxSum = Math.max(MaxSum,sum);  
            }  
            return MaxSum;  
        }  

上面一种算法的思想已经接近动态规划求子问题的思想，来看看动态规划是如何实现的：

动态规划：

    /*动态规划   核心思想：一旦发现子数组的和为负数，弃置，重新一个新数组。*/
    public static int MaxSubStringSum(int[] array,int n) {
            int MaxSum = 0;
            int sum = 0;   
            for(int i = 0;i < n;i++)  {
                sum +=array[i];
                MaxSum= Math.max(MaxSum, sum);
                if(sum < 0)
                    sum = 0;
            }  
            return MaxSum;  
        }  

分治法实现：分而治之 （未完待续）