字符串排列的时间复杂度

Question

以下示例取自 Cracking the coding interview (version 6) book。 根据本书，以下代码的时间复杂度为 O(n^2 * n!)。 (请参考例子12.第32,33页)

public static void main(String[] args) {
    new PermutationsTest().permutations("ABCD");
}

void permutations(String string) {
    permutations(string, "");
}

static int methodCallCount = 0;

void permutations(String string, String perfix) {


    if (string.length() == 0) {
        System.out.println(perfix);
    } else {
        for (int i = 0; i < string.length(); i++) {
            String rem = string.substring(0, i) + string.substring(i + 1);
            permutations(rem, perfix + string.charAt(i));
        }
    }

    System.out.format("Method call count %s \n", methodCallCount);
    methodCallCount += 1;

}

我发现很难理解它是如何计算的。 以下是我对此的看法。

可以有n！ 安排。 所以应该至少有n！ 调用。 但是，对于每次调用，大约会发生 n 次工作。 （因为它需要遍历传递的字符串）。 那么答案不应该是 O (n * n!) 吗？

但真正发生的是对于每个调用，都需要对 (n-1) 个字符串进行循环。 所以我们可以说它应该是n！ * n(n+1)/2

请解释..

Answer 1

有n! 可能的字符串，但添加到字符串中的每个字符都需要：

String rem = string.substring(0, i) + string.substring(i + 1);
permutations(rem, perfix + string.charAt(i));

substring调用和字符串连接是O(n) 。 对于字符串中的每个字符都是O(n^2)并且对于所有字符串都是O(n^2 * n!) 。

编辑：

我计算了通过串联创建字符串的复杂度为O(n^2)但是乘以字符串的数量是不准确的，因为字符串共享公共前缀，因此那里有很多重复计算。

由于对最终字符串的调用次数远多于其余字符串，因此它们在复杂性中占主导地位，因此它们是唯一需要计算的。 所以我认为我们可以将复杂性降低到O(n * n!) 。

Answer 2

要获得渐近时间复杂度，您需要计算permutations函数被调用的次数以及它的渐近时间复杂度是多少。 答案是这些的产物。

string.length() = len在每次迭代中总是减少 1，因此有1调用len=n ，n 次调用len=n-1 ， n*(n-1)调用len = n-2 ， ……， n! 调用 len = 0。因此，调用总数为：

n!/1! + n!/2! + n!/3! + n!/4! + .. + n!/n! = sum(k=1..n) n!/k!

在渐近极限中，这可以计算：

sum(k=1..n)( n!/k! ) =  n! (-1 + sum(k=0..n) 1/k! (1^k)) -> n! (e^1 - 1) = (e-1)*n!,

即 O((1-e)*n!) = O(n!)。 e是纳皮尔常数2.71828128.. . 为了计算总和，我使用了泰勒级数e^x = sum(k=0..infinity) 1/k! x^k e^x = sum(k=0..infinity) 1/k! x^k在x=1 。

现在对于函数的每次调用都有子字符串和连接操作：

String rem = string.substring(0, i) + string.substring(i + 1);

此操作需要string.length操作的顺序，因为String class需要将每个字符复制到新的 String （ String.length - 1个操作数）。 因此，总复杂度是这两个O(n*n!)的乘积。

为了检查对 perm 的调用是否如我所说，我为排列编写了一个小的c++代码（没有字符串操作，所以它应该是 O(n!) ）`。

#include <iostream>
#include <string>
#include <iomanip>

unsigned long long int permutations = 0;
unsigned long long int calls = 0;

void perm(std::string& str, size_t index){
  ++calls;
  if (index == str.size()-1){
    ++permutations;
    //    std::cout << count << " " << str << std::endl;
  }
  else{
    for (size_t i=index; i < str.size();++i){
      std::swap(str[index],str[i]);
      perm(str,index+1);
      std::swap(str[index],str[i]);
    }
  }
}

int main(){
  std::string alpha="abcdefghijklmnopqrstuvwxyz";
  std::cout << std::setprecision(10);
  for (size_t i=1;i<alpha.size()+1;++i){
    permutations = calls = 0;
    std::string str(alpha.begin(),alpha.begin()+i);
    perm(str,0);
    std::cout << i << " " <<  permutations << " " << calls << " " << static_cast<double>(calls)/permutations << std::endl;
  }
}

输出：

1 1 1 1 
2 2 3 1.5 
3 6 10 1.666666667 
4 24 41 1.708333333
5 120 206 1.716666667
6 720 1237 1.718055556
7 5040 8660 1.718253968
8 40320 69281 1.71827877
9 362880 623530 1.718281526
10 3628800 6235301 1.718281801
11 39916800 68588312 1.718281826
12 479001600 823059745 1.718281828
13 6227020800 10699776686 1.718281828
14 took too long

列是： length of the string = n , n! , sum(k=1..n) n!/k! , 第三列和第二列的比率，应为(e-1)=1.71828182845905 。 所以它似乎很快收敛到渐近极限。

Answer 3

恐怕这本书写错了。 时间复杂度是ϴ(n!n) ，正如在 fgb's answer 中正确推测的那样。

原因如下：

与递归函数一样，我们首先写下递归关系。 在这种情况下，我们必须输入、 string和perfix [原文如此！]。 让我们分别用s和p表示它们的长度：

T(0,p) = p           // println
T(s,p) = s *         // for (int i = 0; i < string.length(); i++)
        (O(s +       // String rem = string.substring(0, i) + string.substring(i + 1);
           p) +      // perfix + string.charAt(i)
        T(s-1,p+1))  // permutations(rem, perfix + string.charAt(i));
       = s*T(s-1,p+1) + O(s(s+p))

但是，请注意

1. s+p始终保持不变，即k是字符串string的原始长度。
2. 当s倒数到 0 时， p也有长度k 。

所以对于特定的k ，我们可以像这样重写递推关系：

T_k(0) = k
T_k(s) = s*T(s-1) + O(ks)

一个好记的规则是形式的递推关系

T(n) = n * T(n-1) + f(n)

有一般的解决方案

T(n) = n! (T(0) + Sum { f(i)/i!, for i=1..n })

在这里应用此规则会产生确切的解决方案

T_k(s) = s! (k + Sum { ki/i!, for i=1..s })
       = s!k (1 + Sum { 1/(i-1)!, for i=1..s })

现在回想一下k是字符串string的原始长度，因此我们实际上只对k = s的情况感兴趣，因此我们可以将这种情况的最终精确解写为

T(s) = s!s (1 + Sum { 1/(i-1)!, for i=1..s })

由于级数Sum { 1/(i-1)!, for i=1..infinity }收敛，我们最终有

T(n) = ϴ(n!n), qed