1. 题目

1.1 英文题目

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

1.2 中文题目

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

1.3输入输出

1.4 约束条件

• 1 <= nums.length <= 3 * 104
• -105 <= nums[i] <= 105

2. 实验平台

IDE：VS2019
IDE版本：16.10.1
语言：c++11

3. 程序

3.1 测试程序

#include "Solution.h"
#include <vector>	// std::vector
#include<iostream>	// std::cout
using namespace std;

// 主程序
void main()
{
	// 输入
	vector<int> nums = { -100000 };

	Solution solution; // 实例化Solution
	int k = solution.maxSubArray(nums); // 主功能

	// 输出
	cout << k << endl;
}

3.2 功能程序

3.2.1 穷举遍历法

（1）代码

#pragma once
#include<vector>    // std::vector
using namespace std;

//主功能
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 暴力求解
        int maxValue = -100000;
        for (int i = 0; i < nums.size(); i++) //遍历起始值
        {
            int nowSub = 0;
            for (int j = i; j < nums.size(); j++) // 全部遍历一遍
            {
                nowSub += nums[j];
                if (nowSub > maxValue) maxValue = nowSub;
            }
        }
        return maxValue;
    }
};

（2）解读

该方法是最容易想到的方法，暴力求解，运用滑动窗口法进行遍历，分别得到以某个为开头的序列进行求最大值，并随遍历的进行实时更新该最大值。复杂度为O((n^2))。

3.2.2 动态规划法

（1）代码

#pragma once
#include<vector>    // std::vector
using namespace std;

//主功能
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // 动态规划（时间复杂度O(n)，空间复杂度O(n))
        int length = nums.size();
        vector<int> dp(length);  // 存储每次递归的最大值
        dp[0] = nums[0];
        for (int i = 1; i < length; i++)
            dp[i] = max(dp[i - 1] + nums[i], nums[i], [](int a, int b) {return a > b ? a : b; }); // Lamda表达式

        //求dp中的最大值
        int maxSub = -100000;
        for (auto j : dp) // c++11中基于范围的for循环（Range-based for loop）
            if (maxSub < j)
                dp[j] = maxSub;
        return maxSub;
    }
};

（2）思路

参考：https://zhuanlan.zhihu.com/p/85188269

3.2.3 kadane算法

（1）代码

#pragma once
#include<vector>    // std::vector
using namespace std;

//主功能
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        // kadane算法（时间复杂度O(n)，空间复杂度O(1))
        int length = nums.size();
        int maxSub = nums[0];     // 慢指针
        int maxSubTemp = nums[0]; //快指针
        for (auto i : nums)
        {
            maxSubTemp = max(maxSubTemp + nums[i], nums[i], [](int a, int b) {return a > b ? a : b; }); // Lamda表达式
            if (maxSubTemp > maxSub) // 若当前最大值大于总最大值，则总最大值更新
                maxSub = maxSubTemp;
        }
        return maxSub;
    }
};

（2）解读

kadane算法是在动态规划法的基础上加上快慢指针法，快指针指向以i为结尾的子数组最大值之和，慢指针指向迄今为止的子数组最大值之和

3.3.4 分治法（divide and conquer）

（1）代码

pragma once

include // std::vector

//#include<limits.h> // INT_MIN整型最小值

include // std::max

using namespace std;

//主功能
class Solution {
public:
int maxSubArray(vector& nums) {
if (nums.empty()) return 0;
return helper(nums, 0, (int)nums.size() – 1);
}
int helper(vector& nums, int left, int right)
{
if (left >= right) return nums[left];
int mid = left + (right – left) / 2;
int lmax = helper(nums, left, mid – 1);
int rmax = helper(nums, mid + 1, right);
int mmax = nums[mid], t = mmax;
for (int i = mid – 1; i >= left; –i)
{
t += nums[i];
mmax = max(mmax, t);
}
t = mmax;
for (int i = mid + 1; i <= right; ++i)
{
t += nums[i];
mmax = max(mmax, t);
}
return max(mmax, max(lmax, rmax));
}
};
参考：https://www.cnblogs.com/grandyang/p/4377150.html

（2）解读

参考：https://www.jianshu.com/p/3a38d523503b

4. 相关知识

（1）滑动窗口法

滑动窗口其实就是选取部分序列作为窗口，窗口不停移动，直至找到答案，感觉这更像一种思想。
详细介绍可以参考：https://www.cnblogs.com/huansky/p/13488234.html

(2) Lamda表达式

Lamda表达式可以直接在需要调用函数的位置定义短小精悍的函数，而不需要预先定义好函数,但是不便于复用，适用于比较简单且不需要复用的函数。写法为：
func(input1,input2,[],(type1 parameter1，type2 parameter2){函数;}）
详细介绍参考：https://blog.csdn.net/A1138474382/article/details/111149792

(3) 基于范围的for循环（Range-based for loop）

c++11中加入的新特性，类似于python,matlab等面向对象语言的for循环，写法为：
for(auto i:array){;}
详细介绍参考：https://blog.csdn.net/hailong0715/article/details/54172848

（4）kadane算法

参考：https://zhuanlan.zhihu.com/p/85188269