动态编程与贪婪方法

动态编程和贪婪方法是程序员在算法篇章中......（这里可以根据需要自行补充）

动态编程

动态编程是一种算法设计技术，通常用来求解最优化问题（最大化或最小化问题）。它将问题分解成子问题，并且针对这些子问题只求解一次，存储结果，避免重复计算。最终通过这些存储的结果把所有子问题最优的解组合得到原问题的解。

动态规划的特点

• 求解最优解问题
• 适合用递推方式实现
• 记忆化搜索

动态规划的步骤

1. 定义状态
2. 确定状态转移方程
3. 初始化状态
4. 确定求解方向

动态规划问题的例子

最长公共子序列：字符串A和B的公共子序列中，最长的那个。

状态定义：设c为最长公共子序列的长度，a[i]表示字符串A的第i个字符，b[j]表示字符串B的第j个字符，则有c[i][j]为字符串A的前i个字符和字符串B的前j个字符的最长公共子序列的长度。

状态转移方程：

• 当a[i] == b[j]时，c[i][j] = c[i-1][j-1] + 1
• 当a[i] != b[j]时，c[i][j] = max(c[i][j-1],c[i-1][j])

初始化状态：当i=0或j=0时，c[i][j] = 0

求解方向：c[m][n]

示例代码片段：

def longestCommonSubsequence(text1: str, text2: str) -> int:
    n1, n2 = len(text1), len(text2)
    dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]
    for i in range(1, n1 + 1):
        for j in range(1, n2 + 1):
            if text1[i - 1] == text2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
    return dp[n1][n2]

贪婪方法

贪婪算法是一种选择最优策略的算法。在每一步都选择最优解，从而达到整体最优的解。贪婪算法并不总是能求得最优解，最终结果是与选择的贪婪策略有关的。

贪婪算法的应用

• 最小生成树
• 背包问题
• 图的着色
• 哈夫曼编码

贪婪算法的步骤

1. 建立数学模型来描述问题
2. 把求解的问题分成若干个子问题
3. 对每个子问题求解，得到子问题的局部最优解
4. 把子问题的局部最优解合成原问题的一个解

贪婪算法问题的例子

找零钱问题：有1元、5元、10元、50元、100元五种硬币，现在要用最少的硬币来找n元。

贪心思路：每次找最大硬币的数量。

示例代码片段：

def coinChange(coins: List[int], amount: int) -> int:
    coins.sort(reverse=True)
    res = 0
    for coin in coins:
        if amount == 0:
            break
        res += amount // coin
        amount %= coin
    return res if amount == 0 else -1

总结

动态编程和贪婪算法都可以解决很多最优化问题。对于大多数问题，两种策略可能得到不同的结果。应选择根据不同问题的特点来选择不同的策略。