LeetCode：53.最大子序和-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_28800345/article/details/115179357

这篇博客介绍了如何使用动态规划和线段树两种方法解决最大子数组和的问题。动态规划解决方案包括一维和二维的实现，线段树方案展示了树形动态规划的高效查询能力。这些算法在超出时间限制的情况下优化了计算效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

动态规划

结果：超出时间限制

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int len = nums.size();
        vector<vector<int>> dp(len);
        int maxn = INT_MIN;

        //动态规划, dp[i][j] 为连续一段 从i -> j的最大值 
        // dp[i][j] = dp[i][j - 1] + max{0, nums[j]}
        for(int i = 0; i < len; i++) {
            dp[i].resize(len);
            for(int j = i; j < len; j++) {
                if(i == j) dp[i][j] = nums[j];
                else dp[i][j] = dp[i][j - 1] + nums[j];
                if(maxn < dp[i][j]) maxn = dp[i][j];
            }
        }
        return maxn;
    }
};

动态规划：一维

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        //一维的动态规划: dp[i]表示截止到i的最大和
        //如果dp[i - 1] < 0, 则不需要再加nums[i]了,再加也还是越来越小,不如重新开始
        int lens = nums.size();
        int maxn = INT_MIN;
        vector<int> dp;
        dp.resize(lens);
        dp[0] = nums[0];
        for(int i = 0; i < lens; i++) {
            if(i > 0) dp[i] = max(dp[i - 1], 0) + nums[i];
            if(maxn < dp[i]) maxn = dp[i];
        }
        return maxn;
    }
};

树形动态规划(线段树)
🌂动态规划的树形写法

class Solution {
public:
    struct Status {
        int lSum, rSum, mSum, iSum;
    };

    Status get(vector<int> nums, int l, int r) {
        if(l == r) {
            return (Status) {nums[l], nums[l], nums[l], nums[l]};
        }
        int m = (l + r) / 2;
        Status lSub = get(nums, l, m);
        Status rSub = get(nums, m + 1, r);

        int iSum = lSub.iSum + rSub.iSum;
        int lSum = max(lSub.lSum, rSub.lSum + lSub.iSum);
        int rSum = max(rSub.rSum, lSub.rSum + rSub.iSum);
        int mSum = max(max(lSub.mSum, rSub.mSum), lSub.rSum + rSub.lSum);
        return (Status){lSum, rSum, mSum, iSum}; 
    }
    int maxSubArray(vector<int>& nums) {
        return get(nums, 0, nums.size() - 1).mSum;
    }
};