记忆算法时间复杂度

Question

看了这篇Retiring a Great Interview Problem的文章，作者想出了一个work break的问题，给出了三个解决方案。高效的使用memoization算法，作者说它的最坏情况时间复杂度是O(n^2)，因为the key insight is that SegmentString is only called on suffixes of the original input string, and that there are only O(n) suffixes。

但是，我很难理解为什么是O(n^2)。有人可以给我一个提示或证据吗？

Work Break Problem: 
    Given an input string and a dictionary of words,
    segment the input string into a space-separated
    sequence of dictionary words if possible. For
    example, if the input string is "applepie" and
    dictionary contains a standard set of English words,
    then we would return the string "apple pie" as output.

记忆算法来自 Retiring a Great Interview Problem

Map<String, String> memoized;

String SegmentString(String input, Set<String> dict) {
      if (dict.contains(input)) 
          return input;
      if (memoized.containsKey(input) {
          return memoized.get(input);
      }
      int len = input.length();
      for (int i = 1; i < len; i++) {
          String prefix = input.substring(0, i);
          if (dict.contains(prefix)) {
              String suffix = input.substring(i, len);
              String segSuffix = SegmentString(suffix, dict);
              if (segSuffix != null) {
                  return prefix + " " + segSuffix;
              }
          }
      }
      memoized.put(input, null);
      return null;
}

Answer 1

一般来说，记忆表的维度决定了复杂性。

对于只有 1 维的记忆表 (memoized[n]) -> 需要 O(n) 复杂度， 对于只有 2 维的记忆表 (memoized[n][n]) -> 需要 O(n^2) 复杂度 等等。

原因： 在记忆的情况下，最坏情况的复杂性是输入的运行时间，其中没有一个情况（重叠的子问题）尚未缓存（预先计算）。

现在，假设 memoization 表有 2 个维度（memoization[n][n]）。最坏情况复杂度只能是记忆表的最大维度。因此，其最坏的情况只能达到 O(n^2)。

因此，Memoization 表的维度基本上决定了最坏情况的时间复杂度。

@shx2 的答案以数学方式解释了这一点。

Answer 2

直觉

（很明显，最坏的情况是没有解决方案的情况，所以我专注于此）

由于递归调用是在将值放入记忆缓存之前进行的，因此最后一个（最短的）后缀将首先被缓存。这是因为函数首先用长度为 N 的字符串调用，然后用长度为 N-1 的字符串调用自身，然后 .... ，用 len 0 的字符串，被缓存并返回，然后长度为1的字符串被缓存并返回，...，长度为N的字符串被缓存并返回。

正如提示所暗示的，只有后缀被缓存，并且只有 N 个。这意味着当顶级函数获得其第一次递归调用的结果时（即在长度为N-1 的后缀上），缓存中已经填充了N-1 个后缀。

现在，假设 N-1 个最后的后缀已经被缓存，for 循环需要进行 N-1 个递归调用，每个调用 O(1)（因为答案已经被缓存），总计 O(N)。但是，（预）构建最后 N-1 的缓存需要 O(N^2)（解释如下），总计 O(N)+O(N^2) = O(N^2)。

---

数学归纳证明

这个解释可以很容易地转化为使用归纳法的正式证明。这是它的要点：

（f(N) 是函数在长度为 N 的输入上完成所需的操作数）

归纳假设——存在一个常数c s.t. f(N) < c*N^2。

基本情况很简单——对于长度为 1 的字符串，您可以找到一个常量 c 使得 f(1) < c*N^2 = c

诱导步骤

回顾事情发生的顺序：

第 1 步：函数首先在长度为 N-1 的后缀上调用自身，构建一个缓存，其中包含最后 N-1 个后缀的答案

第 2 步：然后函数调用自身 O(N) 多次，每次花费 O(1)（感谢此测试：if (memoized.containsKey(input))，以及缓存已在第 1 步中填充的事实）。

所以我们得到：

f(N+1) = f(N) + a*N <   (by the hypothesis)
       < c*N^2 + a*N <  (for c large enough)
       < c*N^2 + 2*c*N + c =
       = c*(N+1)^2

因此我们得到了f(N+1) < c*(N+1)^2，这就完成了证明。

Answer 3

首先，对于一个长度为N的字符串，我们可以将它分成N*(N-1)/2段，并检查每个段是否包含在字典中。这个成本是 O(N^2)

回到你的代码，从字符串 N 开始，我们把它分解成两个更小的字符串，长度 'a' 和 'N - a' .而对于每个从 0 开始到 'a' 结束的子字符串（或前缀），我们只检查一次！

从每个段 N - a 中，它也会检查它的每个前缀并将其存储到记忆表中，所以，这一步将确保下一次，当我们做同样的事情时移动，在这个确切的位置拆分字符串，我们只需要返回结果，无需进一步工作（假设地图将在 O(1) 中检索并返回特定字符串的结果）。这个存储和检索步骤还确保征服和分割只进行一次。

因此，在第一点和第二点之后，我们得出结论，只有一次需要检查 N*(N - 1)/2 段，这导致成本是 O(N^2)

注意：仅假设 两者的成本 dict.contains(input) 和 memoized.containsKey(input) 是 O(1) 所以复杂度是 O(N^2)。

Answer 4

如果输入的长度为 N，那么它可以包含的最大字典单词数将是 N。因此您需要检查长度为 1..N 的所有不同组合。即 N(N-1)/2

获取输入字符串 aaaaa

有 N x 'a' 个字符串

N-1 'aa' 字符串

等等