LeetCode刷题日记 53. 最大子序和

题目给出一个整数数组nums，要求在数组中找到具有最大和的连续子数组。这里首先使用暴力求解法，代码如下：

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

这段代码在遇到数组[-2,-1]时，会返回0。这是以为对maxsum的初始值设定为0，当实际maxsum比0还小的时候，就会返回0。为了修改这个bug，将maxsum的初始值重新设定为 INT_MIN，即在int形下最小整数，就可以解决这个问题，代码如下：

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

但是，因为采用的是暴力解法，需要将所有结果遍历一遍，因此运行速度非常的慢。

接下来考虑使用动态规划算法：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size());  //建立第二个数组
        dp[0] = nums[0];  //第二个数组第一个值与nums相同
        int result = dp[0];
        for(int i = 1 ; i < nums.size() ; i++) //循环数组大小的次数
        {
            dp[i] = max(dp[i-1] + nums[i],nums[i]); //在dp数组中，记录数组中可能出现的最大的和
            result = max(result,dp[i]);
        }
        return result;
    }
};

动态规划算法在时间上比暴力法快得多，但是因为它使用了第二个数组，因此内存消耗上较高。