題目

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
the contiguous subarray [4,-1,2,1] has the largest sum = 6.

解題思路

題目大意是給定一個數(shù)組，讓我們找出連續(xù)總和最大的子序列。有兩種解決策略，第一個是利用動態(tài)規(guī)劃，第二個是使用分治算法。（brute-force 就不提了）

1. Dynamic programming
一般來說，最優(yōu)問題都可以利用動態(tài)規(guī)劃的方法求解。而對于DP算法，最重要的事情是要找出子問題的遞歸形式。這題中，我們可以定義問題的形式為
maxSubArray(int A[], int i)，則假設已經求得子問題的解 maxSubArray(A, i-1)，在這基礎上，我們要求原問題 maxSubArray(A, i)。這樣一來，它們之間的關系就很容易弄清楚了：

maxSubArray(A, i) = maxSubArray(A, i - 1) > 0 ? maxSubArray(A, i - 1) : 0 + A[i];

時間復雜度為 O(n), 參考代碼如下。

2. Divide and conquer
第二個方法是分治算法，我們先來考慮下面這個問題，在數(shù)組 A[low..high] 中，最大子序列 A[i..j] 可能存在的位置（假設 mid = int((low+high)/2) ):

A. 完全在 A[low..mid] 里；（low≤i≤j≤mid)
B. 完全在 A[mid+1..high] 里；（mid＜i≤j≤high)
C. 跨過了數(shù)組的中點（low≤i≤mid＜j≤high)

如下圖所示：

Three kinds of situations.png

則我們只需要求得上述三種情況的最大子序列，然后進行比較得出最大的那個即可滿足題意。其中情況 A 和 B 可以用遞歸的方法求得。我們考慮下情況 C，如下圖：

Crossing the midpoint.png

顯然要使 A[i,j] 最大，則需要使 A[i..mid] 和 A[mid+1..j] 最大，所以只需分別遍歷所有可能的 A[i..mid] 和 A[mid+1..j] 值（low≤i≤mid＜j≤high），并分別記錄下最大值即可。
時間復雜度：

time complexity.png

參考代碼

Dynamic programming：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        int dp[n]={0};
        dp[0]=nums[0];
        int ans=dp[0];
        for(int i=1;i<n;i++){
            if(dp[i-1]>0)
                dp[i]=dp[i-1]+nums[i];
            else
                dp[i]=nums[i];
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};

Divide and conquer：

class Solution {
public:
    int find_max_crossing_subarray(vector<int>& A,int low,int mid, int high){
        
        // Find a maximum subarray of the form A[i..mid]
        int left_sum=INT_MIN, max_left;  
        int sum=0;
        for(int i=mid;i>=low;i--){
            sum+=A[i];
            if(sum>left_sum){
                left_sum = sum;
                max_left = i;
            }
        }
        
        // Find a maximum subarray of the form A[mid + 1 .. j ]
        int right_sum=INT_MIN, max_right;  
        sum=0;
        for(int i=mid+1;i<=high;i++){
            sum+=A[i];
            if(sum>right_sum){
                right_sum = sum;
                max_right = i;
            }
        }
        
        // Return the indices and the sum of the two subarrays
        return left_sum+right_sum;
    }
    
    int find_maximum_subarray(vector<int>& A,int low,int high){
        
        //base case: only one element
        if(high==low)        
            return A[low];
        else{
            int mid = (low+high)/2;
            int left_sum=find_maximum_subarray(A,low,mid);
            int right_sum=find_maximum_subarray(A,mid+1,high);
            int cross_sum=find_max_crossing_subarray(A,low,mid,high);
            if((left_sum>=right_sum)&&(left_sum>=cross_sum))
                return left_sum;
            else if((right_sum>=left_sum)&&(right_sum>=cross_sum))
                return right_sum;
            else
                return cross_sum;
        }
    }
    int maxSubArray(vector<int>& nums) {
        return find_maximum_subarray(nums,0,nums.size()-1);
    }
};

反思與總結

兩種方法相比較，分治算法的思想簡單直接，易編程，但時間復雜度較高。而 DP 算法更加高效，但是需要正確得出子問題的形式，較有技巧性。分治算法的最典型的代表就是歸并排序了，所以比較熟悉，而在實際問題中，我往往會看不出其實可以利用 DP 算法來解決。但其實 DP 問題也有一定規(guī)律性，現(xiàn)總結如下：

DP.png