Day 45 | 70. Climbing Stairs | 322. Coin Change | 279. Perfect Squares-CSDN博客

本文链接：https://blog.csdn.net/kyle313606922/article/details/131812493

70. Climbing Stairs

Question Link

class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        int m = 2;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if(i >= j) dp[i] += dp[i-j];
            }
        }
        return dp[n];
    }
}

dp[i]: The number of combinations that make up the total steps n.
When we solve for the number of ways to fill the backpack, the recursive formula is:
- dp[j] += dp[j - i]
dp[0] must be initialized to 1. If dp[0] = 0, all the value of dp will be 0.
Question: why do you put n outside and m inside?
- In this question, if n = 3, 1 step + 2 steps and 2 steps + 1 step are different combinations. So what we are looking for is permutation
- If we traverse m first, 2 steps can not be in front of 1 step.

322. Coin Change

Question Link

class Solution {
    public int coinChange(int[] coins, int amount) {
        int max = Integer.MAX_VALUE;
        int[] dp = new int[amount + 1];
        // Initilze the dp array to the maximum value
        for(int j = 0; j < dp.length; j++){
            dp[j] = max;
        }
        dp[0] = 0;
        for(int i = 0; i < coins.length; i++){
            for(int j = coins[i]; j <= amount; j++){
                if (dp[j - coins[i]] != max)
                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
            }
        }
        return dp[amount] == max ? -1 : dp[amount];
    }
}

dp[j]: The number of fewest coins that make up the j.
The minimum number of coins that make up the total amount of j - coins[i] is dp[j - coins[i]]
So the recursive formula is: dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1)
Array initialization
- dp[0] = 0 Because the number of coins that make up the total amount of 0 must be 0.
- According to the recursive formula, dp[j] must be initialized to a max value. Otherwise, dp[j] will be overwritten by the initial value in the process of comparing.
In this question, we are looking for the fewest number of coins, not the number of permutations or combinations. So no matter what we traverse first, both are fine.
- We adopt positive order traversal when traversing the capacity. Because in this question, we have an infinite number of each kind of coin. So it a full backpack question.
Make comparison only when the dp[i-coins[i]] is not the initial maximum value.

322. Coin Change

Question Link

class Solution {
    public int numSquares(int n) {
        int max = Integer.MAX_VALUE;
        int[] dp = new int[n + 1];
        for(int j = 0; j < dp.length; j++)
            dp[j] = max;

        dp[0] = 0;
        for(int i = 1; i*i <= n; i++){      // traverse item
            for(int j = i*i; j <= n; j++){  // traverse capacity
                //if(dp[j - i*i] != max)
                dp[j] = Math.min(dp[j], dp[j - i*i] + 1);
            }
        }
        return dp[n];
    }
}

dp[j]: The least number of perfect squares numbers that sum to j.
We don’t need if(dp[j - i*i] != max){ } anymore. Because we can use 1 to make up every n, so it is definitely possible to make up n.