【LeetCode】53.最大子序和

题目

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

题解

方法1：暴力法

算法

暴力地用两重循环遍历所有情况

代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        int max = nums[0];
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum > max)
                    max = sum;
            }
        }
        return max;
    }
};

• 通过使用int n = nums.size()可以提高一点速度，从580ms到420ms，由此看出循环里使用vector的size()函数是非常不明智的。

分析

• 时间复杂度：$O(n^2)$，循环次数为$\frac{n(n-1)}{2}$。
• 空间复杂度：$O(1)$，只用了两个变量。
• LeetCode排名：8.66%

---

方法2：分治法

算法

代码

class Solution {
public:
    int CrossSum(vector<int>& nums, int left, int right, int middle) {
        if(left == right)
            return nums[left];
        
        int left_sum = nums[middle];
        int t = 0;
        for (int i = middle; i >= left; i--) {
            t += nums[i];
            if (t > left_sum)
                left_sum = t;
        }
        
        int right_sum = nums[middle + 1];
        t = 0;
        for (int i = middle + 1; i <= right; i++) {
            t += nums[i];
            if (t > right_sum)
                right_sum = t;
        }
        return left_sum + right_sum;
    }
    
    int MaxSub(vector<int>& nums, int left, int right) {
        if (left == right)
            return nums[left];
        
        int middle = (left + right) / 2;
        int left_sum = MaxSub(nums, left, middle);
        int right_sum = MaxSub(nums, middle + 1, right);
        int cross_sum = CrossSum(nums, left, right, middle);
        
        int t = left_sum > right_sum ? left_sum : right_sum;
        return t > cross_sum ? t : cross_sum;
    }
    
    int maxSubArray(vector<int>& nums) {
        return MaxSub(nums, 0, nums.size() - 1);
    }
};

分析

• 时间复杂度：$O(NlogN)$。
• 空间复杂度：$O(N)$，递归时使用线性空间。
• LeetCode排名：81.72%

---

方法3：动态规划

算法

代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max = nums[0];
        int n = nums.size();
        for (int i = 1; i < n; i++) {
            if (nums[i - 1] > 0)
                nums[i] += nums[i - 1];
            if (nums[i] > max)
                max = nums[i];
        }
        return max;
    }
};

分析

• 时间复杂度：$O(N)$，只遍历一遍。
• 空间复杂度：$O(1)$，算法使用常数空间。
• LeetCode排名：$98.37\%$，不过每次提交都会不一样，有时$98\%$，有时$20\%$，故只当作一个参考。