动态规划降低空间复杂度例题及简化
爬楼梯
题目描述
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例:
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
- 1 阶 + 1 阶 + 1 阶
- 1 阶 + 2 阶
- 2 阶 + 1 阶
解题代码
var climbStairs = function(n) {const dp = new Array(n+1);dp[1] = 1;dp[2] = 2;for(let i=3; i<=n; i++){dp[i] = dp[i-1] +dp[i-2];}return dp[n];
};
思路分析
dp数组代表要爬i个台阶的爬法有dp[i]个
要爬i 阶台阶,也就是求解dp[i]可以视为两种情况:
第一种:最后一步爬一个台阶,那么前i-1个台阶的爬法个数等于dp[i-1].
第二种:最后一步爬两个台阶,那么前i-2个台阶的爬法个数等于dp[i-2].
两种情况相加:dp[i] = dp[i-1] +dp[i-2];
此时时间复杂度和空间复杂度都是O(n),能不能优化呢?
我们可以注意到,其实每一步用到的数据都只有数组中的前两项,也就是说之前的就没用了,那么我们可以直接用dp2代替dp[i],用dp1代替dp[i-1],用dp0代替dp[i-2],就可以把空间复杂度降到O(1),如下:
优化后的代码
var climbStairs = function(n) {let dp0 = 0, dp1 = 1, dp2 = 0;for(let i=1; i<=n; i++){dp2 = dp1 +dp0;dp0 = dp1;dp1 = dp2;}return dp1;
};零钱兑换
题目描述
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。
示例 ：
输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1
解题代码
var coinChange = function (coins, amount) {const n = coins.length;let dp = Array.from({length:n+1}, ()=>Array(amount+1).fill(Infinity));dp[0][0] = 0;for (let i = 0; i < n; i++) {for (let j = 0; j <= amount; j++) {if (j >= coins[i]) {dp[i + 1][j] = Math.min(dp[i][j], dp[i + 1][j - coins[i]] + 1);} else {dp[i + 1][j] = dp[i][j]}}}return dp[n][amount] < Infinity ? dp[n][amount] : -1;};
思路分析
dp数组表示目前有coins[0]到coins[i]这些面额的硬币可以选,需要凑够j这么多钱,所需的最少的硬币个数为dp[i+1][j]
为什么是
dp[i+1][j]而不是dp[i][j]的原因是为了更好地处理边界,我们不想遇到要计算dp[i-1]的情况.
那么当i++,会有的情况:
情况一: j < coins[i], 也就是要凑够的钱比新加进来的面额还小, 那这个新加进来的coins[i]就没有用,于是dp[i + 1][j] = dp[i][j]
情况二: j >= coins[i], 此时又会分成两种情况:
1.1 不选择新加进来的coins[i],于是dp[i + 1][j] = dp[i][j]
1.2 选择新加进来的coins[i],于是要凑够的钱j - coins[i], 选择的硬币数量+1, dp[i + 1][j] = dp[i + 1][j - coins[i]] + 1
从这两种情况中选出硬币数较小的即可.
请注意,如果最终答案应该是凑不够,就意味着两件事:
- 硬币面额数种类还不够多,那么将这个面额种类数逐步减少也必然是凑不够的,也就是说
dp[i][amount]的值始终是Infinity,没有被覆盖过 - 如果从需要凑的钱
amount中减去某一个拥有的面额硬币,得到的amount-coins[i]也是凑不出来的,也就是说dp[i + 1][j - coins[i]]的值也是Infinity,没有被覆盖过
由此得到dp[i + 1][j] = Infinity,所以如果dp[n][amount]为Infinity,应该输出的答案就是-1
此时时间复杂度和空间复杂度都是O(n*amount), 开始考虑优化问题.
注意到dp[i + 1][j]其实只跟dp[i][j]和dp[i + 1][j - coins[i]]有关系
那我们不妨就原地修改,选择dp[i][j]和dp[i + 1][j - coins[i]]中的较小值直接覆盖地写在dp[i][j]上,每一个都这样写的话, 就会发现dp[i + 1][j - coins[i]]也就是之前的某个节点被覆盖在dp[i][j - coins[i]]上的值.
所以我们可以直接去掉一个维度i,得到dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1), 空间复杂度就会降低到O(amount)
注意此时为了避免判断是否有 j >= coins[i], j可以每次从coins[i]开始循环.
优化后的代码
var coinChange = function (coins, amount) {const n = amount + 1;let dp = Array(n).fill(Infinity);dp[0] = 0;for (let coin of coins) {for (let j = coin; j < n; j++) {dp[j] = Math.min(dp[j], dp[j - coin] + 1);}}return dp[n-1] < Infinity ? dp[n-1] : -1;
};