如何将分治策略应用于最大和子数组问题（JavaScript）

我是一名前端开发人员，正在学习一些基本的CS基础知识。我做了一些leetcode，遇到了最大子数组问题

在看了几段视频后，我试图实现一个D/C解决方案，并提出了以下解决方案。然而，这并不是正确的回答

对于下面的输入，我应该返回6，但我继续返回4

输入：

[-2,1,-3,4,-1,2,1,-5,4]

预期：

6

实际：

4

解决方案：

var maxSubArray = function(nums) {
    if (nums.length === 1) {
        return nums[0];
    }
    const mid = Math.ceil(nums.length / 2);
    let LSS = maxSubArray(nums.slice(0, mid));
    let RSS = maxSubArray(nums.slice(mid));
    

    let leftSum = 0;
    let rightSum = 0;
    let sum = 0;

    nums.slice(0, mid).forEach(num => {
        sum += num;
        leftSum = Math.max(sum, leftSum);
    });
    sum = 0;
    nums.slice(mid).forEach(num => {
        sum += num;
        rightSum = Math.max(sum, rightSum);
    });

    return Math.max(RSS, LSS, (leftSum + rightSum));
};

---

有人能解释一下我在这个解决方案中缺少了什么吗？

这是一个动态规划解决方案，它将通过：

var maxSubArray = function(nums) {
    for (let index = 1; index < nums.length; index++) {
        nums[index] = Math.max(nums[index], nums[index] + nums[index - 1]);
    }
    return Math.max.apply(Math, nums);
};

这是一个基于Java的LeetCode分而治之的解决方案（与您的方法类似），其中没有JavaScript代码片段：

class Solution {
  public int crossSum(int[] nums, int left, int right, int p) {
    if (left == right) return nums[left];

    int leftSubsum = Integer.MIN_VALUE;
    int currSum = 0;
    for(int i = p; i > left - 1; --i) {
      currSum += nums[i];
      leftSubsum = Math.max(leftSubsum, currSum);
    }

    int rightSubsum = Integer.MIN_VALUE;
    currSum = 0;
    for(int i = p + 1; i < right + 1; ++i) {
      currSum += nums[i];
      rightSubsum = Math.max(rightSubsum, currSum);
    }

    return leftSubsum + rightSubsum;
  }

  public int helper(int[] nums, int left, int right) {
    if (left == right) return nums[left];

    int p = (left + right) / 2;

    int leftSum = helper(nums, left, p);
    int rightSum = helper(nums, p + 1, right);
    int crossSum = crossSum(nums, left, right, p);

    return Math.max(Math.max(leftSum, rightSum), crossSum);
  }

  public int maxSubArray(int[] nums) {
    return helper(nums, 0, nums.length - 1);
  }
}

类解决方案{
公共整数交叉和（int[]nums，int左，int右，int p）{
if（left==right）返回nums[左]；
int leftSubsum=Integer.MIN_值；
int currSum=0；
对于（int i=p；i>左-1；--i）{
currSum+=nums[i]；
leftSubsum=Math.max（leftSubsum，currSum）；
}
int rightSubsum=Integer.MIN_值；
currSum=0；
对于（int i=p+1；i

---

工具书类

• 有关其他详细信息，请参见。这里有很多公认的解决方案，有各种解释和解释，有高效的算法，还有渐近/复杂性分析

• 例如，我们希望基于标准和约定（例如，，，，，，，）编写和编写代码

---

我相信，在代码中， LeftSoS<代码>是从向左向右累积的，它不是在中间形成一个连续的最佳总和。在艾玛的回答中提供的解正确地从中间向左和向右迭代，因此找到最佳的和“中间”作为我们的选项之一的考虑。

< P>使用KADAN的算法，在我看来是O（n）：< /P>的最佳方式。

var maxSequence=函数（arr）{
var curr\u max=0，max\u so\u far=0；
对于（var i=0；i

感谢您的详细回复。我将尝试用JS和debug实现这个java解决方案

class Solution:
    def maxSubArray(self, nums):
        for index in range(1, len(nums)):
            if nums[index - 1] > 0:
                nums[index] += nums[index - 1]
        return max(nums)

class Solution {
  public int crossSum(int[] nums, int left, int right, int p) {
    if (left == right) return nums[left];

    int leftSubsum = Integer.MIN_VALUE;
    int currSum = 0;
    for(int i = p; i > left - 1; --i) {
      currSum += nums[i];
      leftSubsum = Math.max(leftSubsum, currSum);
    }

    int rightSubsum = Integer.MIN_VALUE;
    currSum = 0;
    for(int i = p + 1; i < right + 1; ++i) {
      currSum += nums[i];
      rightSubsum = Math.max(rightSubsum, currSum);
    }

    return leftSubsum + rightSubsum;
  }

  public int helper(int[] nums, int left, int right) {
    if (left == right) return nums[left];

    int p = (left + right) / 2;

    int leftSum = helper(nums, left, p);
    int rightSum = helper(nums, p + 1, right);
    int crossSum = crossSum(nums, left, right, p);

    return Math.max(Math.max(leftSum, rightSum), crossSum);
  }

  public int maxSubArray(int[] nums) {
    return helper(nums, 0, nums.length - 1);
  }
}

var maxSequence = function(arr){

  var curr_max = 0, max_so_far = 0;

  for(var i = 0; i < arr.length; i++){  
    curr_max = Math.max(0, curr_max + arr[i]);
    max_so_far = Math.max(curr_max, max_so_far);
  }
  return max_so_far;
}