连续子数组。 有比 O(n^2) 更好的解决方案吗？

Question

我正在解决以下问题：

给你一个包含 N 个整数的数组 arr。 对于每个索引 i，您需要确定满足以下条件的连续子数组的数量：

1. 索引 i 处的值必须是连续子数组中的最大元素，并且
2. 这些连续的子数组必须从 i 开始或以 i 结束。

输入：数组 arr 是范围在 1 到 1,000,000,000 之间的唯一整数的非空列表，大小 N 介于 1 和 1,000,000 之间

Output：一个数组，其中每个索引 i 包含一个 integer，表示 arr[i] 的连续子数组的最大数量

示例：arr = [3, 4, 1, 6, 2] output = [1, 3, 1, 5, 1]

我有以下天真的 O( n ² ) 解决方案：

  int[] countSubarrays(int[] arr) {
  int len = arr.length;
  int[] output = new int[arr.length];
  
  for (int i = 0; i < len; i++) { 
    output[i] = 1;
    
    // move right
    for (int j = i + 1; j < len; j++) {
      if (arr[i] <= arr[j]) {
        break;
      }
      output[i]++;
    }
    
    // move left
    for (int j = i - 1; j >= 0; j--) {
      if (arr[i] <= arr[j]) {
        break;
      }
      output[i]++;
    }
  }
  
  return output;
}

根据编码平台还有另一种解决方案：

接下来我们可以观察到，第 i 个元素左侧的最新元素的索引大于它决定了哪些以索引 i 结尾的子数组是有效的——特别是从那个较大元素的右侧开始的子数组。 让 G[i] 等于最大索引 j 使得 j < i 并且 a[j] > a[i] （如果没有这样的 j，则等于 0），然后 L[i] = i - G[i ]。 我们现在已经将问题简化为为 N 个不同整数的数组计算这些值 G[1..N]。

为从 1 到 N 的每个 i 计算 G[i] 是一种很有前途的方法，但我们仍然需要考虑如何尽可能高效地这样做。 我们可以观察到，仅仅根据 G[i-1]、a[i-1] 和 a[i] 的值来计算 G[i] 是不可能的； 我们可能还需要有关早期 a 值的更多信息，但希望避免简单地扫描所有这些值。 在较早的索引 j（例如 j < i）中，我们可以考虑哪些索引值得考虑作为 G[i] 的潜在候选者 - 例如，如果存在一对索引 j 和 k 使得 j < k 和 a [j] < a[k]，对于任何 i > k，索引 j 是否可以成为 G[i] 的候选者？ 如果我们可以像 go 那样通过数组维护这些可能的候选索引集的信息，则可以有效地确定每个 i 实际等于 G[i] 的那个。

我无法理解这背后的逻辑。 有什么建议么？

Answer 1

因此，首先，让我们通过仅考虑以最大值结尾的子数组来简化问题。 （可以使用相同的方法找到以最大值开始的子数组，但是从数组的末尾开始并向后工作，而不是从开头开始并向前工作。幸运的是，我们真的不需要担心 double-计算以相等值开始和结束的子数组，因为问题指定所有元素都是不同的，所以唯一这样的子数组是长度为 1 的子数组，我们可以通过从最终答案中减去n轻松处理。）

我从您的代码中看到您已经发现，对于任何给定的索引i ，我们需要找到最大的索引j < i使得A [ j ] > A [ i ]，因为子数组 [( j +1).. i ], [( j +2).. i ], ... [ i .. i ] 正是满足我们条件的子数组。 在您的代码中，您在向后工作时递增output ； 但实际上你可以在循环结束后写output += i - j 。 这意味着，只要我们可以在摊销常数时间内找到j ，我们就可以在 O( n ) 时间内而不是 O( n2 ⁾时间内解决问题。

那么，我们该怎么做呢？ 诀窍是在一个名为G的数组中跟踪我们之前的答案； 例如，如果A是 [10,0,5,3]，那么G将是 [-1,0,0,2]。 （你明白为什么吗？）然后，当我们试图找到G [ i ] 时，我们可以查阅我们已经存储在G [0..( i -1)] 中的值以更快地向后跳转； 代替j-- ，我们可以写j = G[j] 。

对于每个单独的索引i ，仍然可能需要最多n次向后跳转才能找到G [ i ]； 但只有当A [ i ] 大于所有先前的值并且所有先前的值都在减少时才会发生这种情况。 那只能发生一次。 更一般地，跨越所有i值的跳跃总数将为O ( n )，因为我们仅在第一次找到大于A [ j ] 的值时才进行从j到G [ j ] 的跳跃。 （你明白为什么吗？）