【LeetCode】最大子陣列 Maximum Subarray（貪婪&分治）

描述：

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

Follow up:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

思路一：動態規划

因為這是個優化問題。並且問題可以分解為一個個子問題，所以利用DP來解決此問題是一種很好的解決方案：

dp[i-1]到dp[i]的轉換分兩種情況：

　　　　　　　　1）dp[i-1] > 0： 當大於0時，dp[i] = dp[i-1] + num[i]

　　　　　　　　2) dp[i-1] < 0：當大於0時，dp[i] = 0  （因為此時將剔除dp[i-1]的影響）

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

 

思路二：貪婪

從左到右匯總數組時找到總和最優解，和dp類似，但是我們這里不保存dp的狀態，只記錄臨時sum和最大sum

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

 

思路三：分治法

 分治法的思路是將問題不斷二分，分到不能再分，然后再將計算完的數據整合歸一，最后得出最優解，這里，如圖所示，將數組不斷二分，然后取出每一段的最大sum，然后傳回總函數，然后輸出最優解

 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size()==0) return 0;
        return maxSubArray(nums, 0 , nums.size() - 1);
    }
    
    
    // l代表數組左端low，h代表數組右端high，返回最大sum
    int maxSubArray(vector<int>& arr, int l, int h)
    {
        // Base Case: Only one element
        if (l == h)
            return arr[l];

        // Find middle point
        int m = (l + h)/2;

        /* Return maximum of following three possible cases
           a) Maximum subarray sum in left half
           b) Maximum subarray sum in right half
           c) Maximum subarray sum such that the subarray crosses the midpoint */
        return max(max(maxSubArray(arr, l, m),  //最左側數組求最大sum
                       maxSubArray(arr, m+1, h)),  //對右側數組求最大sum ，之后求左右的最大值
                   maxCrossingSum(arr, l, m, h));  //對整個數組以mid為分界線求最大sum
    }
    
    
    int maxCrossingSum(vector<int>& arr, int l, int m, int h)
    {
        // Include elements on left of mid.
        int sum = 0;
        int left_sum = INT_MIN;
        for (int i = m; i >= l; i--)
        {
            sum = sum + arr[i];
            if (sum > left_sum)
                left_sum = sum;
        }

        // Include elements on right of mid
        sum = 0;
        int right_sum = INT_MIN;
        for (int i = m+1; i <= h; i++)
        {
            sum = sum + arr[i];
            if (sum > right_sum)
                right_sum = sum;
        }

        // Return sum of elements on left and right of mid
        return left_sum + right_sum;
    }
};