時間復雜度分析經典問題——最大子序列和

最大子序列和問題

　　最大子列和問題是非常經典的問題，基本上講算法的書都會將這個例子，用此例題來講解算法時間復雜度的重要性，對比不同算法的時間復雜度。最大子列和問題如下：給定整數序列A1,A2,A3,A4,...,An(可能存在負數)，求A(i)+A(i+1)+........+A(j)的最大值（無法輸入公式），請看下圖：

　　注：為了方便起見，如果所有的整數均為負數，則最大的子序列和為0

算法的運行時間

　　這個問題之所以有如此的吸引力，主要是因為存在求解它的很多算法，而且這些算法的性能又差異很大。我們將討論求解該問題的四種算法。這四種算法的運行時間如下表所示：（算法1是O(N^3)，圖中寫錯了）

• 表中的幾個重要的情況值得注意。對於小量的輸入，算法可以在眨眼之間的完成，因而如果只是小量輸入的情況下，那么花費大量的時間去設計優秀的算法恐怕是不值得的。另一方面，隨着業務，用戶的增加，小量輸入的情況可能會發生變化，哪些低效率的程序可能必須要進行重寫。
• 其次，表中所給的時間不包括讀入數據的所需要的時間，對於算法4，僅僅從磁盤讀入數據所用的時間很可能在數量級上比求解問題所需的時間還要大。數據的讀入一般是一個瓶頸，一旦數據讀入，問題就會迅速解決。但是對於低效的算法，它必然要耗費大量的計算資源。因此，只要可能，使得算法足夠有效而不至於成為問題的瓶頸是非常重要的。

　　我們還可以通過函數曲線來對這四種算法的時間復雜度函數進行分析，通過曲線我們清楚的可以看出O(nlgn)算法時間復雜度是介於O(n^2)的O(n)之間的，當然這也不難證明。在實際的情況中，當我們采用O(n^2)算法的時候，應該在仔細想想，能否將算法的時間復雜度優化成O(nlgn)，這對算法的性能提升也是非常巨大的，不妨要問，為什么不優化為O(n)呢？事實上，O(n)時間復雜度意味着只需要進行一次掃描，就能找到問題的解，在大部分的問題中，這是非常的困難的。

O(n^3)算法

#include<iostream>
#include<stdio.h>
using namespace std;

int MaxSubsequenceSum(int a[],int n);

int main(){
    //int a[6] = {-2, 11, -4, 13, -5, -2};
    int a[8] = {4, -3, 5, -2, -1, 2, 6, -2};
    printf("%d\n",MaxSubsequenceSum(a,8));
}

int MaxSubsequenceSum(int a[],int n){
    int ThisSum, MaxSum;
    MaxSum = 0;
    for(int i = 0; i < n; i++){
        for(int j = i; j < n; j++){
            ThisSum = 0;
            for(int k = i; k <= j; k++){
                ThisSum += a[k];
            }
            if(ThisSum > MaxSum){
                MaxSum = ThisSum;
            }
        }
    }
    return MaxSum;
}

　　這是一種O(n^3)的解法，說實話，我是寫不來這樣高時間復雜度的算法，這個算法重復做了很多的無用的計算，強行將算法復雜化，經過簡單的分析，直接可以求 ThisSum += a[k] 語句的次數，就能夠得出它的時間復雜度：

O(n^2)算法

　　對上述的算法直接優化，我們發現最里面的循環是完全多余的，很過分的消耗了大量的時間，很容易就能得到下面的算法

int MaxSubsequenceSum(int a[],int n){
    int ThisSum, MaxSum;
    MaxSum = 0;
    for(int i = 0; i < n; i++){
        ThisSum = 0;
        for(int j = i; j < n; j++){
            ThisSum += a[j];
            if(ThisSum > MaxSum){
                MaxSum = ThisSum;
            }
        }
    }
    return MaxSum;
}

　　相信大部分人首想想到的應該是這個算法把，這個算法性能只能說還行。但是，我們想到了O(n^2)的時候，應該多思考一下，能否將其轉化為O(nlogn)呢？如果能的話，這將會極大的提高算法的性能。

O(nlogn)算法

　　如果沒有O(n)算法的話，那么遞歸的威力就能體現出來了。這個算法采用的是分治策略，分治思想是把所求問題划分成兩個大致相等的問題，然后遞歸的對它進行求解，這是分的思想，治的階段是將兩個子問題的解合並到一起，最后得到整個問題的解。
　　在這個問題中，最大的子序列和可能出現在三處，要么是序列的左半部分，要么是序列的右半部分，要么是跨越輸入數據的中間左右部分都有，前面的兩種情況可以用遞歸進行求解，第三種情況的最大子序列和可以通過求出前半部分的最大和以及后半部分的最大和而得到，我們可以通過下面的例子進行分析：

• 前半部分最大子序列和為6，
• 后半部分的最大子序列和為8。
• 前半部分包含最后一個元素的最大和是4，而后半部分包含第一個元素的的最大和是7，因此跨越兩部分的最大和是11，這是最大的子列和。

　　這個算法的源碼有點復雜，仔細讀幾遍。

int MaxSubSum(int A[], int Left, int Right){
    int MaxLeftSum, MaxRightSum;
    int MaxLeftBorderSum, MaxRightBorderSum;
    int LeftBorderSum, RightBorderSum;
    int Center;
    if(Left == Right){
        if(A[Left] > 0){
            return A[Left];
        }else{
            return 0;
        }
    }
    
    Center = (Left + Right) / 2;
    MaxLeftSum = MaxSubSum(A, Left, Center);   //遞歸求解左半部分的最大和
    MaxRightSum = MaxSubSum(A, Center + 1, Right);  //遞歸求解右半部分的最大和
    
    MaxLeftBorderSum = 0;
    LeftBorderSum = 0;
    for(int i = Center; i >= Left; i--){
        LeftBorderSum += A[i];
        if(LeftBorderSum > MaxLeftBorderSum){
            MaxLeftBorderSum = LeftBorderSum;
        }
    }
    
    MaxRightBorderSum = 0;
    RightBorderSum = 0;
    for(int i = Center+1; i <= Right; i++){
        RightBorderSum += A[i];
        if(RightBorderSum > MaxRightBorderSum){
            MaxRightBorderSum = RightBorderSum;
        }
    }
    return Max3(MaxLeftBorderSum+MaxRightBorderSum,MaxLeftSum,MaxRightSum);
}

int Max3(int a, int b, int c){
    if(a>b){
        return a > c ? a : c;    
    }else{
        return b > c ? b : c;
    }
}

int MaxSubsequenceSum(int a[],int n){
    return MaxSubSum(a, 0, n-1);
}

時間復雜度分析 
　　有興趣的同學可以參考網易公開課：麻省理工學院公開課：算法導論，第三集分治法，講的非常詳細，還有推導過程。

　　O(n)算法

int MaxSubsequenceSum(int a[],int n){
    int ThisSum = 0, MaxSum = 0;    
    for(int j = 0; j < n; j++){
        ThisSum += a[j];
        if(ThisSum > MaxSum){
            MaxSum = ThisSum;
        }else if (ThisSum < 0){
            ThisSum = 0;        //ThisSum < 0，說明跨越a[j]不能使序列和變大
        }
    }
    return MaxSum;
}

　　這個算法的效率非常的高，又被稱為在線處理算法，算法只需要掃描一遍序列，就能找到最大的子序列和，它的技巧就是一旦A[i]被讀入並被處理，它就不再需要被記憶。不僅如此，在任意時刻，算法都能夠對它已經讀入的數據給出正確的答案。具有這種特性的算法叫做聯機算法。僅需要常量的空間並以線性時間運算的聯機算法集合是完美的算法。