剑指 Offer 42. 连续子数组的最大和

题目描述：
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

示例1 :

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

提示：

1 <= arr.length <= 10^5
-100 <= arr[i] <= 100

>>>>>>>>>>>>>>力扣原题传送>>>>>>>>>>>>>>>
下列将使用 暴力法、分治法、动态规划、贪心 对本题进行求解，初学算法，存在错误还请指出

暴力求解

枚举出所有连续子数组的和，取最大值返回。

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

• 时间复杂度O(N^2)
• 空间复杂度O(1)
  时间复杂度过高，无法通过测试案例
  

分治法

利用分而治之的思想，将序列分为两块：左半子序列、右半子序列。
显然，答案一定出现在以下三种情况中：

• 左半部分序列最大子序和即为整个序列最大子序和；
• 右半部分序列最大子序和即为整个序列最大子序和；
• 最大子序和出现在原序列中部（即部分在左半部分，部分位于右半部分）；
  用递归分别求出左右两部分的子序列最大和，具体分析请看代码↓

class Solution {
public:
	int maxSum(vector<int>& nums, int l, int r) {
		if (l == r)//子数组长度为一，直接返回当前元素
			return nums[l];
			
		int mid = (l + r) / 2;
		int leftSum = maxSum(nums, l, mid);//递归调用分别求得左右部分序列最大和
		int rightSum = maxSum(nums, mid + 1, r);
		
		//从mid位置处往前遍历，并记录最大和
		int s1 = nums[mid], left = nums[mid];
		for (int i = mid - 1; i >= l; --i) {
			left += nums[i];
			s1 = max(s1, left);
		}
		//从mid + 1位置往后遍历，并记录最大和
		int s2 = nums[mid + 1], right = nums[mid + 1];
		for (int i = mid + 2; i <= r; i++) {
			right += nums[i];
			s2 = max(s2, right);
		}
		
		int sum = s1 + s2;//计算出第三种情况：最大子序和横跨左右序列：将左右两部分最大和拼接起来
		
		if (sum < leftSum) sum = leftSum; //与其他两种情况比较，取最大的
		if (sum < rightSum) sum = rightSum;
		return sum;
	}

	int maxSubArray(vector<int>& nums) {
		return 	maxSum(nums, 0, nums.size() - 1);
	}
};

• 对数组折中分割 log2（N）次，每次分割后整体都对原数组进行一次遍历，时间复杂度O(N*logN)
• 递归调用 造成的内存栈深度为：2 * log2（N），空间复杂度O(logN）
  

动态规划求解

这里引用“代码随想录”中对动态规划问题的求解方法：

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！

1、确定dp数组（dp table）以及下标的含义
2、确定递推公式
3、dp数组如何初始化
4、确定遍历顺序
5、举例推导dp数组

附上动态规划法学习网址：关于动态规划，你应该了解这些！
按照Carl老师的五部曲，我对本题的理解如下↓

class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		int length = nums.size();
		//确定dp数组（dp table）以及下标的含义
		vector<int> dp(nums.size());//dp数组下标代表到当前位置的最大子序和
		//确定递推公式:当前边的子序和影响到当前值时我们选择抛弃前面带来的负面影响
		//dp[i] = max(dp[i - 1] + nums[i], nums[i]);
		
		//dp数组初始化：子数组仅有一个元素的情况下最大值为其本身
		dp[0] = nums[0];
		
		//确定推导顺序：从左往右寻找最大子序和
		for (int i = 1; i < length; ++i) {
			dp[i] = max(dp[i - 1] + nums[i], nums[i]);
		}
		return *max_element(dp.begin(), dp.end());//返回dp数组中最大值
	}
};

注意到最终的答案并不一定是dp[length - 1]:
因为在递推时我们没法判断 dp[i - 1] 与 nums[i] 的关系，仅仅是对dp[i - 1] + nums[i] 与 nums[i] 的大小进行了比较，选择了较大值作为当前dp[ i ]的状态。
考虑这种情况: dp[i - 1] = - 1, nums[ i ] = - 2, 我们选择了使用 nums[ i ] (-2) 作为本次状态，但是并不代表它就是我们所需要的最终结果。

• 两次遍历，时间复杂度O(N)
• 使用了额外的dp数组，空间复杂度O(N)
  
  这里我们注意到，dp的创建使得空间复杂度提高不少，我们能不能适当对其优化呢，答案是肯定的，稍加思索就发现一个问题：动态规划过程中使用到的递推公式：

dp[i] = max(dp[i - 1] + nums[i], nums[i])

对于求解dp数组中的当前项，仅需用到其前一项，是不是来feeling了 OvO！，没错，这里就能很愉快地去使用 滚动数组 的思想了！！！
需要额外注意的是：上一解法在完成对dp数组的填充后我们返回的是数组中的最大值，而使用 滚动数组 势必造成前面的数据丢失！~~

具体做法为：
定义一个变量保存dp数组前一项的值，另一个变量保存dp数组的最大值。

class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		int preMaxSum = 0;//未开始遍历前 最大子序和为0
		int ans = nums[0];//记录dp数组的最大值
		for (const int val : nums) {
            //两种选择：让当前元素加上之前的一段 或 让其单独成段
			preMaxSum = max(preMaxSum + val, val);//dp[i] = max(dp[i - 1] + nums[i], nums[i])
			ans = max(preMaxSum, ans);
		}
		return ans;
	}
};

• 一次遍历，时间复杂度O(N)
• 用到常量空间，空间复杂度O(1)
  

贪心算法

我们都清楚，要想获得连续子数组的最大和，必然需要非负数去“做贡献”，因此一种贪心策略为：如果前项和preSum小于0，那么直接就抛弃前项和（若不抛弃，势必对后面的和造成负面影响，从而无法获得最优解）

class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		int length = nums.size();
		int preSum = 0;
		int curSum = 0;
		int maxSum = INT_MIN;
		for (int i = 0; i < length; ++i) {
			if (preSum < 0)
				curSum = nums[i];//之前和小于0则丢弃
			else
				curSum = preSum + nums[i];//大于0则加上之前和
			preSum = curSum;//更新数据
			maxSum = maxSum < curSum ? curSum : maxSum;//更新数据
		}
		return maxSum;
	}
};

• 一次遍历，时间复杂度O(N)
• 常量空间，空间复杂度O(1)

各算法时间空间复杂度一览

算法	时间复杂度	空间复杂度
暴力法	O(N ^ 2)	O(1)
分治法	O(N * logN)	O(logN)
动态规划	O(N )	O(1)
贪心	O(N )	O(1)