LeetCode 53 最大子数组和问题

• 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

• note：子数组是数组中的一个连续部分。

• 示例 1：
  输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
  输出：6
  解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

• 示例 2：
  输入：nums = [1]
  输出：1

• 示例 3：
  输入：nums = [5,4,-1,7,8]
  输出：23

• 提示：
  1 <= nums.length <= 105
  -104 <= nums[i] <= 104

• 题解一：这题最简单直接的方法其实就是纯暴力求解，算出每一个子数组的和，最后仅保留最大子数组和即可，这里有些和子字符串的遍历相似。

点击查看代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        int max_arr = INT_MIN;
        int sum = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i; j < n; ++j) { // 双重循环遍历每一个子数组
                sum += nums[j];           // 求得每一个子数组的和
                max_arr = max(sum, max_arr); // 实时更新最大子数组和
            }
            sum = 0; // 每次更换子数组起点时需将sum赋为0
        }
        return max_arr;
    }
};

 易得该暴力求解算法实践复杂度为O(n2);

• 题解二：我们可以采用分治法的思路解决该题，顾名思义，分治法则是将整个大问题分解成多个子问题，直到分解成最小问题（也就是一般我们所说的递归出口或者是if判定语句不成立时），此处最直接的思路便是将整个数组分成尽可能大小相同的两个子数组，然后子数组再分，直到不可再分（也就是子数组只有一个元素时）。

• 但是分治法不仅有“分”还要有“治”，当子数组大小为1的时候，递归开始回升（递结束，归开始），其实我个人认为分治法难点就在于“治”上，归并排序用的是MERGE操作合并。对于此问题我们可以分为三个情况，对于一个数组的最大子数组和可能为左子数组的最大子数组和，也可能为右子数组的最大子数组和，也有可能是跨越左右数组中点的子数组，也就是必须跨越中点的最大子数组和。
• 至此，分治法的“分”与“治”我们已经分析完毕，付诸实践吧

点击查看代码

class Solution {
public:
    int maxMidSubArray(vector<int>& nums, int low, int mid, int high) {
        int max_mid_left = INT_MIN; // 初始值赋为整型最小值
        int sum = 0;
        for (int i = mid; i >= low; --i) { // 跨越中点的左最大子数组和
            sum += nums[i];
            max_mid_left = max(max_mid_left, sum);
        }
        int max_mid_right = INT_MIN;
        sum = 0;
        for (int i = mid + 1; i <= high; ++i) { // 跨越中点的右最大子数组和
            sum += nums[i]; // 此处需注意不要将nums[mid]加两次
            max_mid_right = max(max_mid_right, sum);
        }
        return max_mid_left + max_mid_right;
    }
    int maxArr(vector<int>& nums, int low, int high) {
        if (low == high) {
            return nums[high]; // 递归出口
        }
        int mid = (low + high) / 2;
        int max_left = maxArr(nums, low, mid);
        int max_right = maxArr(nums, mid + 1, high);
        int mid_arr = maxMidSubArray(nums, low, mid, high);
        return max(max(max_left, max_right), mid_arr); // 三者取最大值返回
    }
    int maxSubArray(vector<int>& nums) {
        if (nums.empty()) {
            return INT_MIN;
        }
        return maxArr(nums, 0, nums.size() - 1);
    }
};

 类比归并排序递推式（排序的MERGE操作与该算法的中点延申算法实践复杂度均为O(n))，易得该算法时间复杂度为O(nlogn);

• 题解三：贪心法