javascript动态规划之缓存与递归优化

动态规划的适用性
1.最优子结构
2.无后效性
3.子问题的重叠性

例题：
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

这个问题的最直白的写法就是：

  const numWays = function (n) {
    if (n < 0) {
      return 0n;	//BigInt表示法
    }
    if (n === 0){
      return 1n     //BigInt表示法
    }
    const a1 = numWaysTool(n - 1);
    const a2 = numWaysTool(n - 2);
    return a1 + a2;
  }

这样在n比较小的时候，的确能很快的求解出正确答案，但是在n比较大的时候，由于不断的递归，执行栈上就会push上很多numWays方法，程序需要跑很久才跑得出来。

因此需要优化，首先想到的就是尾调用优化，但无奈这题我抓耳挠腮也没想出来怎么进行尾调用优化。

然后我又想到了缓存，要求跳100个台阶跳法，我就得知道跳99个台阶和跳98个台阶的跳法，然后99又可以拆分为98和97，但是求跳100个台阶的时候就已经求过98了，我现在求跳99个台阶，又要求一次跳98的……………………那么为何不先把98的求出来，再求99个台阶和100个台阶的呢？

所以，代码就变成了下面这样：

const numWays = function (n) {
  const numWaysTool = function (m) {
    if (cache[m]) {
      return cache[m];
    }
    if (m < 0) {
      return 0n;
    }
    const a1 = numWaysTool(m - 1);
    const a2 = numWaysTool(m - 2);
    return cache[i] = (a1 + a2);
  }
  const cache = [1n];
  let i;
  for (i = 0; i <= n; i++) {
    numWaysTool(i);
  }
  return Number(cache[n]);
};

这其实就是一种动态规划的写法，以空间换时间，把子问题的解保存起来。

---

---

---

最后发现，其实这就是一个斐波那契数列，然后再使用尾递归优化，计算效率会更快。

const numWays = function (n) {
  return Number(tool(1n, 1n, BigInt(n)) % BigInt(1e9 + 7));
};
function tool(left, right, total) {
  if (total > 0n) {
    return tool(right, left + right, total - 1n);
  } else {
    return left;
  }
}