给你一个整数数组 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
思路:本题中每种硬币的数量是无限的,可以抽象成一道完全背包的问题
动态规划五部曲:
1.确定dp[j]的含义:
dp[j]:装满表示容量为j的物品,最少要几个物品
2.确定递推公式:
1).不放该硬币:dp[j]
2).放该硬币:dp[j-coins[i]]+1
dp[j]=min(dp[j],dp[j-coins[i]]+1)
3.dp数组如何初始化
求最少硬币数,为了防止覆盖,先将dp数组都设为Integer.MAX_VALUE
dp[0]=0;凑成0元只要0个硬币
4.遍历顺序
一层循环遍历物品,一层循环遍历背包容量,哪层循环放外面?
Day44:动态规划 LeedCode 完全背包 518. 零钱兑换 II 377. 组合总和 Ⅳ-CSDN博客这篇文章有讲
由于本题中不同顺序算同一方法,所以应该用遍历背包容量在内层循环,遍历物品在外部循环
5.举例推导
二维数组:
格外注意这些条件:
if(j>=coins[i]&&dp[i][j-coins[i]]!=Integer.MAX_VALUE)
dp[i][j]=Math.min(dp[i-1][j],dp[i][j-coins[i]]+1);
class Solution {
public int coinChange(int[] coins, int amount) {
int[][] dp=new int[coins.length][amount+1];//前i种硬币凑出j的最少硬币个数
for(int i=0;i<dp.length;i++){
Arrays.fill(dp[i],Integer.MAX_VALUE);
}
//初始化
dp[0][0]=0;
for(int i=coins[0];i<=amount;i++){
if(dp[0][i-coins[0]]!=Integer.MAX_VALUE)
dp[0][i]=dp[0][i-coins[0]]+1;
}
for(int i=1;i<coins.length;i++){
for(int j=0;j<=amount;j++){
if(j>=coins[i]&&dp[i][j-coins[i]]!=Integer.MAX_VALUE)
dp[i][j]=Math.min(dp[i-1][j],dp[i][j-coins[i]]+1);
else{
dp[i][j]=dp[i-1][j];
}
}
}
return dp[coins.length-1][amount]==Integer.MAX_VALUE?-1:dp[coins.length-1][amount];
}
}
一维数组:
class Solution {
public int coinChange(int[] coins, int amount) {
int[] dp=new int[amount+1];//dp[i]凑成i最少多少种方法
Arrays.fill(dp,Integer.MAX_VALUE);
dp[0]=0;
for(int i=0;i<coins.length;i++){
for(int j=coins[i];j<=amount;j++){
if(dp[j-coins[i]]!=Integer.MAX_VALUE)
dp[j]=Math.min(dp[j],dp[j-coins[i]]+1);
}
}
return dp[amount]==Integer.MAX_VALUE?-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
思考:
本题和上一题类似,转化为完全背包问题
1.确定dp[j]的含义:
dp[j]:装满表示容量为j的物品,最少要几个物品
凑成整数n,至少需要几个完全平方数
2.确定递推公式:
1).不放i*i:dp[j]
2).放i*i:dp[j-i*i]+1
dp[j]=min(dp[j],dp[j-i*i]+1)
3.dp数组如何初始化
求最少完全平方数,为了防止覆盖,先将dp数组都设为Integer.MAX_VALUE
dp[0]=0;凑成0只要0个完全平方数
4.遍历顺序
一层循环遍历物品,一层循环遍历背包容量,哪层循环放外面?
Day44:动态规划 LeedCode 完全背包 518. 零钱兑换 II 377. 组合总和 Ⅳ-CSDN博客这篇文章有讲
由于本题中不同顺序算同一方法,所以应该用遍历背包容量在内层循环,遍历物品在外部循环
5.举例推导
代码参考:
由于本题一定能凑出目标数,所以不需要判断dp[j-i*i]是否等于Integer.MAX_VALUE
class Solution {
public int numSquares(int n) {
int[] dp=new int[n+1];
Arrays.fill(dp,Integer.MAX_VALUE);
dp[0]=0;
for(int i=1;i*i<=n;i++){
for(int j=i*i;j<=n;j++){
if(dp[j-i*i]!=Integer.MAX_VALUE)
dp[j]=Math.min(dp[j],dp[j-i*i]+1);
}
}
return dp[n];
}
}
给你一个字符串 s
和一个字符串列表 wordDict
作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s
则返回 true
。
注意:不要求字典中出现的单词全部都使用,并且字典中的单词可以重复使用。
示例 1:
输入: s = "leetcode", wordDict = ["leet", "code"] 输出: true 解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
示例 2:
输入: s = "applepenapple", wordDict = ["apple", "pen"] 输出: true 解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。 注意,你可以重复使用字典中的单词。
示例 3:
输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"] 输出: false
提示:
1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s
和wordDict[i]
仅由小写英文字母组成wordDict
中的所有字符串 互不相同
思路:
本题可转化为完全背包问题,单词就是物品,字符串s就是背包,单词能否组成字符串s,就是问物品能不能把背包装满。
动态规划五部曲:
1.确定下标i与dp[j]的含义
dp[i];表示字符串长度为i时,是否可拆分为一个或多个在字典中出现的单词
2.确定递推公式
如果确定dp[j] 是true,且 [j, i) 这个区间的子串出现在字典里,那么dp[i]一定是true。(j < i )。
所以递推公式是 if(dp[j]&&[j, i) 这个区间的子串出现在字典里) dp[i]=true;
3.初始化
dp[0]就是递推的根基,dp[0]一定要为true,否则递推下去后面都都是false
下标非0的dp[i]初始化为false
4.确定遍历顺序
如果求组合数就是外层for循环遍历物品,内层for遍历背包。
如果求排列数就是外层for遍历背包,内层for循环遍历物品。
本题是求排列,不同顺序算不同情况
5.举例
代码参考:
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
boolean[] dp = new boolean[s.length()+1];//dp[i]在[0,i)这个区间内,是否为true
//初始化
dp[0]=true;
for(int i=1;i<=s.length();i++){
for(int j=0;j<i;j++){
if(wordDict.contains(s.substring(j,i))&&dp[j]){
dp[i]=true;
}
}
}
return dp[s.length()];
}
}
回溯法:
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
return backTracking(0,s,wordDict);
}
public boolean backTracking(int stardIndex,String s,List<String> wordDict){
if(stardIndex>=s.length()){
return true;
}
for(int i=stardIndex+1;i<=s.length();i++){
String temp= s.substring(stardIndex,i);
if(wordDict.contains(temp)&&backTracking(i,s,wordDict)){
return true;
}
}
return false;
}
}
上一种方法超时
回溯法优化:记忆化搜索,使用memory数组保存每次计算的以startIndex起始的计算结果,如果memory[startIndex]里已经被赋值了,直接用memory[startIndex]的结果。
class Solution {
int[] memory;
public boolean wordBreak(String s, List<String> wordDict) {
memory=new int[s.length()+1];
return backTracking(0,s,wordDict);
}
public boolean backTracking(int stardIndex,String s,List<String> wordDict){
if(stardIndex>=s.length()){
return true;
}
if(memory[stardIndex]==-1) return false;
for(int i=stardIndex+1;i<=s.length();i++){
String temp= s.substring(stardIndex,i);
if(wordDict.contains(temp)&&backTracking(i,s,wordDict)){
return true;
}
}
memory[stardIndex]=-1;
return false;
}
}
背包问题总结:
1.
01背包:
二维dp数组01背包先遍历物品还是先遍历背包都是可以的,如果先遍历容量则第二层for循环是从小到大遍历
一维dp数组01背包只能先遍历物品再遍历背包容量,且第二层for循环是从大到小遍历。
2.
完全背包
与01背包不同之处在于物品可无限取
内层循环一定是从小到大遍历的
纯完全背包,先遍历物品还是先遍历背包都是可以的
变形完全背包
求组合数(换零钱):先遍历物品
求排列数(组合总和IV):先遍历容量
求最小数:
为了防止覆盖,先将dp数组都设为Integer.MAX_VALUE