最大子列和問題描述：

給定一串整數列中，求滿足子列和最大，並返回最大值。例如（2, -1, 6, 8, -5, 7, -11），其中的滿足和最大的子列為（2, -1, 6, 8, -5, 7），最大值為17。

演算法一

最蠢的方法是列舉法，把所有的子列都跑一遍。

int max_len(int a[], int N){
    int i, j, k, thisSum, maxSum = 0;
    for(i=0; i<N; i++){
        for(j=i; j<N; j++){
            thisSum = 0;
            for(k=i; k<=j; k++)
                thisSum += a[k];
            if
 
(thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    return maxSum;
}

複雜度為O（n^3），效率很低。

演算法二

演算法一中對j的迴圈是每次自加1，此時i是不變的，而k迴圈的作用是累加從i到j的子列長度，可見雖然每次只需要再計算一個int值，但是k迴圈依然從最開始累加，沒有必要，所以k迴圈這裡可以優化。

int max_len(int a[], int N){
    int i, j, k, thisSum, maxSum = 0;
    for(i=0; i<N; i++){
        thisSum = 0
 
;
        for(j=i; j<N; j++){
            thisSum += a[j]; //優化
            if(thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    return maxSum;
}

也就是每次j移動的時候就判斷大小，複雜度為O（n^2）。

演算法三

當演算法複雜度為O（n^2）時，我們總想通過分治法等方法將複雜度降為O（nlogn），但是這裡分治法需要注意的是，並不是所有子問題的解合併就是最後的解了，由於子列可能存在從左邊的子問題跨到右邊子問題的情況，如下圖：

這時候在遞迴的同時還要加上一層從中間開始向兩邊延伸的判斷並賦值語句。

int max_len(int a[], int left, int right){
    int center, i, j, sum, left_sum, right_sum, s1, s2, lefts, rights;
    if(left == right){
        if(a[left] > 0)
            return a[left];
        else
            return 0;
    } else {
        center = (left + right) / 2;
        left_sum = max_len(a, left, center);
        right_sum = max_len(a, center + 1, right);
        s1 = 0;
        lefts = 0;
        for(i=center; i>=left; i--){
            lefts += a[i];
            if(lefts > s1) s1 = lefts;
        }
        s2 = 0;
        rights = 0;
        for(j=center+1; j<=right; j++){
            rights += a[j];
            if(rights > s2) s2 = rights;
        }
        if(s1+s2 < left_sum && right_sum<left_sum) return left_sum;
        if(s1+s2 < right_sum && left_sum < right_sum) return right_sum;
        return s1+s2;
    }
}

else中的兩個for迴圈是從中間開始，找出兩邊各自的最大值，然後相加，得出橫跨的最大值， 並與左右兩邊子問題的最大值進行比較。注意一定是從中間開始。

該演算法的複雜度為O（nlogn）。

演算法四

線上處理演算法：

int max_len(int a[], int N){
    int i, thisSum = 0, maxSum = 0;
    for(i=0; i<N; i++){
        thisSum += a[i];
        if(thisSum > maxSum)
            maxSum = thisSum;
        else if(thisSum < 0) //當前的子列和為負數，無論後面是什麼，負數與其相加肯定不能使子列和增大
            thisSum = 0;     //所以拋棄它，重新計算下一個子列和
    }
    return maxSum;
}

該演算法不容易理解，但是確是效率最高的，複雜度為O（n），因為至少要遍歷所有的元素，所以這已經是效率最高的演算法了。