代码随想录算法训练营第四十五天 _ 动态规划_ 70. 爬楼梯、322.零钱兑换、279.完全平方数、139.单词拆分。

学习目标：

动态规划五部曲：
① 确定dp[i]的含义
② 求递推公式
③ dp数组如何初始化
④ 确定遍历顺序
⑤ 打印递归数组 ---- 调试
引用自代码随想录！

60天训练营打卡计划！

学习内容：

70. 爬楼梯

动态规划五步曲：
① 确定dp[j]的含义：容量为j的背包可以放dp[j]种排列
② 求递推公式： dp[j] += dp[j-i]; （排列问题的标准递推公式！）
③ dp数组如何初始化： dp[0] = 1
④ 确定遍历顺序：排列问题！先遍历背包，再遍历物品！

class Solution {// 使用完全背包再做！// 是一种排列问题！// 先遍历背包，再遍历物品！public int climbStairs(int n) {// dp数组的含义是：容量为j的背包可以放dp[j]种排列int[] dp = new int[n + 1];// 初始化dp[0] = 1;// 递归逻辑for(int j = 1; j <= n; j++){for(int i = 1; i <= 2 && j >= i; i++){dp[j] += dp[j-i];}}return dp[n];}
}

322.零钱兑换

动态规划五步曲：
① 确定dp[j]的含义：装满容量为i的背包，最少的物品数量dp[j]
② 求递推公式： dp[j] = min(dp[j-coins[i]]+1, dp[j])
③ dp数组如何初始化： dp[0] = 0 其他的都是Integer.MAX_VALUE
④ 确定遍历顺序：都可以，因为不管是排列还是组合，元素的个数是一样的。
因为初始值是Integer.MAX_VALUE，再做加法就会溢出，一定会成为最小值。所以在递归的最小逻辑上要额外的判断，如果(dp[j - coins[i]]是最大值，说明该位没有意义，没有被选择的意义。

class Solution {public int coinChange(int[] coins, int amount) {int[] dp = new int[amount+1];int itemSize = coins.length;// 初始化dp[0] = 0;for(int i = 1; i <= amount; i++){dp[i] = Integer.MAX_VALUE;// System.out.println(dp[i] + " ");}// System.out.println("*");// 递归逻辑for(int i = 0; i < itemSize; i++){for(int j = coins[i]; j <= amount; j++){//只有dp[j-coins[i]]不是初始最大值时，该位才有选择的必要if (dp[j - coins[i]] != Integer.MAX_VALUE) {//选择硬币数目最小的情况dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);}// System.out.println(dp[j] + " ");}// System.out.println("*");}return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];}
}

279.完全平方数

动态规划五步曲：
① 确定dp[j]的含义：凑成 i 这个数需要的最少的完全平方数的个数dp[j]。
② 求递推公式： dp[j] = min(dp[j] , dp[j-i*i]+1)
③ dp数组如何初始化： dp[0] = 0 其他的都是Integer.MAX_VALUE
④ 确定遍历顺序：都可以，因为不管是排列还是组合，元素的个数是一样的。
本题的特殊之处在于物品遍历时的结束条件：i*i <= n ，太精髓了！

class Solution {public int numSquares(int n) {int[] dp = new int[n+1];// 初始化for(int j =0; j <= n; j++){dp[j] = Integer.MAX_VALUE;}dp[0] = 0;// 递归逻辑,需要考虑终止的条件i*i <= n// 如果取i < n/2的话，1和2无法进入循环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];}}

139.单词拆分

动态规划五步曲：
① 确定dp[i]的含义：当前 i 长度的字符串可以被字典中共计dp[i]个单词组成。
② 求递推公式：

// 只有当dp[j]可以被wordDict组成的时候，才有必要去继续比较if(dp[j] != -1 && set.contains(sub)){dp[i] = dp[j] + 1;}

③ dp数组如何初始化： dp[0] = 0 dp[其他] = -1
④ 确定遍历顺序：先遍历背包，再遍历物品，因为本题是一种排列。
背包指的肯定是字符串s，背包里装的是截至i长度的字符串可以被字典中的几个单词组成；物品指的是字典中的单词。

// 使用上述的动态规划思想完成的代码，可以更好地被视为完全背包问题。
class Solution {public boolean wordBreak(String s, List<String> wordDict) {HashSet<String> set = new HashSet<>();for(int i = 0; i < wordDict.size(); i++){set.add(wordDict.get(i));}// 指的是截至i长度的字符串被几个单词组成int[] dp = new int[s.length() + 1];// 初始化dp[0] = 0;for(int i = 1; i <= s.length(); i++){dp[i] = -1;}// 递推逻辑  - 算是一种排列，所以先背包后物品for(int i = 0; i <= s.length(); i++){for(int j = 0; j < i; j++){// 左闭右开String sub = s.substring(j, i);// 只有当dp[j]可以被wordDict组成的时候，才有必要去继续比较if(dp[j] != -1 && set.contains(sub)){dp[i] = dp[j] + 1;}}}// for(int i : dp){//     System.out.println(i + " ");// }return dp[s.length()] != -1 ? true : false;}
}

class Solution {public boolean wordBreak(String s, List<String> wordDict) {HashSet<String> set = new HashSet<>();for(int i = 0; i < wordDict.size(); i++){set.add(wordDict.get(i));}boolean[] dp = new boolean[s.length() + 1];// 初始化dp[0] = true;for(int i = 1; i < s.length(); i++){dp[i] = false;}// 递推逻辑  - 算是一种排列，所以先背包后物品for(int i = 0; i <= s.length(); i++){for(int j = 0; j < i; j++){// 左闭右开String sub = s.substring(j, i);// 只有当dp[j]为true的时候，才有必要去继续比较// 代表前一段可以被wordDict组成if(dp[j] == true && set.contains(sub)){dp[i] = true;}}}return dp[s.length()];}
}