使用分治法求最大子序列之和

對於求最大子序列之和，對於我這樣的菜鳥，首先想到的應該是最暴力的方法，就是將所有的子序列的和進行比較，然后出現最大值並返回答案。不過這也沒啥意思，復雜度O(N2).

對這個問題，有一個相對復雜的O(NlogN)的解法，就是使用遞歸。其主要思想是：比較左、右、中間三部分的序列和的大小，因為中間部分是沒辦法分治的，只能在每一層遞歸函數空間里面進行,所以遞歸的部分為左、右，而且左右部分序列和有分別為次層遞歸的結果。遞歸的基本邊界：左右為相同位置元素，即只有一個元素.

 

private static int maxSumRec(int [] a , int left , int right){
　　if( left == right ){//邊界①
　　　　if( a[left] > 0 )
　　　　　　return a[left];
　　　　else
　　　　　　return 0;
　　}
　　//遞歸分治部分②
　　int center = (left + right) / 2;
　　int maxLeftSum = maxSumRec( a, left, center);
　　int maxRightSum = maxSumRec( a, center + 1, right);

　　//對改層的部分進行數據處理③
　　int maxLeftBorderSum = 0,　leftBorderSum = 0;
　　for( int i = center; i >= left; i--){
　　　　leftBorder += a[i];
　　　　if( maxLeftBorderSum < leftBorderSum)
　　　　　　maxLeftBorderSum = leftBorderSum;
　　}
　　
　　int maxRightBorderSum = 0, leftBorderSum = 0;
　　for( int i = center + 1; i <= right; i ++){
　　　　rightBorderSum += a[i];
　　　　if( maxRightBorderSum > rightBorderSum)
　　　　　　maxRightBorderSum = rightBorderSum;
　　}

　　//返回
　　return max3( maxRightBorderSum + maxLeftBorderSum , maxLeftSum , maxRightSum);
}

 

 

 

復雜度:

如果數據量為N,①與數據兩無關,時間為常數;③為數據處理部分,時間為O(N);②為遞歸部分,每一層的該處時間消耗總與上一層有關,並有T(N)=T(N/2)+O(N)的關系.

最后計算得T(N)=O(NlogN).

 

下面是一個時間復雜度更小(O(N))的算法:

該算法更為簡便之處是忽略了對子序列的尋找比較,而是根據規律直接找出最佳答案.

對於含有正數的序列而言,最大子序列肯定是正數,所以頭尾肯定都是正數.我們可以從第一個正數開始算起,每往后加一個數便更新一次和的最大值;當當前和成為負數時,則表明此前序列無法為后面提供最大子序列和,因此必須重新確定序列首項.

public class maxSubSumS {
    public static int maxSubSum(int [] a ){
        int maxSum = 0 , thisSum = 0;
        for( int i = 0; i < a.length ; i ++ ){
            thisSum += a[ i ];
            if(thisSum > maxSum)
                maxSum = thisSum;
            else if(thisSum < 0)
                thisSum = 0;
        }
        return maxSum;
    }
}