【刷题之路】牛客剑指offer JZ42 连续子数组的最大和
一、题目描述
原题连接: JZ42 连续子数组的最大和
题目描述:
输入一个长度为n的整型数组array,数组中的一个或连续多个整数组成一个子数组,子数组最小长度为1。求所有子数组的和的最大值。
数据范围:1<=n<=2×10^5
−100<=a[i]<=100
要求:时间复杂度为O(n),空间复杂度为O(n)
进阶:时间复杂度为O(n),空间复杂度为O(1)
示例1
输入:[1,-2,3,10,-4,7,2,-5]
返回值: 18
说明:
经分析可知,输入数组的子数组[3,10,-4,7,2]可以求得最大和为18
示例2
输入:[2]
返回值: 2
示例3
输入:[-10]
返回值:-10
二、解题
1、方法1——暴力法
1.1、思路分析
枚举出所有的子数组,求出子数组中元素的总和,每次都跟已有的最大子数组元素总和max_sum进行对比。
枚举完所有的子串后,我们也就求出了连续子数组的最大和。
1.2、代码实现
有了以上思路,那我们写起代码来也就水到渠成了:
int FindGreatestSumOfSubArray1(int* array, int arrayLen) {
assert(array);
int i = 0;
int j = 0;
int max_sum = array[0]; // 存储最大的子数组的和,默认初始化为array[0]
for (i = 0; i < arrayLen; i++) {
int part_sum = 0; // 存储每个子数组的和
for (j = i; j < arrayLen; j++) {
part_sum += array[j];
if (part_sum > max_sum) {
max_sum = part_sum;
}
}
}
return max_sum;
}
时间复杂度:O(n^2),其中n为数组元素个数。
空间复杂度:O(1),我们只需要用到常数级的额外空间。
这个算法的时间复杂度过大,提交给牛客网是不给通过的。
2、方法2——动态规划
2.1、思路分析
我们想想,这道题是不是跟 LeetCode 5.最长回文子串 很类似啊?
所以我们也可以用与那一题一样的动态规划思路:
我们可以设置动态规划表dp,dp[i][j]表示从下标为i的元素到下标为j的元素的子数组中元素的总和,所以状态转移方程为:
dp[i][j] = dp[i + 1][j - 1] + array[i] + array[j]
因为dp对角线上的元素表示的是一个单独的元素,所以我们可以先对
对角线的元素进行初始化。
然后填表时候为了填表的正确性,我们还是要先一列一列地填,再一行一行的填。
且dp[i][j] 和dp[j][i]其实是同一个子数组,所以我们填表就只需要填对角线及其上半部分即可。
2.2、代码实现
有了以上思路,那我们写起代码来也就水到渠成了:
int FindGreatestSumOfSubArray2(int* array, int arrayLen) {
assert(array);
// 先试用malloc函数模拟出一个二维数组dp
int** dp = (int**)malloc(arrayLen * sizeof(int*));
int i = 0;
for (i = 0; i < arrayLen; i++) {
dp[i] = (int*)malloc(arrayLen * sizeof(int));
}
int max_sum = array[0];
// 先初始化对角线
for (i = 0; i < arrayLen; i++) {
dp[i][i] = array[i];
if (dp[i][j] > max_sum) {
max_sum = dp[i][j];
}
}
// 再填入其他部分
int j = 0;
for (j = 1; j < arrayLen; j++) {
for (i = 0; i < j; i++) {
dp[i][j] = dp[i + 1][j - 1] + array[i] + array[j];
if (dp[i][j] > max_sum) {
max_sum = dp[i][j];
}
}
}
for (i = 0; i < arrayLen; i++) {
free(dp[i]);
dp[i] = NULL;
}
free(dp);
dp = NULL;
return max_sum;
}
时间复杂度:O(n^2),其中n为数组元素个数。
空间复杂度:O(n^2),其中n为数组元素个数。
但这个算法的时间和空间的复杂度都过大,提交给牛客网也是不给过的。
2.3、改进1
改进思路:
我们应该想想这一题和那道求最长回文子串的题有什么不同,求回文子串求的是“最长”而我们这题求的是“最大和”。在求最长回文子串的时候当一个子串的长度增加时,只可能有两种情况增长后的字串不是回文串和是回文串,如果是回文串,那么最长回文串的长度就一定会增加。而现在我们求的最大子串总和当子串的长度增加时,总和有可能是减小的,因为在子串增长的时候后面又可能遇到的是负数。
所以我们这提并不需要记录所有子串的总和,我们只需要记录总和比之前的子串的总和更大的总和即可。
所以我们就有了以下思路:
设置一个一维数组dp,dp[i]表示以元素array[i]为结尾的子串中包含的所有子串中最大子串总和。
动态转移方程为:
dp[i] = max(dp[i - 1] + array[i], array[i])。
每求出一个dp[i],我们都将它与现已有的最大子串总和max_sum进行比较,当我们遍历完数组之后,我们就求出了连续子数组的最大和。
改进代码实现:
有了以上改进思路,那我们再写起代码来也就水到渠成了:
int Max(int x, int y) {
return x > y ? x : y;
}
int FindGreatestSumOfSubArray3(int* array, int arrayLen) {
assert(array);
// 先用malloc函开辟一块空间模拟一维数组dp
int* dp = (int*)malloc(arrayLen * sizeof(int));
int max_sum = array[0];
dp[0] = array[0];
int i = 0;
for (i = 1; i < arrayLen; i++) {
dp[i] = Max(dp[i - 1] + array[i], array[i]);
if (dp[i] > max_sum) {
max_sum = dp[i];
}
}
free(dp);
dp = NULL;
return max_sum;
}
时间复杂度:O(n),其中n为数组元素个数,我们需要遍历一遍数组。
空间复杂度:O(n),我们需要n个整型空间来存储以元素array[i]为结尾的子串的最大元素总和。
2.4、改进2
改进思路:
既然我们每次求出dp[i]都是为了和max_sum进行对比,也就是说对每个dp[i]的使用都是一次性的,那又何必把每个dp[i]都存起来呢?
我们完全可以只用一个变量来存储以array[i]为结尾的子串的最大元素总和。
改进代码实现:
有了以上改进思路,那我们再写起代码来也就水到渠成了:
int FindGreatestSumOfSubArray4(int* array, int arrayLen) {
assert(array);
int max_sum = array[0];
int dp = array[0];
int i = 0;
for (i = 1; i < arrayLen; i++) {
dp = Max(dp + array[i], array[i]);
if (dp > max_sum) {
max_sum = dp;
}
}
return max_sum;
}
时间复杂度:O(n),其中n为数组元素个数,我们只需要遍历一遍数组即可。
空间复杂度:O(1),我们只需要用到常数级的额外空间。