如何解释缓存的斐波那契算法复杂度

Question

我试图解释正确缓存的斐波那契算法复杂性。这是代码（https://jsfiddle.net/msthhbgy/2/）：

function allFib(n) {
  var memo = [];
  for (var i = 0; i < n; i++) {
    console.log(i + ":" + fib(i, memo))
  }
}

function fib(n, memo) {
  if (n < 0) return 0;
  else if (n === 1) return 1;
  else if (memo[n]) return memo[n];
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
  return memo[n];
}

allFib(5);

解决方案取自“Cracking the coding interview”并改编为javascript。 所以这是一个“不是很好”的函数调用树

我是这样想的：“最左边的分支（粗体）是进行评估的地方”，这绝对是第一次传递给 allFib 函数的数字。所以复杂度是O(n)。右侧的所有内容都将从缓存中获取，并且不需要额外的函数调用“。正确吗？以及如何将其连接到树“理论”。在这种情况下，树的深度和高度为 4，但是不是 5（接近 n 但不是它）。我希望答案不直观但更可靠。

Answer 1

这是一个真正使用缓存的函数：

function Fibonacci() {
  var memo = [0, 1];

  this.callCount = 0;

  this.calc = function(n) {
    this.callCount++;
    return n <= 0 ? 0 
         : memo[n] || (memo[n] = this.calc(n - 1) + this.calc(n - 2));
  }
}

var fib = new Fibonacci();

console.log('15! = ', fib.calc(15));
console.log('calls made: ', fib.callCount);
fib.callCount = 0; // reset counter
console.log('5! = ', fib.calc(5));
console.log('calls made: ', fib.callCount);
fib.callCount = 0;
console.log('18! = ', fib.calc(18));
console.log('calls made: ', fib.callCount);

函数调用次数为：

(n - min(i,n))*2+1

i 是 memo 中的最后一个条目。

您可以通过 n = 18 和 i = 15 的示例看到如下：

调用按以下顺序进行：

calc(18)
calc(17)   // this.calc(n-1) with n=18
calc(16)   // this.calc(n-1) with n=17
calc(15)   // this.calc(n-1) with n=16, this can be returned from memo
calc(14)   // this.calc(n-2) with n=16, this can be returned from memo
calc(15)   // this.calc(n-2) with n=17, this can be returned from memo
calc(16)   // this.calc(n-2) with n=18, this can be returned from memo

一般模式是 this.calc(n-1) 和 this.calc(n-2) 被调用多次（当然），此外还有原始调用 calc(n)。

这是您第一次以fib.calc(5) 调用fib.calc 时的动画。箭头显示进行的调用。越向左，递归越深。当相应的结果存储在 memo 中时，气泡会被着色：

当 i 是给定常数时，这显然是 O(n)。

Answer 2

首先，检查是否为负 n，并将值移至零。

然后检查一个值是否被缓存，取值。如果不是，则将值分配给缓存并返回结果。

对于n === 0或n === 1的特殊情况分配n。

function fibonacci(number) {
    function f(n) {
        return n in cache ?
            cache[n] :
            cache[n] = n === 0 || n === 1 ? n : f(n - 1) + f(n - 2);
    }

    var cache = [];
    return f(number);
}

console.log(fibonacci(15));
console.log(fibonacci(5));

按照Thomas 的建议，在cache 中使用预定义值。

function fibonacci(number) {
    function f(n) {
        return n in cache ?
            cache[n] :
            cache[n] = f(n - 1) + f(n - 2);
    }

    var cache = [0, 1];
    return f(number);
}

console.log(fibonacci(15));
console.log(fibonacci(5));