【LeetCode】 53. Maximum Subarray 最大子序列和

原題

 

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.

 

思路

 

1. 最笨的辦法

 

用2個for循環，遍歷所有的子序列和，最後得到其中最大的一個

 

public class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int len = nums.length;
        int tempSum = 0;
        for(int i = 0 ; i< len ;i ++){
            tempSum = nums[i];
            if(tempSum >max){
                max = tempSum;
            }
            for(int j = i+1; j< len; j++){
                tempSum += nums[j];
                if(tempSum >max){
                    max = tempSum;
                }
            }
        }
        return max;
    }
}

時間複雜度O(n^2) 

 

2. 經典的DP


對一個序列[a1, a2, a3, ..., an]，要求最大子序列和，可以等價於求max(以a1爲起點的序列的最大序列和，以a2爲起點的序列的最大和，...，以an爲起點的序列的最大和)。而對於第i項ai，不難推出，以ai爲起點的序列最大和爲：
max_sum(i) = max(ai, max_sum(i+1) + ai)
然後遞推出max_sum(1)，也就是最後的結果了。


依此，我們可以寫一個for循環，從數組的最後往前，依次遞推，並保存最大值：
 

        public int maxSubArray(int[] nums) {
            int max = nums[nums.length - 1];
            int lastMaxSum = nums[nums.length - 1];


            for (int i = nums.length - 2; i >= 0; i--) {
                int ai = nums[i];
                lastMaxSum = lastMaxSum > 0 ? ai + lastMaxSum : ai;
                max = Math.max(max, lastMaxSum);
            }
            return max;
        }

 

時間複雜度O(n) 

 

更新：

某日夜，突然想到這道題，靈光一現，特此記錄。

 

1. 記數列{a[0], a[1] ... a[n]} = S[n]，那麼：

對於數列S[n]，若其最大子序列和爲S，有：

S = S[q] - S[p-1]

則原問題化爲{S[0], S[1] .. S[n]}找最大差值（後-前）的問題。

即原問題等價於對於任意0≤p≤q≤n，求S[q] - S[p]的最大值。

 

2. 易證：

S[p-1] = min{S[0] .. S[q]}

S[q] = max{S[p] .. S[q]}

則原問題化爲求階段性最小值、最大值的問題。

 

3. 經過1和2的轉化，問題已經很簡單了。

對於正整數 i ∈[0, n]，最大子序列和 maxSubarr[i] = Sum2 - Sum1。其中：

Sum1 爲 S[0] ~ S[i] 的最小值，Sum2 爲 S[x] ~ S[i] 的最大值。

 

 

代碼：

        public int maxSubArray(int[] nums) {
            int sumTmp; // = S[0, i]
            int minTmp; //記錄階段性的最小值
            int maxTmp; //記錄階段性的最大值
            int max; // 最大序列和
            boolean allNeg = true; // 特殊情況，如果所有都是負數
            minTmp = maxTmp = sumTmp = max = nums[0];

            for (int ai : nums) {
                sumTmp += ai; // = S[0, i]
                if (allNeg) {
                    if (max < ai) max = ai;
                    if (ai >= 0) allNeg = false;
                }
                if (sumTmp < minTmp) {
                    minTmp = maxTmp = sumTmp; // 新的階段最小值
                } else if (sumTmp > maxTmp) {
                    maxTmp = sumTmp; // 新的階段最大值
                    int diff = sumTmp - minTmp;
                    if (diff > max) {
                        max = diff; // 判斷是否是最大差值
                    }
                }
            }
            return max;
        }

 

 

這個方法的思路，是把一個複雜的問題等價轉化爲另一個簡單的問題。雖然代碼反而變多了，但是思考層級變低了，就好似把一道高等數學的題目用初等數學的方法解決（小學教材求圓的面積）。我覺得還是有一定的記錄價值的。