假设你正在爬楼梯。需要 n
阶你才能到达楼顶。
每次你可以爬 1
或 2
个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2 输出:2 解释:有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶
示例 2:
输入:n = 3 输出:3 解释:有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶
提示:
1 <= n <= 45
这题之前做过,就是一个简单的动规问题。但如果问题延伸一下,每次还可以跨 3 个,甚至更多台阶呢?显然就是一个完全背包问题了,问爬到楼顶有几种方法其实就是问装满背包有几种方法。
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n + 1];
int[] weight = {1,2};
dp[0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < weight.length; j++) {
if (i >= weight[j]) dp[i] += dp[i - weight[j]];
}
}
return dp[n];
}
}
这里提供了原题中只能爬 1 或 2 个台阶的情况。如果能爬 m 或 其以内的台阶数,则只需设置 weight 的值为 [1, 2, 3, , m] 。
给你一个整数数组 coins
,表示不同面额的硬币;以及一个整数 amount
,表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额,返回 -1
。
你可以认为每种硬币的数量是无限的。
示例 1:
输入:coins = [1, 2, 5], amount = 11 输出:3 解释:11 = 5 + 5 + 1
示例 2:
输入:coins = [2], amount = 3 输出:-1
示例 3:
输入:coins = [1], amount = 0 输出:0
提示:
1 <= coins.length <= 12
1 <= coins[i] <= 231 - 1
0 <= amount <= 104
本题 dp[j] 为凑足总额 j 所需的最少硬币个数,递推公式推导需要考虑凑足总额为j - coins[i]的最少个数为dp[j - coins[i]],加上一个coins[i]后个数+1。初始化,凑足金额 0 需要 0 个硬币。遍历顺序,由于求的是最少硬币个数,顺序不顺序的不重要,先遍历物品还是先遍历背包都可以。
class Solution {
public int coinChange(int[] coins, int amount) {
int[] dp = new int[amount + 1];
for (int c = 0; c < dp.length; c++) dp[c] = 10001;
dp[0] = 0;
for (int i = 0; i < coins.length; i++) {
for (int j = coins[i]; // 保证 j - coins[i] ≥ 0
j <= amount; j++) {
if (dp[j - coins[i]] != 10001) {
dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
}
}
}
return dp[amount] == 10001 ? -1 :dp[amount];
}
}
给你一个整数 n
,返回 和为 n
的完全平方数的最少数量 。
完全平方数 是一个整数,其值等于另一个整数的平方;换句话说,其值等于一个整数自乘的积。例如,1
、4
、9
和 16
都是完全平方数,而 3
和 11
不是。
示例 1:
输入:n = 12 输出:3 解释:12 = 4 + 4 + 4
示例 2:
输入:n = 13 输出:2 解释:13 = 4 + 9
提示:
1 <= n <= 104
其实和上题思路一样,只要把硬币的面额全改成完全平方数就行。
class Solution {
public int numSquares(int n) {
int[] dp = new int[n + 1];
int[] sqr = new int[101];
for (int j = 0; j <= n; j++) {
dp[j] = 10001;
}
int count = -1;
for (int i = 1; i * i <= n; i++) {
sqr[++count] = i * i;
}
dp[0] = 0;
for (int i = 0; i <= count; i++) {
for (int j = sqr[i]; j <= n; j++) {
if (dp[j - sqr[i]] != 10001) {
dp[j] = Math.min(dp[j], dp[j - sqr[i]] + 1);
}
}
}
return dp[n];
}
}