力扣 hot100 Day14

53. 最大子数组和

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

//ai提示写的
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.empty()) return 0;
        int dp = nums[0];
        int maxn=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            dp=(max(nums[i],dp+nums[i]));
            maxn=max(maxn,dp);
        }
        return maxn;        
    }
};

动态规划逻辑。

思考中最大的难点在于，如果用dp保存前面数组中具有最大和的子数组，不能顺利推进递推关系。

正确做法是，通过dp存储以num[i]结尾的最大序列值，通过maxn存储遍历过程中最大序列值。这样，就有了dp=(max(nums[i],dp+nums[i]))的递推关系，由于dp不总是所求值，即最大和的连续子数组不总是以nums[i]收尾，所以维护一个maxn值进行记录。

补充理解：由于具有最大和的连续子数组总归会以一个数结尾，即为一个dp，所以不会出现遗漏。

补充理解：如果前面的累计值小于 0 了，那么就没有意义了

//ai写的
class Solution {
public:
    int maxSubArray(std::vector<int>& nums) {
        return divideAndConquer(nums, 0, nums.size() - 1);
    }

private:
    // 分治递归函数
    int divideAndConquer(std::vector<int>& nums, int left, int right) {
        if (left == right) {
            return nums[left]; // 基本情况：子数组只有一个元素
        }

        int mid = left + (right - left) / 2; // 防止溢出

        // 递归求左右半部分的最大子数组和
        int leftMax = divideAndConquer(nums, left, mid);
        int rightMax = divideAndConquer(nums, mid + 1, right);

        // 计算跨越中点的最大子数组和
        int crossMax = maxCrossingSum(nums, left, mid, right);

        // 返回三者中的最大值
        return std::max({leftMax, rightMax, crossMax});
    }

    // 计算跨越中点的最大子数组和
    int maxCrossingSum(std::vector<int>& nums, int left, int mid, int right) {
        // 向左扩展（从中点到左边界）
        int leftSum = INT_MIN;
        int tempSum = 0;
        for (int i = mid; i >= left; i--) {
            tempSum += nums[i];
            leftSum = std::max(leftSum, tempSum);
        }

        // 向右扩展（从中点+1到右边界）
        int rightSum = INT_MIN;
        tempSum = 0;
        for (int i = mid + 1; i <= right; i++) {
            tempSum += nums[i];
            rightSum = std::max(rightSum, tempSum);
        }

        return leftSum + rightSum; // 跨越中点的和
    }
};

分治法，比官解清晰点。

并不比dp优秀，只是展示一下分治法的逻辑。

求解时，分别计算左边、右边、跨越两边数组，这三个的最大值，最后再取最大值。

思路很简单，主要是逻辑的实现，求解跨越两边的数组时，直接遍历到头，没有什么特别的。