Day 38 | 509. Fibonacci Number | 70. Climbing Stairs | 746. Min Cost Climbing Stairs

原创已于 2023-01-21 11:29:42 修改 · 204 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

于 2023-01-20 15:20:06 首次发布

LeetCode 专栏收录该内容

52 篇文章

订阅专栏

该文列举了一系列LeetCode上的动态规划和递归解题实例，包括斐波那契数列、爬楼梯问题和最小成本爬楼梯等，展示了如何利用动态规划数组解决这些计算问题。

LeetCode 509. Fibonacci Number

Question Link

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

Determine the meaning of dp[i]
- The value of ith Fibonacci Number is dp[i]
Determine recursive formula
- dp[i] = dp[i - 1] + dp[i - 2]
Initialize the dynamic programming array
- dp[0] = 0
- dp[1] = 1
The traverse order is front to back, because dp[i] depends on dp[i - 1] and dp[i - 2]
Print the array

LeetCode 70. Climbing Stairs

Question Link

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

Determine the meaning of dp[i]
- The number of distinct ways to the ith stair is dp[i]
Determine recursive formula
- dp[i] = dp[i - 1] + dp[i - 2]
Initialize the dynamic programming array
- dp[1] = 1
- dp[2] = 2
The traverse order is front to back, because dp[i] depends on dp[i - 1] and dp[i - 2]
Print the array

LeetCode 746. Min Cost Climbing Stairs

Question Link

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length + 1];
        // We can start from index `0` or `1` 
        dp[0] = 0;
        dp[1] = 0;
        for(int i = 2; i <= cost.length; i++)
            dp[i] = Math.min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);
        
        return dp[cost.length];
    }
}

Determine the meaning of dp[i]
- The minimum cost to reach the ith stairs is dp[i]
Determine recursive formula
- dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
Initialize the dynamic programming array
- dp[0] = 0
- dp[1] = 0
The traverse order is front to back, because dp[i] depends on dp[i - 1] and dp[i - 2]
Print the array