动态规划1（DP）

1. 动态规划的思想

动态规划（Dynamic Programming，DP）通过将复杂问题分解为更小的子问题，并存储这些子问题的解（通常是在表格中），从而避免重复计算，提高了算法的效率。

动态规划与贪心算法、分治算法等其他优化算法相比，最大的特点是它对子问题的全面考察。贪心算法每步都做出在当前看来最好的选择，可能无法达到全局最优；分治算法将问题分解后独立解决各子问题，不适用于子问题重叠的情况。而动态规划通过存储子问题的解来避免重复计算，旨在找到全局最优解。

2.动态规划的基本原理

2.1 最优子结构

最优子结构是指问题的最优解包含其子问题的最优解。具体而言，如果我们可以通过组合子问题的最优解来构造出原问题的最优解，那么这个问题就具有最优子结构的性质。在动态规划中，识别并利用最优子结构是解决问题的关键。

2.2 重叠子问题

在递归算法中，很多问题会多次计算相同的子问题，这种现象称为重叠子问题。动态规划算法通过记忆化或者表格化来存储这些子问题的解，确保每个子问题只被解决一次，从而显著提高效率。

2.3 记忆化（Memoization）与表格化（Tabulation）

• 记忆化是一种自顶向下的动态规划实现方式，它从原问题开始，递归地解决子问题。在这个过程中，每次计算一个子问题的解时，都会先检查这个解是否已经被计算并存储起来，如果是，就直接使用，避免重复计算。
• 表格化是一种自底向上的动态规划实现方式，它首先解决最小子问题，并逐步结合这些解来得到更大子问题的解，直至解决原问题。这个过程通常使用一个表格来存储所有子问题的解。

2.4 状态转移方程（State Transition Equation）

状态转移方程描述了子问题之间是如何相互关联的。在动态规划中，我们定义一组变量来表示问题的状态，然后找到状态之间转移的关系，即从一个状态如何转移到另一个状态。这些转移关系通常以数学公式的形式表达，是动态规划算法中的核心。

3. 动态规划的基本解题步骤

• 定义状态
• 定义状态转移方程
• 解决基本情况（base case）

4. 动态规划的经典例题理解

4. 1最长公共子序列（LCS）

最长公共子序列（Longest Common Subsequence, LCS）问题是寻找两个序列共有的最长子序列的长度，这个子序列不需要在原序列中是连续的

解题思路：

1. 定义状态

在LCS问题中，定义 dp[i][j] 为序列 X[0..i-1] 和序列 Y[0..j-1] 的最长公共子序列的长度。这里，i 和 j 分别表示序列 X 和序列 Y 中元素的索引，范围从1到序列长度。

2. 定义状态转移方程

• 当 X[i - 1] == Y[j - 1] 时，我们发现了两个序列中共有的元素，因此 dp[i][j] 应该是这个共有元素之前的最长公共子序列的长度加一，即 dp[i][j] = dp[i - 1][j - 1] + 1。

• 当 X[i - 1] != Y[j - 1] 时，最长公共子序列要么在 X 的前 i-1 个元素和 Y 的前 j 个元素中，要么在 X 的前 i 个元素和 Y 的前 j-1 个元素中，所以 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])。

3. 解决基本情况

基本情况对应于矩阵的边界，当任一序列长度为0时（即 i == 0 或 j == 0），dp[i][j] 自然应该是0，因为空序列与任何序列的最长公共子序列长度都是0。

代码实现如下：

def lcs(X, Y):
    m, n = len(X), len(Y)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if X[i - 1] == Y[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    
    return dp[m][n]

4.2 最长递增子序列（LIS）

最长递增子序列（Longest Increasing Subsequence, LIS）问题是在一个无序的给定序列中寻找一个最长的递增子序列。

解题思路：

1. 定义状态

我们定义 dp[i] 为以元素 nums[i] 结尾的最长递增子序列的长度。

2. 定义状态转移方程

对于每个 i（从1到 n-1），我们都检查前面的每个较小的 j（从0到 i-1），如果 nums[i] > nums[j]，这意味着我们可以将 nums[i] 接在由 nums[j] 结尾的递增子序列后面，形成一个新的递增子序列。因此，更新 dp[i] 为 dp[j] + 1 和 dp[i] 的较大者，具体转移方程为：dp[i] = max(dp[i], dp[j] + 1)，对所有 0 ≤ j < i 且 nums[i] > nums[j]。

3. 解决基本情况

基本情况是在序列开头，每个元素自身构成一个长度为1的递增子序列，因此，初始化 dp[i] = 1 对所有 0 ≤ i < n。

代码实现如下：

def lis(nums):
    if not nums:
        return 0
    
    n = len(nums)
    dp = [1] * n
    
    for i in range(1, n):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)
    
    return max(dp)