从斐波那契数列看递归和动态计划

赫赫有名的斐波那契数列:0,1,1,2,3,5,8,13,21...运用数学归纳法能够看出其规律为:f(n) = f(n-1) + f(n-2)

递归

下面起首直接运用递归(JavaScript完成)来求解第 n 项:f(n)

// 直接运用递归
let num = 0;    // 用来纪录fib函数实行次数,实行一次加一
function fib(n) {
  num ++;
  if(n === 0) {
    return 0;
  }
  if(n === 1) {
    return 1;
  }
  return fib(n-1) + fib(n-2);
}

console.time("time used");
console.log(`result is: ${fib(40)}`);
console.log(`fib() runned ${num} times`);
console.timeEnd("time used");

以 n = 40 为例,这里我们纪录了 fib 函数统共挪用的次数以及运算统共耗时,效果以下:

《从斐波那契数列看递归和动态计划》

能够看出,即使仅仅是盘算第 40 项,fib 函数挪用的次数高达3亿屡次,时候是2477ms。由于每一次 fib 函数的挪用都邑有两个子 fib 函数挪用,那末时候复杂度是 O(2^n) ,呈指数级增进,这明显不是一个好算法。怎样优化呢?以一个简朴的例子绘图剖析一下:

《从斐波那契数列看递归和动态计划》

上图是 n = 5 时的递归树,能够看出虚线框中 f(2) 的盘算用到了三次,一样的 f(3) 的盘算用到了两次,明显我们实行了异常多的反复运算。那末很天然的想到,把每个状况的盘算效果都存起来,背面碰到雷同的状况就能够直接运用了。

影象化搜刮递归(自顶向下)

代码以下,这里第三行 new 了一个长度为 n+1 的数组,用于寄存 f(0) 到 f(n) 这 n+1 个状况的盘算效果:

// 影象化搜刮,纪录每次盘算的效果
let num = 0; // 用来纪录fib函数实行次数,实行一次加一
let totalnum = 40;
let memory = new Array(totalnum).fill(-1);
function fib(n) {
  num++;
  if(n === 0) {
    return 0;
  }
  if(n === 1) {
    return 1;
  }
  if(memory[n] === -1) {
    memory[n] = fib(n-1) + fib(n-2);  // 假如前面已取得,直接运用
  } 
  return memory[n];
}

console.time("timer");
console.log(`result is: ${fib(totalnum)}`);
console.log(`fib() runned ${num} times`);
console.timeEnd("timer");

一样 n = 40,效果以下:

《从斐波那契数列看递归和动态计划》

能够看处出优化是非常可观的,纪录下每一次子挪用的效果,让算法复杂度从 O(2^n) 变成了 O(n)。这实在就是动态计划的头脑。什么是动态计划?

Dynamic programming is when you use past knowledge to make solving a future problem easier.(动态计划是用已知项去更好的求解未知项)

Dynamic programming is a technique used to avoid computing multiple time the same subproblem in a recursive algorithm.

将原题目拆解成多少子题目,同时保留子题目的答案,使得每个子题目只求解一次,终究取得原题目的答案。

以上是我看到的两个很好的定义。影象化搜刮递归求斐波那契数列明显是运用了动态计划的头脑,而且,这是一种自顶向下的求解体式格局(我们没有从最基本的题目最先求解,关于 f(n) = f(n-1) + f(n-2) ,先假定 f(n-1) f(n-2) 是已知的)。别的我们能够采纳另一种自下向上的体式格局求解,即迭代,这也是一种动态计划的头脑。

迭代法(自下向上)

代码以下,我们运用迭代,f(2) = f(1) + f(0),f(3) = f(2) + f(1),...,明显这是一种从基本题目最先的自下向上的解决要领:

let num = 0;
function fib(n) {
  num++;
  let memory = new Array(n);
  memory[0] = 1;
  memory[1] = 1;
  for(let i = 2; i <= n; i++) {
    memory[i] = memory[i-1] + memory[i-2];  
  }
  return memory[n];
}

console.time("timer");
console.log(`result is: ${fib(40)}`);
console.log(`fib() runned ${num} times`);
console.timeEnd("timer");

效果以下,明显运用迭代的要领复杂度也为 O(n):

《从斐波那契数列看递归和动态计划》

小结

动态计划就是:将原题目拆解成多少子题目,同时保留子题目的答案,使得每个子题目只求解一次,终究取得原题目的答案。关于斐波那契数列的求解,有自顶向下的影象化搜刮递归和自下向上的迭代法,他们都运用了动态计划的头脑。

参考链接:
https://stackoverflow.com/que…

    原文作者:Leon
    原文地址: https://segmentfault.com/a/1190000015489981
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注