力扣第53题 最大子数组和 C++ 动态规划 / 贪心算法 附Java代码

题目

53. 最大子数组和

中等

相关标签

数组   分治   动态规划

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

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

示例 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

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

思路和解题方法 一（动态规划）

1. 首先定义一个变量result，用于记录目前为止找到的最大子序和。初始值设置为INT_MIN，即理论上的最小值。

2. 获取数组nums的长度。

3. 定义一个变量dp，并将其初始化为数组的第一个元素。然后将dp的值赋给result，初始化result为数组的第一个元素的值。

4. 循环遍历数组，从数组的第二个元素开始计算每个位置之前的最大子序和。对于当前位置i，更新dp的值为max(dp + nums[i], nums[i])，即要么将当前元素加入到之前的子序和中，要么以当前元素作为新的子序和的起点。然后将当前dp的值与result比较，将较大的值赋给result，保持result为目前为止找到的最大子序和。

5. 返回result，即全局最大子序和的值。

复杂度

        时间复杂度:

                O(n)

时间复杂度为 O(n)，其中 n 为数组 nums 的长度。因为只需要遍历一次数组，对于每个元素只需要常数时间（O(1)）操作，所以时间复杂度为 O(n)。

        空间复杂度

                O(1)

空间复杂度为 O(1)，因为只使用了常数个变量（result、numsSize、dp）来保存中间结果，所以空间复杂度为 O(1)。

c++ 代码 一 动态规划

class Solution
{
public:
    int maxSubArray(vector<int> &nums)
    {
        // 类似寻找最大最小值的题目，初始值一定要定义成理论上的最小最大值
        int result = INT_MIN; // 用于记录最大子序和的变量, 初始值设置为INT_MIN

        int numsSize = int(nums.size()); // 获取数组nums的长度

        // 因为只需要知道dp的前一项，我们用int代替一维数组
        int dp(nums[0]); // 定义dp变量，并将其初始化为数组的第一个元素
        result = dp; // 初始化result为数组的第一个元素的值

        // 遍历数组，计算每个位置之前的最大子序和
        for (int i = 1; i < numsSize; i++)
        {
            dp = max(dp + nums[i], nums[i]); // 更新dp的值为max(dp + nums[i], nums[i])
            result = max(result, dp); // 更新result为目前为止找到的最大子序和
        }

        return result; // 返回最大子序和的结果
    }
};

 思路和解题方法 二（贪心算法）

1. 定义一个变量res，用于记录目前为止找到的最大子序和。初始值设置为数组的第一个元素。

2. 循环遍历数组，从数组的第二个元素开始计算每个位置之前的最大子序和。对于当前位置i，如果前一个位置的子序和大于0（即对结果有贡献），则将其加到当前位置的元素上，以得到当前位置的最大子序和。

3. 在每次迭代中，将当前最大子序和与全局最大子序和相比较，以得出整个数组的最大子序和。

4. 返回res，即全局最大子序和的值。

复杂度

        时间复杂度:

                O(n)

时间复杂度为O(n)，其中n是数组nums的长度，因为该算法只需要一次遍历就能够求出最大子序和。在每个位置上，只需要进行一次比较和一次加法运算，因此时间复杂度为线性级别。

        空间复杂度

                O(1)

空间复杂度：这段代码的空间复杂度为O(1)，因为只用了常数个变量（result、numsSize、dp），不随输入规模而改变。

c++ 代码 二 贪心

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int res = nums[0]; // 用于记录最大子序和的变量，初始化为数组的第一个元素

        // 遍历数组，计算每个位置之前的最大子序和
        for(int i = 1; i < nums.size(); i++) {
            if (nums[i - 1] > 0) 
                nums[i] += nums[i - 1]; // 如果前一个位置的子序和大于0，则将其加到当前位置的元素上，以得到当前位置的最大子序和
            if (nums[i] > res) 
                res = nums[i]; // 更新res为目前为止找到的最大子序和
        }

        return res; // 返回最大子序和的结果
    }
};

附Java代码

1. 声明一个变量res，用于记录最大子序和结果。将其初始值设为数组第一个元素的值。

2. 声明一个变量pre，用于记录当前位置之前的最大子序和。将其初始化为数组第一个元素的值。

3. 从数组的第二个元素开始，遍历数组。对于每个位置i，更新pre的值为max(pre+nums[i], nums[i])，即要么将当前元素加入到之前的子序和中，要么以当前元素作为新的子序和的起点。

4. 在每次更新pre的同时，将当前pre的值与res比较，将较大的值赋给res，保持res为目前为止找到的最大子序和。

5. 遍历结束后，返回res，即全局最大子序和的结果。

class Solution {
    public int maxSubArray(int[] nums) {
        int res = nums[0]; // 用于记录最大子序和的变量, 初始值设置为数组第一个元素的值
        int pre = nums[0]; // 用于记录当前位置之前的最大子序和，初始化为数组第一个元素的值
        for(int i = 1; i < nums.length; i++) { // 遍历数组，计算每个位置之前的最大子序和
            pre = Math.max(pre + nums[i], nums[i]); // 更新pre的值为max(pre+nums[i], nums[i])
            res = Math.max(res, pre); // 更新res为目前为止找到的最大子序和
        }
        return res; // 返回最大子序和的结果
    }
}

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。