leetcode 53. 最大子序和

第一种的算法复杂度是O(n^3)，没法通过，超过时间限制

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    var maxSum = nums[0];
    var len = nums.length;
    // i 为子序列的左边界
    for (var i = 0; i < len ; i++) {
        // j为子序列的右边界
        for (var j = i; j < len; j++) {
            var subSum = 0;
            // 迭代子序列中的每一个元素，求和
            for (var k = i; k <= j; k++){
                subSum += nums[k]
            }
            if (subSum > maxSum){
                maxSum = subSum
            }
        }
    }
    return maxSum;
};

第二种的算法复杂度为O(n^2)，可以通过

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    var maxSum = nums[0];
    var len = nums.length;
    for (var i = 0; i < len ; i++) {
        // j为子序列的左边界
        var subSum = 0;
        for (var j = i; j < len; j++) {
            subSum += nums[j]
            if (subSum > maxSum){
                maxSum = subSum
            }
        }
    }
    return maxSum;
};

第三种方法是分治法，算法复杂度是O(nlogn)
分治法：将一个问题拆分成多个相似的小问题，并对其分别求解，如果拆出的问题依然复杂，就通过递归调用再次将子问题拆分，直到拆出的方法可以以简单方式求得解，最后合并多个小问题的解，就是原问题的结果。
分治法求解最大子序列和问题。将序列等分为左右两个子序列，任何连续子序列所处的位置必然式如下三种情况之一：完全位于左子序列中、完全位于右子序列中以及跨越了左右序列的中点。那么，算法的工作就是先递归求解两个子序列，然后寻找跨越中点的最大子序列，最后在三种情况中选取和最大者。

var maxSubArray = function (nums) {
    return divide(nums, 0, nums.length - 1);
};

var divide = function (nums, l, r) {
    if (l === r) {
        return nums[l];
    }
    if (l === r - 1) {
        return Math.max(nums[l], Math.max(nums[r], nums[l] + nums[r]));
    }

    let mid = parseInt((l + r) / 2);
    let lmax = divide(nums, l, mid - 1);
    let rmax = divide(nums, mid + 1, r);

    let mmax = nums[mid];  // 从中间开始计算
    let sum = mmax; // 用来求和
    for (let i = mid - 1; i >= l; i--) {
        sum += nums[i];
        mmax = Math.max(mmax, sum);
    }

    sum = mmax;
    for (let i = mid + 1; i <= r; i++) {
        sum += nums[i];
        mmax = Math.max(mmax, sum);
    }

    return Math.max(lmax, Math.max(rmax, mmax));
}

第四种的算法复杂度是O(n)
动态规划的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans
如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果
时间复杂度：O(n)
联机算法：联机算法是在任意时刻算法对要操作的数据只读入(扫描)一次，一旦被读入并处理，它就不需要在被记忆了。而在此处理过程中算法能对它已经读入的数据立即给出相应子序列问题的正确答案

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    let ans = nums[0];
    let sum = 0;
    for(const num of nums) {
        if(sum > 0) {
            sum += num;
        } else {
            sum = num;
        }
        ans = Math.max(ans, sum);
    }
    return ans;
};

https://ruphi.cn/archives/340/