day32-dynamic programming-part01-8.3

tasks for today:

1. 理论基础

2. 509.斐波那契数列

3. 70.爬楼梯

4. 747.是用最小花费爬楼梯

--------------------------------------------------------------------------

1. 理论基础

定义区分：

如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的

步骤：

状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

2. 509.斐波那契数列

In this practice, although the mindset is simply, this is a good opportunity to understanding how the 5-step mode proceed.

1st: determin the dp table and the index, dp[i] represent the i number value;

2nd: the dp recursive equation: dp[i] = dp[i-1] + dp[i-2]

3rd: initialize, dp[0]=0 and dp[1]=1, this is prepared for the first round in the loop

4th: traverse sequence, from start to end

5th: a manual check to derive several steps of dp

class Solution:
    def fib(self, n: int) -> int:
        if n <= 1: return n

        dp = [0] * (n+1)
        dp[1] = 1

        for i in range(2, n+1):
            dp[i] = dp[i-1] + dp[i-2]

        return dp[n]

3. 70.爬楼梯

In this practice, the essence is figuring out how the number of method to get up onto step n, 1st is step onto n-1 then one more step 1, whole the other method is step onto n-2 and one more step 2, so the dp[n] = dp[n-1] + dp[n-2]

class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 3: return n

        dp = [0] * (n+1)
        dp[0] = 1
        dp[1] = 1
        dp[2] = 2

        for i in range(3, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        
        return dp[n]

4. 747.是用最小花费爬楼梯

the mindset is also decomposing each i's result into the previosus i-1 and i-2.

In this practice, the key is:

1. figuring out the top is not the bigest index in cost, which is the last step instead of the top.

2. do foget adding the corresponding cost for step on the step.

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        dp = [0] * (len(cost) + 1)

        for i in range(2, len(dp)):
            dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])
        
        return dp[-1]