在 O(nlogn) 时间复杂度中找到总和为 0 的子数组（使用分而治之）？

Question

我在网上看到过解决方案，但所有解决方案都有 O(n) 或 O(n^2) 时间复杂度。我想知道是否可以在不使用辅助数据结构的 O(nlogn) 中找到总和为 0 的子数组。但是，我们可以使用递归。

我们可以修改最大子数组求和算法来解决这个问题吗？

输入数组将只有 1 和 -1，算法将找到总和为 0 的子数组。

输入 = { 1, 1, -1, 1, -1, -1, 1, -1}

output = 1, 8（1 为起始索引，8 为最后索引）

在这种特殊情况下，整个输入数组的和等于 0。因此，报告的开始和结束索引分别为 1 和 8（假设数组中的索引从 1 开始）。

编辑：我们可以使用这个问题的解决方案来解决另一个问题。问题如下。

给定一个包含 n 个整数的数组 arr，找到最长的连续子数组，其中偶数和奇数元素的数量相等。下面是一个例子（索引从 1 开始）：

A = {8, 2, -3, 4, 9, 6}

答案：(2, 5)。 （2 为起始索引，5 为最后索引）

唯一的限制是算法不能使用任何辅助数据结构。在这种约束下，解决方案必须是最有效的。此外，允许使用递归。

Answer 1

您可以使用递归算法，其中函数获取前一个数组值（如果有）的值，然后从输入数组中读取下一个值。如果它是相同的值，那么它会递归地调用自己，当从那里返回时，它会以相同的方式继续下一个值。如果它是相反的值，它会返回给调用者true——表明存在一个零和。如果遇到数组末尾，函数返回false。

这实际上意味着递归的深度等于绝对累积和。因此，例如，如果数组是 [-1, -1, -1, 1]，则递归将进入深度 3，它将从第 3 级返回到第 2 级，返回值 true。在第 2 级，它将返回 false，因为遇到数组的末尾，因此它将退出递归。

只要返回值为true，您就可以检查所覆盖的区间是否比目前遇到的更大。

这是这个想法在 JavaScript 中的实现：

function zeroSum(arr) {
  let i = 0; // index in the input array, managed outside of recursion
  // Longest zero-sum interval so far. Zero based, and value at end index 
  //   is not part of the interval:
  let longest = [0, 0];

  function recur(dir) { // dir is the previous value from the array (if any)
    let start = i; // local variable
    while (i < arr.length) {
      let val = arr[i++];
      if (val == -dir) return true; // zero sum
      if (recur(val) && i - start > longest[1] - longest[0]) {
        longest[0] = start;
        longest[1] = i;
      }
    }
    return false; // no zero sum
  }

  recur(0); // 0 is passed to indicate there is no previous value
  return longest;
}

// demo
console.log(zeroSum([1, 1, -1, 1, -1, -1, 1, -1]));