Day 41 算法记录|动态规划 07

70. 爬楼梯

将这道题转换为完全背包问题：
一步一个台阶，两个台阶，三个台阶，…，直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢？
1阶，2阶，… m阶就是物品，楼顶就是背包。
1.dp[i]：爬到有i个台阶的楼顶，有dp[i]种方法。
2.装满背包有几种方法，dp[i] += dp[i - j]
3.初始化，
4.确定遍历顺序：1、2 步 和 2、1 步都是上三个台阶，但是这两种方法不一样！
排列问题，先遍历背包，在遍历物品

class Solution {

    public int climbStairs( int n) {
       
       int[] dp = new int[n+1];
       int[] nums =new int[]{1,2};
       dp[0]=1;

       for(int i=1;i<=n;i++ ){  // 遍历背包
          for(int j = 0;j<nums.length;j++){
              if(i>= nums[j]){
                  dp[i] +=dp[i-nums[j]];
              }
          }
       }
  return dp[n];
    }
}

之前的做法也很简单：

class Solution {

    public int climbStairs( int n) {
        if(n<2) return 1;

     int[] dp = new int[n+1];
     dp[0] =1;
     dp[1] =1;
       for( int i=2;i<=n;i++){
           dp[i] = dp[i-1]+dp[i-2];
       }
return dp[n];

    }
}

322. 零钱兑换

1.dp[i]：凑到金额i，有最少需要dp[i]个硬币。
2.凑满金额有最少个数，min{添加当前金额，不添加当前金额}
3.初始化，
4.确定遍历顺序：金额个数，
组合：不同的组合，先物品再背包
排列：顺序很重要， 先背包再物品
这道题说的是，最少，所以组合排序都不会影响结果
递归的推导过程

排序的思路： 先背包再物品

class Solution {
    public int coinChange(int[] coins, int amount) {
     int[] dp = new int[amount+1];
     // 1.初始化
       Arrays.fill(dp, amount+1);
   dp[0] =0;

  //动态规划
  for(int j =1;j<=amount;j++){  //1.先遍历背包
      for(int coin:coins){
          if(coin<=j){
              dp[j] = Math.min(dp[j],dp[j-coin]+1);
          }
      }
  }
   return dp[amount] > amount ? -1 : dp[amount];
    }
}

279.完全平方数

这道题说的是，最少，所以组合排序都不会影响结果
1.先物品，就是存放$i$的平方 2.背包容量n

class Solution {
    public int numSquares(int n) {
      int max = Integer.MAX_VALUE;
      int[] dp = new int[n+1];
      Arrays.fill(dp,max);
     dp[0] =0;
      for(int i=1;i*i<=n;i++){
          for(int j = i*i;j<=n;j++){
              dp[j] = Math.min(dp[j],dp[j-i*i]+1);
          }
      }
      return dp[n];
    }
}

2.先背包

class Solution {
    public int numSquares(int n) {
      int max = Integer.MAX_VALUE;
      int[] dp = new int[n+1];
      Arrays.fill(dp,max);
     dp[0] =0;
    //
    for(int j=1;j<=n;j++){
        for(int i =1;i*i<=n;i++){
            if(j>=i*i){
                dp[j] = Math.min(dp[j],dp[j-i*i]+1);
            }
        }
    }

      return dp[n];
    }
}