一文看懂《最大子序列和問題》

引言

在作KB的基礎DP練習題的時候遇到了最大子序列和的變種問題，忽然發現本身之前沒作過解題筆記（現補上）

最大子序列和是一道經典的算法題， leetcode 也有原題《53.maximum-sum-subarray》，今天咱們就來完全攻克它。

題目描述

求取數組中最大連續子序列和，例如給定數組爲 A = [1， 3， -2， 4， -5]， 則最大連續子序列和爲 6，即 1 + 3 +（-2）+ 4 = 6。
去

首先咱們來明確一下題意。

• 題目說的子數組是連續的
• 題目只須要求和，不須要返回子數組的具體位置。
• 數組中的元素是整數，可是多是正數，負數和 0。
• 子序列的最小長度爲 1。

好比：

• 對於數組 [1, -2, 3, 5, -3, 2], 應該返回 3 + 5 = 8
• 對於數組 [0, -2, 3, 5, -1, 2], 應該返回 3 + 5 + -1 + 2 = 9
• 對於數組 [-9, -2, -3, -5, -3], 應該返回 -2

解法一 - 暴力法（超時法）

通常狀況下，先從暴力解分析，而後再進行一步步的優化。

思路

咱們來試下最直接的方法，就是計算全部的子序列的和，而後取出最大值。
記 Sum[i,….,j]爲數組 A 中第 i 個元素到第 j 個元素的和，其中 0 <= i <= j < n，
遍歷全部可能的 Sum[i,….,j] 便可。

咱們去枚舉以 0,1,2…n-1 開頭的全部子序列便可，
對於每個開頭的子序列，咱們都去枚舉從當前開始到 n-1 的全部狀況。

這種作法的時間複雜度爲 O(N^2), 空間複雜度爲 O(1)。

代碼

Java：

class MaximumSubarrayPrefixSum {
  public int maxSubArray(int[] nums) {
      int len = nums.length;
      int maxSum = Integer.MIN_VALUE;
      int sum = 0;
      for (int i = 0; i < len; i++) {
        sum = 0;
        for (int j = i; j < len; j++) {
          sum += nums[j];
          maxSum = Math.max(maxSum, sum);
        }
      }
      return maxSum;
  }
}

Python 3:

import sys
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        maxSum = -sys.maxsize
        sum = 0
        for i in range(n):
            sum = 0
            for j in range(i, n):
                sum += nums[j]
                maxSum = max(maxSum, sum)

        return maxSum

空間複雜度很是理想，可是時間複雜度有點高。怎麼優化呢？咱們來看下下一個解法。

解法二 - 分治法

思路

咱們來分析一下這個問題， 咱們先把數組平均分紅左右兩部分。

此時有三種狀況：

• 最大子序列所有在數組左部分
• 最大子序列所有在數組右部分
• 最大子序列橫跨左右數組

對於前兩種狀況，咱們至關於將原問題轉化爲了規模更小的一樣問題。

對於第三種狀況，因爲已知循環的起點（即中點），咱們只須要進行一次循環，分別找出
左邊和右邊的最大子序列便可。

因此一個思路就是咱們每次都對數組分紅左右兩部分，而後分別計算上面三種狀況的最大子序列和，
取出最大的便可。

舉例說明，以下圖：

這種作法的時間複雜度爲 O(N*logN), 空間複雜度爲 O(1)。

代碼

Java:

class MaximumSubarrayDivideConquer {
  public int maxSubArrayDividConquer(int[] nums) {
      if (nums == null || nums.length == 0) return 0;
      return helper(nums, 0, nums.length - 1);
    }
    private int helper(int[] nums, int l, int r) {
      if (l > r) return Integer.MIN_VALUE;
      int mid = (l + r) >>> 1;
      int left = helper(nums, l, mid - 1);
      int right = helper(nums, mid + 1, r);
      int leftMaxSum = 0;
      int sum = 0;
      // left surfix maxSum start from index mid - 1 to l
      for (int i = mid - 1; i >= l; i--) {
        sum += nums[i];
        leftMaxSum = Math.max(leftMaxSum, sum);
      }
      int rightMaxSum = 0;
      sum = 0;
      // right prefix maxSum start from index mid + 1 to r
      for (int i = mid + 1; i <= r; i++) {
        sum += nums[i];
        rightMaxSum = Math.max(sum, rightMaxSum);
      }
      // max(left, right, crossSum)
      return Math.max(leftMaxSum + rightMaxSum + nums[mid], Math.max(left, right));
    }
}

Python 3 :

import sys
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        return self.helper(nums, 0, len(nums) - 1)
    def helper(self, nums, l, r):
        if l > r:
            return -sys.maxsize
        mid = (l + r) // 2
        left = self.helper(nums, l, mid - 1)
        right = self.helper(nums, mid + 1, r)
        left_suffix_max_sum = right_prefix_max_sum = 0
        sum = 0
        for i in reversed(range(l, mid)):
            sum += nums[i]
            left_suffix_max_sum = max(left_suffix_max_sum, sum)
        sum = 0
        for i in range(mid + 1, r + 1):
            sum += nums[i]
            right_prefix_max_sum = max(right_prefix_max_sum, sum)
        cross_max_sum = left_suffix_max_sum + right_prefix_max_sum + nums[mid]
        return max(cross_max_sum, left, right)

解法三 - 動態規劃

思路

咱們來思考一下這個問題， 看能不能將其拆解爲規模更小的一樣問題，而且能找出
遞推關係。

咱們不妨假設問題 Q(list, i) 表示 list 中以索引 i 結尾的狀況下最大子序列和，
那麼原問題就轉化爲 Q(list, i), 其中 i = 0,1,2…n-1 中的最大值。

咱們繼續來看下遞歸關係，即 Q(list, i)和 Q(list, i - 1)的關係，
即如何根據 Q(list, i - 1) 推導出 Q(list, i)。

若是已知 Q(list, i - 1)， 咱們能夠將問題分爲兩種狀況，即以索引爲 i 的元素終止，
或者只有一個索引爲 i 的元素。

• 若是以索引爲 i 的元素終止， 那麼就是 Q(list, i - 1) + list[i]
• 若是隻有一個索引爲 i 的元素，那麼就是 list[i]

分析到這裏，遞推關係就很明朗了，即Q(list, i) = Math.max(0, Q(list, i - 1)) + list[i]

舉例說明，以下圖：

這種算法的時間複雜度 O(N), 空間複雜度爲 O(1)

代碼

Java:

class MaximumSubarrayDP {
  public int maxSubArray(int[] nums) {
     int currMaxSum = nums[0];
     int maxSum = nums[0];
     for (int i = 1; i < nums.length; i++) {
       currMaxSum = Math.max(currMaxSum + nums[i], nums[i]);
       maxSum = Math.max(maxSum, currMaxSum);
     }
     return maxSum;
  }
}

Python 3:

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        max_sum_ending_curr_index = max_sum = nums[0]
        for i in range(1, n):
            max_sum_ending_curr_index = max(max_sum_ending_curr_index + nums[i], nums[i])
            max_sum = max(max_sum_ending_curr_index, max_sum)

        return max_sum

解法四 - 數學分析

思路

咱們來經過數學分析來看一下這個題目。

咱們定義函數 S(i) ，它的功能是計算以 0（包括 0）開始加到 i（包括 i）的值。

那麼 S(j) - S(i - 1) 就等於 從 i 開始（包括 i）加到 j（包括 j）的值。

咱們進一步分析，實際上咱們只須要遍歷一次計算出全部的 S(i), 其中 i 等於 0,1,2….,n-1。
而後咱們再減去以前的 S(k),其中 k 等於 0，1，i - 1，中的最小值便可。 所以咱們須要
用一個變量來維護這個最小值，還須要一個變量維護最大值。

這種算法的時間複雜度 O(N), 空間複雜度爲 O(1)。

其實不少題目，都有這樣的思想， 好比以前的《每日一題 - 電梯問題》。

代碼

Java:

class MaxSumSubarray {
  public int maxSubArray3(int[] nums) {
      int maxSum = nums[0];
      int sum = 0;
      int minSum = 0;
      for (int num : nums) {
        // prefix Sum
        sum += num;
        // update maxSum
        maxSum = Math.max(maxSum, sum - minSum);
        // update minSum
        minSum = Math.min(minSum, sum);
      }
      return maxSum;
  }
}

Python 3:

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        maxSum = nums[0]
        minSum = sum = 0
        for i in range(n):
            sum += nums[i]
            maxSum = max(maxSum, sum - minSum)
            minSum = min(minSum, sum)

        return maxSum

總結

咱們使用四種方法解決了《最大子序列和問題》,
並詳細分析了各個解法的思路以及複雜度，相信下次你碰到相同或者相似的問題
的時候也可以發散思惟，作到一題多解，多題一解。

實際上，咱們只是求出了最大的和，若是題目進一步要求出最大子序列和的子序列呢？ 若是要題目容許不連續呢？ 咱們又該如何思考和變通？如何將數組改爲二維，求解最大矩陣和怎麼計算？ 這些問題留給讀者本身來思考。