Day 45 | 70. Climbing Stairs | 322. Coin Change | 279. Perfect Squares

王锴KKKKKKyle

已于 2023-08-16 23:21:43 修改

阅读量84

点赞数

分类专栏： LeetCode 文章标签： java leetcode 算法

于 2023-07-20 01:03:18 首次发布

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

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

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.

王锴KKKKKKyle

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day 45 | 70. Climbing Stairs | 322. Coin Change | 279. Perfect Squares

Day 45 | 70. Climbing Stairs | 322. Coin Change | 279. Perfect Squares
复制链接

扫一扫