本文代码均采用C++
0x01.问题
给定一个整数数组
nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
输入示例：[-2,1,-3,4,-1,2,1,-5,4]
输出示例：6
解释： 连续子数组 [4,-1,2,1] 的和最大，为 6。
C++函数形式为 int maxSubArray(vector<int>& nums)
0x02.分析问题
这是一个连续的子列和问题，很明显，第一种做法就出来了，暴力枚举，时间复杂度为O（n^2）,这里面存在许多相互独立的子问题，所以可以考虑动态规划，时间复杂度为O（n），然后，可以根据实际的子列情况在线处理，贪心算法就出来了，时间复杂度因也可以为O（n），在这个问题中，我们采用时间复杂度更低的分治法解决。
0x03.分治法基本思路
分治法的基本思路：
- 将一个规模为N的问题，分解成K个规模较小的子问题，这些子问题相互独立且月原问题性质相同。
- 求解出子问题的解，合并得到原问题的解。
分治法的基本特征：
- 该问题的规模缩小到一定程度就可以容易的解决。
- 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
- 利用该问题分解出子问题的解，可以合并为该问题的解。
- 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
分治算法大多采用递归实现。
分治法的思维过程：
- 找到最小问题规模时的求解方法。
- 考虑随着问题规模增大时的求解方法。
- 找到求解的递归函数，设计递归程序。
0x04.此问题的分治法分析过程
若原序列只有一个数，那么最大值就是它本身。当原序列的元素非常多，我们应该怎样使用分治的思维去处理呢？
分治，就是分而治之，把每个小问题分到小，最后解决它，然后合并所有小问题，就能得到最终的解。
对于一个序列，如何去分开它呢，最简单的分治思想，就是左右各一半，然后左边处理，右边处理，再合起来处理，找出里面的最大值，就可以了，那么，是什么原理在支撑着我们只要把左边的，右边的，一起的最大值求出来就可以了呢？
关键：以数组中点为界，目标值只能在三处---要么在中点左边(不含中点)，要么必须包含中点，要么右边(不含中点)。
有了这条思路，我们就可以开始写代码了。
具体如何把分治的思想用代码表述出来，可以参考 归并排序算法，原理差不多：戳我前往
0x05.代码--分治法
int crossSum(vector<int>& nums, int left, int right, int p) {
if (left == right) return nums[left];
int leftSubsum = INT_MIN;
int currSum = 0;
for (int i = p; i > left - 1; i--) {
currSum += nums[i];
leftSubsum = max(leftSubsum, currSum);
}
int rightSubsum = INT_MIN;
currSum = 0;
for (int i = p + 1; i < right + 1; i++) {
currSum += nums[i];
rightSubsum = max(rightSubsum, currSum);
}
return leftSubsum + rightSubsum;
}
int helper(vector<int>& nums, int left, int right) {
if (left == right) return nums[left];
int p = (left + right) / 2;
int leftSum = helper(nums, left, p);
int rightSum = helper(nums, p+1, right);
int crosssum = crossSum(nums, left, right, p);
return max(max(leftSum, rightSum), crosssum);
}
int maxSubArray(vector<int>& nums) {
return helper(nums, 0, nums.size() - 1);
}0x06.复杂度分析
时间复杂度：O(N*logN)
空间复杂度：O(logN)--来源递归调用栈产生的空间
0x07.其他算法代码
1：全排列--暴力枚举 --O（N^2）
int maxSubArray(vector<int>& nums){
int max = INT_MIN;
int numsSize = int(nums.size());
for (int i = 0; i < numsSize; i++){
int sum = 0;
for (int j = i; j < numsSize; j++){
sum += nums[j];
if (sum > max){
max = sum;
}
}
}
return max;
}空间复杂度：O(1)
2.动态规划 --O（N）
状态转移方程：dp[i] = max(dp[i - 1] + nums[i], nums[i]) result = max(result, dp[i]); dp[i]表示表示nums中以nums[i]结尾的最大子序和，result记录所有最大自序和中的最大值。
int maxSubArray(vector<int>& nums){
int result = INT_MIN;
int numsSize = int(nums.size());
vector<int> dp(numsSize);
dp[0] = nums[0];
result = dp[0];
for (int i = 1; i < numsSize; i++){
dp[i] = max(dp[i - 1] + nums[i], nums[i]);
result = max(result, dp[i]);
}
return result;
}空间复杂度：O（n）
3.动态规划--改进 --O（N）
int maxSubArray(vector<int>& nums){
int result = INT_MIN;
int numsSize = int(nums.size());
int dp(nums[0]);
result = dp;
for (int i = 1; i < numsSize; i++){
dp = max(dp + nums[i], nums[i]);
result = max(result, dp);
}
return result;
}空间复杂度：O（1）
4.贪心算法 --O（N）
int maxSubArray(vector<int>& nums) {
int n = nums.size();
int currSum, maxSum;
currSum = maxSum = nums[0];
for (int i = 1; i < n; i++) {
currSum = max(currSum + nums[i], nums[i]);
maxSum = max(maxSum, currSum);
}
return maxSum;
}本质上和改进的动态规划差不多
空间复杂度：O（1）
这是这一类问题的通用解法，如果遇到某些全为负数则输出0的，只需要加入一些判断条件即可。
如果本文对你有帮助，请分享给你的朋友吧！
ATFWUS --Writing By 2020--03--15
