LeetCode --- 53. 最大子序和

• LeetCode链接：53. 最大子序和

• 算法策略 ： 分治（Divide And Conquer）

• 算法策略 ： 动态规划（Dynamic Programming）

给定一个长度为n的整数序列，求它的最大连续子序列和
比如-2、1、-3、4、-1、2、1、-5、4的最大连续子序列和是4 + (-1) + 2 + 1 = 6

解法1 - 暴力出奇迹

• 穷举出所有可能的连续子序列，并计算出它们的和，最后取它们中的最大值

int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int max = Integer.MIN_VALUE;
    for (int begin = 0; begin < nums.length; begin++) {
        for (int end = begin; end < nums.length; end++) {
            int sum = 0;
            for (int i = begin; i <= end; i++) {
                sum += nums[i];
            }
            max = Math.max(max, sum);
        }
    }
    return max;
}

空间复杂度：O(1)，时间复杂度：O(n^3)

解法1 - 暴力出奇迹 - 优化

• 重复利用前面计算过的结果

int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int max = Integer.MIN_VALUE;
    for (int begin = 0; begin < nums.length; begin++) {
        int sum = 0;
        for (int end = begin; end < nums.length; end++) {
            sum += nums[end];
            max = Math.max(max, sum);
        }
    }
    return max;
}

• 空间复杂度：O(1)，时间复杂度：O(n^2)

---

解法2 - 分治

• 将序列均匀地分割成2个子序列
• [begin, end) = [begin, mid) + [mid, end)，mid = (begin + end) >> 1
• 假设问题的解释S[i, j)，那么问题的解有3中可能

1. [i, j)存在于[begin, mid)中
2. [i, j)存在于[mid, end)中
3. [i, j)一部分存在于[begin, mid)中，另一部分存在于[mid, end)中
   [i, j) = [i, mid) + [mid, j)
   S[i, mid) = max { S[k, mid)}，begin <= k < mid
   S[mid, j) = max { S[mid, k)}，mid < k <= end
   

int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    return maxSubArray(nums, 0, nums.length);
}
int maxSubArray(int[] nums, int begin, int end) {
    if (end - begin < 2) return nums[begin];
    int mid = (begin + end) >> 1;
    int leftMax = nums[mid - 1];
    int leftSum = leftMax;
    for (int i = mid - 2; i >= begin; i--) {
        leftSum += nums[i];
        leftMax = Math.max(leftMax, leftSum);
    }
    int rightMax = nums[mid];
    int rightSum = rightMax;
    for (int i = mid + 1; i < end; i++) {
        rightSum += nums[i];
        rightMax = Math.max(rightMax, rightSum);
    }
    return Math.max(leftMax + rightMax,
            Math.max(maxSubArray(nums, begin, mid),
                    maxSubArray(nums, mid, end)));
}

• 空间复杂度：O(logn)
• 时间复杂度：O(nlogn)，跟归并排序、快速排序一样，T(n) = 2T(n/2) + O(n)

---

解法3 - 动态规划

• 状态定义
  假设dp(i)是以nums[i]结尾的最大连续子序列和（nums是整个序列）

1. 以nums[0] -2 结尾的最大连续子序列是 -2，所以dp(0) = -2
2. 以nums[1] 1 结尾的最大连续子序列是 -1，所以dp(1) = 1
3. 以nums[2] -3 结尾的最大连续子序列是 1、-3，所以dp(2) = dp(1) + (-3) = -2
4. 以nums[3] 4 结尾的最大连续子序列是 4，所以dp(3) = 4
5. 以nums[4] -1 结尾的最大连续子序列是 4、-1，所以dp(4) = dp(3) + (-1) = 3
6. 以nums[5] 2 结尾的最大连续子序列是 4、-1、2，所以dp(5) = dp(4) + 2 = 5
7. 以nums[6] 1 结尾的最大连续子序列是 4、-1、2、1，所以dp(6) = dp(5) + 1 = 6
8. 以nums[7] -5 结尾的最大连续子序列是 4、-1、2、1、-5，所以dp(7) = dp(6) + (-5) = 1

状态转移方程和初始状态

• 状态转移方程

1. 如果dp(i - 1) <= 0，那么dp(i) = nums[i]
2. 如果dp(i - 1) >= 0，那么dp(i) = dp(i - 1) + nums[i]

• 初始状态
  dp(0)的值是nums[0]
• 最终的解
  最大连续子序列和是所有dp(i)中的最大值max { dp(i) }，i ∈ [0, nums.length)

动态规划 - 实现

int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int[] dp = new int[nums.length];
    int max = dp[0] = nums[0];
    for (int i = 1; i < dp.length; i++) {
        int prev = dp[i - 1];
        if (prev > 0) {
            dp[i] = prev + nums[i];
        } else {
            dp[i] = nums[i];
        }
        max = Math.max(max, dp[i]);
    }
    return max;
}

• 空间复杂度O(n)，时间复杂度O(n)

动态规划 - 优化实现

int maxSubArray(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    int dp = nums[0];
    int max = dp;
    for (int i = 1; i < nums.length; i++) {
        if (dp > 0) {
            dp = dp + nums[i];
        } else {
            dp = nums[i];
        }
        max = Math.max(dp, max);
    }
    return max;
}

• 空间复杂度：O(1)，时间复杂度：O(n)