js动态规划算法入门级教程，斐波那契数列的解法

一、什么是动态规划？

以下为百度百科的定义：

动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。

在现实生活中，有一类活动的过程，由于它的特殊性，可将过程分成若干个互相联系的阶段，在它的每一阶段都需要作出决策，从而使整个过程达到最好的活动效果。因此各个阶段决策的选取不能任意确定，它依赖于当前面临的状态，又影响以后的发展。当各个阶段决策确定后，就组成一个决策序列，因而也就确定了整个过程的一条活动路线。这种把一个问题看作是一个前后关联具有链状结构的多阶段过程就称为多阶段决策过程，这种问题称为多阶段决策问题。在多阶段决策问题中，各个阶段采取的决策，一般来说是与时间有关的，决策依赖于当前状态，又随即引起状态的转移，一个决策序列就是在变化的状态中产生出来的，故有“动态”的含义，称这种解决多阶段决策最优化的过程为动态规划方法。

上面文字引用自 深入浅出理解动态规划 | 交叠子问题与最优子结构 这篇文章。

动态规划的三个特征：

1. 最优子结构
   最优子结构指的是，问题的最优解包含子问题的最优解。反过来说就是，我们可以通过子问题的最优解，推导出问题的最优解。我们也可以理解为，后面阶段的状态可以通过前面状态推导出来。
2. 无后效性
   无后效性，有两层含义，第一层含义是，在推导后面阶段状态的时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步步推导出来的。第二层含义是，某阶段状态一旦确定，就不受之后阶段的决策影响。
3. 重复子问题
   不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态，也就会产生重复的解。

动态规划求解的问题，经分解得到的子问题往往是相互关联的。即下一个子问题的解是建立在上一个子问题求解的基础上。就比如求值5，5=2+3，想要求的5的解，先要知道2的解与3的解，即2与3是怎么得来的，即 2=1+1; 3=1+2 递推而来，有了2与3才能求出5。

接下来，我们使用 斐波那契数列 来举例说明。

二、什么是斐波那契数列？

斐波那契数列（Fibonacci sequence），又称黄金分割数列。斐波纳契数列以如下被以递归的方法定义：F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)（n≥2，n∈N*）；这个数列从第三项开始，每一项都等于前两项之和。

1、递归解法

斐波那契数列的解法想必大家都知道，最简单粗暴的解法就是递归。

function fib(n){
	if ( n < 2) return n;  // 边界条件 F(0)=0，F(1)=1
	return fib(n-1) + fib(n-2);
}
let result = fib(10);
console.log(result); // 55

虽然使用递归的方式简单易懂，但是却不推荐这种做法，因为对于性能消耗太大，当数量级增长到一定程度时，前端会直接卡爆浏览器，后端的话或许会直接让服务器宕机。而且使用递归的方式，渐进时间复杂度为 O(2ⁿ)，指数级在时间复杂度的量级中非常高，如果能优化，绝对要优化。

时间复杂度 由简单到复杂：

n	O(1) 常数阶	O(logn) 对数阶	O(n) 线性阶	O(nlogn) 线性对数阶	O(n²) 平方阶	O(n³) 立方阶	O(2ⁿ) 指数阶	O(n!) 阶乘阶
1	1	0	1	0	1	1	2	1
2	1	1	2	2	4	8	4	2
4	1	2	4	8	16	64	16	24
8	1	3	8	24	64	512	256	40320
16	1	4	16	64	256	4096	65536	2.0923E+13
32	1	5	32	160	1024	32768	4.295E+09	2.6313E+35

2、动态规划解法

使用递归的解法会有许多重复的子项被计算，以求 fib(10) 为例，如下图：

递归会将之前已经计算过的子项在其他子项中重新计算，如上面的 fib(7)，fib(7) 里面的所有子项也会被一层一层重新计算，这就是递归为什么损耗性能。既然已经计算过了，为什么我们不能在计算第一遍的时候直接存储，再次遇到直接拿来用呢？

这时候动态规划的思想就用上了，动态规划是自底向上的，而递归是自上而下的。

那如何自底向上呢？

我们知道 F(0)=0、F(1)=1；定义一个数组，里面已经存在两项 let arr = [0, 1]；这时候我们可以求出第3项的值为arr[2]=arr[0]+arr[1]；最后数组的结果为 arr = [0, 1, 1]，这时候有了第2项与第3项的结果，我们又可以求出第4项的结果；如此循环，直到求出最终结果。

动态规划代码：

function fib(n) {
	const arr = [0, 1];
	if (n < 2) return n;
	 // 索引从0开始，i=2时求第3项的值。 求F(n)，要计算n；所以要 i<=n
	for (let i = 2; i <= n; i++){
		arr[i] = arr[i-1] + arr[i-2];
	}
	// 打印 F(10)数列
	console.log(arr); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
	return arr[arr.length-1];
}
let result = fib(10);
console.log(result);  // 55

动态规划的 斐波那契数列 的时间复杂度为 O(n)；比递归的 O(2ⁿ) 不知道强了多少倍！我们可以使用 console.time() 以及 console.timeEnd() 来计算一下两段程序所耗时间：

console.time();
console.log("递归：")
function fib(n){
	if ( n < 2) return n;
	return fib(n-1) + fib(n-2);
}
let result = fib(30);
console.log(result);
console.timeEnd();

console.time();
console.log("动态规划：")
function fibDP(n) {
	const arr = [0, 1];
	if (n < 2) return n;
	for (let i = 2; i <= n; i++){
		arr[i] = arr[i-1] + arr[i-2];
	}
	return arr[arr.length-1];
}
let resultDP = fibDP(30);
console.log(resultDP);
console.timeEnd();