代码随想录算法训练营第四十五天|57. 爬楼梯、322.零钱兑换、279. 完全平方数

KamaCoder 57. 爬楼梯
题目链接：题目页面 (kamacoder.com)

这道题使用完全背包来实现，我们首先考虑的是总的楼梯数，因此dp数组大小为n + 1 ，其意义是，在n阶时有多少种方法爬到楼顶，因此，当前n状态等于前面状态(1, m)状态之和。

每道题都要考虑dp五步：

1）确定dp数组下标与值的关系：满足凑出总楼梯的组合数

2）确定递推公式：我们把n个数组成看作1与n-1个组成,使用分而治之的思路来处理,dp[i] += dp[i - j]

3）确定初始值：dp[0]为1,没得选

4）确定遍历的数：注意一下边界问题

5）带入验证一下

代码：

#python acm模式
while True:
    try:
        n, m = map(int, input().split())
        dp = [0 for _ in range(n + 1)]  //dp数组大小为n+1
        dp[0] = 1  //初始化dp[0]
        for i in range(1, n + 1):  //从1开始，从0没意义
            for j in range(1, min(i, m) + 1):   //从前往后，遍历可能的楼梯数
                    dp[i] += dp[i - j]
        print(dp[n])
    except:
        break

import java.util.*;
public class Main{
    //1.dp[i] 到第i个台阶，有dp[i]种方法
    //2.dp[i]=dp[i-m] + ... + dp[i-1]
    //3.初始化,i= 1..m,dp[1] = 1, dp[i] = dp[1]+...+dp[i-1] + 1
    //4.顺序，升序
    //5,举例，
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);  
        while (scanner.hasNextLine()) {  
            try {  
                String[] input = scanner.nextLine().split(" ");  
                int n = Integer.parseInt(input[0]);  
                int m = Integer.parseInt(input[1]);  
                  
                int[] dp = new int[n + 1]; // dp数组大小为n+1  
                dp[0] = 1; // 初始化dp[0]  
                  
                for (int i = 1; i <= n; i++) { // 从1开始，从0没意义  
                    for (int j = 1; j <= Math.min(i, m); j++) { // 从前往后，遍历可能的楼梯数  
                        dp[i] += dp[i - j];  
                    }  
                }  
                  
                System.out.println(dp[n]);  
            } catch (Exception e) {  
                // 当输入不合法或遇到文件结束符时，退出循环  
                scanner.close();  
                break;  
            }  
        }  
    }    
}

---

LeetCode 322.零钱兑换
题目链接：322. 零钱兑换 - 力扣（LeetCode）

这道题使用完全背包来实现，要求的组成整数amount的最小硬币组合数，因此dp数组大小为n + 1 ，其意义是，在n阶时最小的硬币数量，因此，当前n状态等于前面状态的最小值。

每道题都要考虑dp五步：

1）确定dp数组下标与值的关系：满足凑出目标金额的最少硬币数量

2）确定递推公式：dp[i] = min(dp[i], dp[i - coin] + 1) (后面这个意思是从前coin的位置递推过来，加上一个硬币数）

3）确定初始值：dp[0]为0，当目标为0时当然一个硬币也不要

4）确定遍历的数：注意一下i要大于等于当前coin，否则数组会越界

5）带入验证一下

代码：

#python   //DFS
class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dfs
        n=len(coins)
        @cache   //用一个装饰器
        def dfs(i,c):
            if i<0:  //判定结束条件
                return 0 if c==0 else inf
            if c<coins[i]: //确定一下coin
                return dfs(i-1,c)
            return min(dfs(i-1,c),dfs(i,c-coins[i])+1)  //返回最小的硬币数量，递归
        res=dfs(n-1,amount)  //结果
        return res if res<inf else -1  //看下结果呗，要么有，没有就-1

#python   //二维DP
class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        n=len(coins)  //一共有n个硬币数量
        dp=[[inf]*(amount+1) for _ in range(n+1)]  //二维dp数组
        dp[0][0]=0  //初始化一下
        for i,x in enumerate(coins):  //使用枚举，把键与值分离
            for c in range(amount+1):   //同样的是在金额内部
                if c<x:    //当前的值放不下硬币了
                    dp[i+1][c]=dp[i][c]
                else:  //放得下，比较一下
                    dp[i+1][c]=min(dp[i][c],dp[i][c-x]+1)
        res=dp[n][amount]
        return res if res < inf else -1没有就-1

#python   //一维DP
class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        n = len(coins)
        dp = [float('inf') for _ in range(amount + 1)]
        dp[0] = 0
        for i in range(1, amount + 1):
            for coin in coins:
                if i >= coin:
                    dp[i] = min(dp[i], dp[i - coin] + 1)
        return dp[-1] if dp[-1] < float('inf') else -1

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE / 2); // 除 2 是防止下面 + 1 溢出
        dp[0] = 0;
        for (int x : coins)
            for (int c = x; c <= amount; ++c)
                dp[c] = Math.min(dp[c], dp[c - x] + 1);
        int ans = dp[amount];
        return ans < Integer.MAX_VALUE / 2 ? ans : -1;
    }
}

---

LeetCode 279. 完全平方数
题目链接：279. 完全平方数 - 力扣（LeetCode）

和前面的做法异曲同工，注意一下范围就是

每道题都要考虑dp五步：

1）确定dp数组下标与值的关系：满足凑出目标金额的最少完全平方数数量

2）确定递推公式：dp[i] = min(dp[i], dp[i - j ** 2] + 1) (后面这个意思是从前j**2的位置递推过来，加上一个完全平方数）

3）确定初始值：dp[0]为0，当目标为0时当然完全平方数

4）确定遍历的数：注意一下i要大于等于当前j**2，否则数组会越界

5）带入验证一下

代码：

#python  一维dp
class Solution:
    def numSquares(self, n: int) -> int:
        dp = [inf for _ in range(n + 1)]
        dp[0] = 0
        for i in range(1, n + 1):
            for j in range(1, int(math.sqrt(i)) + 1): //从小于当前i的平方根数来
                dp[i] = min(dp[i], dp[i - (j ** 2)] + 1)
        return dp[-1]

/java
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 <= n; i++){
            for(int j = 1; j <= Math.sqrt(i); j++){
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }
        return dp[n];
    }
}

---