特定函数 big-O 的时间复杂度答案

【问题标题】：Time complexity of a specific function big-O特定函数 big-O 的时间复杂度
【发布时间】：2017-02-12 22:30:12
【问题描述】：

如果之前已经回答过，我提前道歉。

我了解以下代码的时间复杂度为O(n!)：

void permutations(int n){
  if(n!=0){
    for(int i=0; i<n; i++){
      permutations(n-1);
    }//for
  }//if
}//permutations

我也明白以下代码的时间复杂度是O(2^n)：

void permutations(int n){
  if(n!=0){
    permutations(n-1);
    permutations(n-1);
  }//if
}//permutations

但是我无法确定以下代码的复杂性，我怀疑它是 O((n^2)*(n!))，但我不确定是否如此是正确的。如果有人能解释我是否正确，以及为什么，我将不胜感激。

void permutations(int n){
  if(n!=0){
    for(int i=0; i<n; i++){
      permutations(n-1);
      permutations(n-1);
    }//for
  }//if
}//permutations

【问题讨论】：

你做了什么来尝试解决这个问题？
看看递归树：在O(n!) 版本中，每次循环迭代分支一次，现在分支两次......
permutations(0) 的调用次数为 f(n) = 2n * f(n - 1) = 2^n * n!。如果 n^2 你的意思是 2^n，那么是的，你是对的。

标签： time-complexity big-o

【解决方案1】：

我相信你打错了，意思是 O((2^n)*(n!))，这就是答案。

外行的方法：

不做证明（我自己有点生疏），考虑n=4：

在 n=4 时，我们循环 4 次，每次迭代调用 permutations(3) 两次。所以总共 4 x 2 = 8 次调用。
在 n=3 时，我们循环 3 次，每次迭代调用 permutations(2) 两次，但在 n=4 时，我们进行了 8 次这样的调用。所以总共 3 x 2 x 8 = 48 次调用。
在 n=2 时，我们循环 2 次，每次迭代调用 permutations(1) 两次，但在 n=3 时，我们进行了 48 次这样的调用。所以总共有 2 x 2 x 48 = 192 次调用。
在 n=1 时，我们循环 1 次，每次迭代调用 permutations(0) 两次，但在 n=2 时，我们进行了 192 次这样的调用。所以总共 1 x 2 x 192 = 384 次调用。
我们不关心 n=0，因为这是基本情况。

检查递归的增长情况，我们有一个调用 permutations(4) 增长到 384 个调用。从这个图倒推：

384 == 1 x 2 x 192
1 x 2 (2 x 2 x 48)
...
1 x 2 x (2 x 2 x (3 x 2 x (4 x 2)))
2 x 2 x 2 x 2 x 4 x 3 x 2 x 1
2^4 x 4！

看起来我们可以推断它是O((2^n)*(n!))。

解决重复关系：

现在我已经修改了使用杜克大学的Big-Oh for Recursive Functions: Recurrence Relations 解决递归关系，并调整了该问题的方法：

令 T(n) 为执行 permutations(n) 的时间，并且 T(0) = 1。
我们知道 T(n) = n x 2 x T(n-1)
- 这是因为循环 n 次，执行 permutations(n-1) 两次。
T(n) = n x 2 x ((n-1) x 2 x T(n-2))
T(n) = n x 2 x ((n-1) x 2 x ((n-2) x 2 x T(n-3)))
因此，我们可以将这对于 k 扩展推广为 T(n) = 2^k * k！
- 我们可以观察到因子 n、n-1、n-2、...、1（在基本情况下），这是因子分量 (k!)。
- 在每次展开时，我们都有额外的因子 2，即 2^k。
因为基本情况是 n=0，所以我们有 k=n

因此 O((2^n)*(n!)).

【讨论】：