feat: add the section of the introduction to dynamic programming (#571)

* add the section of the introduction to
dynamic programming

* add a code comments.

codes/python/chapter_dynamic_programming/climbing_stairs_backtrack.py

@@ -0,0 +1,37 @@
+"""
+File: climbing_stairs_backtrack.py
+Created Time: 2023-06-30
+Author: Krahets (krahets@163.com)
+"""
+
+
+def backtrack(choices: list[int], state: int, n: int, res: list[int]) -> int:
+    """回溯"""
+    # 当爬到第 n 阶时，方案数量加 1
+    if state == n:
+        res[0] += 1
+    # 遍历所有选择
+    for choice in choices:
+        # 剪枝：不允许越过第 n 阶
+        if state + choice > n:
+            break
+        # 尝试：做出选择，更新状态
+        backtrack(choices, state + choice, n, res)
+        # 回退
+
+
+def climbing_stairs_backtrack(n: int) -> int:
+    """爬楼梯：回溯"""
+    choices = [1, 2]  # 可选择向上爬 1 或 2 阶
+    state = 0  # 从第 0 阶开始爬
+    res = [0]  # 使用 res[0] 记录方案数量
+    backtrack(choices, state, n, res)
+    return res[0]
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    n = 9
+
+    res = climbing_stairs_backtrack(n)
+    print(f"爬 {n} 阶楼梯共有 {res} 种方案")

codes/python/chapter_dynamic_programming/climbing_stairs_dfs.py

@@ -0,0 +1,28 @@
+"""
+File: climbing_stairs_dfs.py
+Created Time: 2023-06-30
+Author: Krahets (krahets@163.com)
+"""
+
+
+def dfs(i: int) -> int:
+    """搜索"""
+    # 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 or i == 2:
+        return i
+    # dp[i] = dp[i-1] + dp[i-2]
+    count = dfs(i - 1) + dfs(i - 2)
+    return count
+
+
+def climbing_stairs_dfs(n: int) -> int:
+    """爬楼梯：搜索"""
+    return dfs(n)
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    n = 9
+
+    res = climbing_stairs_dfs(n)
+    print(f"爬 {n} 阶楼梯共有 {res} 种方案")

codes/python/chapter_dynamic_programming/climbing_stairs_dfs_mem.py

@@ -0,0 +1,35 @@
+"""
+File: climbing_stairs_dfs_mem.py
+Created Time: 2023-06-30
+Author: Krahets (krahets@163.com)
+"""
+
+
+def dfs(i: int, mem: list[int]) -> int:
+    """记忆化搜索"""
+    # 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 or i == 2:
+        return i
+    # 若存在记录 dp[i] ，则直接返回之
+    if mem[i] != -1:
+        return mem[i]
+    # dp[i] = dp[i-1] + dp[i-2]
+    count = dfs(i - 1, mem) + dfs(i - 2, mem)
+    # 记录 dp[i]
+    mem[i] = count
+    return count
+
+
+def climbing_stairs_dfs_mem(n: int) -> int:
+    """爬楼梯：记忆化搜索"""
+    # mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+    mem = [-1] * (n + 1)
+    return dfs(n, mem)
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    n = 9
+
+    res = climbing_stairs_dfs_mem(n)
+    print(f"爬 {n} 阶楼梯共有 {res} 种方案")

codes/python/chapter_dynamic_programming/climbing_stairs_dp.py

@@ -0,0 +1,40 @@
+"""
+File: climbing_stairs_dp.py
+Created Time: 2023-06-30
+Author: Krahets (krahets@163.com)
+"""
+
+
+def climbing_stairs_dp(n: int) -> int:
+    """爬楼梯：动态规划"""
+    if n == 1 or n == 2:
+        return n
+    # 初始化 dp 列表，用于存储子问题的解
+    dp = [0] * (n + 1)
+    # 初始状态：预设最小子问题的解
+    dp[1], dp[2] = 1, 2
+    # 状态转移：从较小子问题逐步求解较大子问题
+    for i in range(3, n + 1):
+        dp[i] = dp[i - 1] + dp[i - 2]
+    return dp[n]
+
+
+def climbing_stairs_dp_comp(n: int) -> int:
+    """爬楼梯：状态压缩后的动态规划"""
+    if n == 1 or n == 2:
+        return n
+    a, b = 1, 2
+    for _ in range(3, n + 1):
+        a, b = b, a + b
+    return b
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    n = 9
+
+    res = climbing_stairs_dp(n)
+    print(f"爬 {n} 阶楼梯共有 {res} 种方案")
+
+    res = climbing_stairs_dp_comp(n)
+    print(f"爬 {n} 阶楼梯共有 {res} 种方案")

codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py

@@ -0,0 +1,43 @@
+"""
+File: min_cost_climbing_stairs_dp.py
+Created Time: 2023-06-30
+Author: Krahets (krahets@163.com)
+"""
+
+
+def min_cost_climbing_stairs_dp(cost: list[int]) -> int:
+    """爬楼梯最小代价：动态规划"""
+    n = len(cost) - 1
+    if n == 1 or n == 2:
+        return cost[n]
+    # 初始化 dp 列表，用于存储子问题的解
+    dp = [0] * (n + 1)
+    # 初始状态：预设最小子问题的解
+    dp[1], dp[2] = cost[1], cost[2]
+    # 状态转移：从较小子问题逐步求解较大子问题
+    for i in range(3, n + 1):
+        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
+    return dp[n]
+
+
+def min_cost_climbing_stairs_dp_comp(cost: list[int]) -> int:
+    """爬楼梯最小代价：状态压缩后的动态规划"""
+    n = len(cost) - 1
+    if n == 1 or n == 2:
+        return cost[n]
+    a, b = cost[1], cost[2]
+    for i in range(3, n + 1):
+        a, b = b, min(a, b) + cost[i]
+    return b
+
+
+"""Driver Code"""
+if __name__ == "__main__":
+    cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1]
+    print(f"输入楼梯的代价列表为 {cost}")
+
+    res = min_cost_climbing_stairs_dp(cost)
+    print(f"爬完楼梯的最低代价为 {res}")
+
+    res = min_cost_climbing_stairs_dp_comp(cost)
+    print(f"爬完楼梯的最低代价为 {res}")