📝 更新动态规划文档，新增最长公共子串与最长公共子序列示例

- 在文档中新增了最长公共子串和最长公共子序列的详细描述与示例，展示了如何使用动态规划解决相关问题。
- 增加了动态规划的解题步骤，帮助读者理解算法的核心思想与实现过程。
- 优化了示例代码，提升了文档的实用性与参考价值。

Author: jiangyangcreate

docs/docs/选择编程语言/Python/99练习.mdx

@@ -1754,7 +1754,7 @@ items = {
 |音响| 0|0 | 0 | 0 | 3000|
 |笔记本电脑| 0|0 | 0 | 2000 | 3000|
 |吉他| 0|1500 | 1500 | 2000 | 3500 |
-|iphone| 0|2000 | 3500 | 3500 | 4000 |
+|iphone| 0|2000 | 3500 | 3500 |  |
 
 
 ```bash showLineNumbers
@@ -1848,4 +1848,232 @@ for i in range(1, rows + 1):
 # 最右下角就是最大价值
 max_value = dp[rows][cols]
 print("最大总价值：", max_value)
+```
+
+### 最长公共子串
+
+当用户输入"hish"时，下面三个单词哪个更有可能是用户真正输入的单词？
+
+- fish
+- vista
+- hsih（原单词的反转）
+
+我们希望找到：哪个单词和 hish 之间有“最长的公共子串”（连续、顺序一致的公共部分），这个单词就更有可能是用户真正想输的。
+
+#### 思路
+
+这题是不能用集合取交集判断长度来解决的。
+
+因为用户输入的单词是"hish"，而单词"hsih"是原单词的反转。取集合交集判断虽然最长，但是交集不判断顺序。
+
+最长公共子串要求顺序也一致的公共子字符串。
+
+我们可以用动态规划来解决这个问题。
+
+| 字符串 | h | i | s | h |
+| --- | --- | --- | --- | --- |
+| f | 0(左上角) | 0 | 0 | 0 |
+| i | 0  | 0+1=1 |   |  |
+| s |   |  |   |  |
+| h |   |  |   |  |
+
+如果两个字母不相同，则标记0 , 由于 f 和 `['h', 'i', 's', 'h']` 每个字母都不相同，所以标记0。
+
+如果两个字母相同，值为右上角的邻居的值 + 1  
+
+<Highlight>为了让每个点都有一个左上角，你依然可以在第一行前和第一列前补0</Highlight>
+
+直到填满所有表格。表格最大值为3，说明最多有3个连续相同的字符串。
+
+| 字符串 | h | i | s | h |
+| --- | --- | --- | --- | --- |
+| f | 0 | 0 | 0 | 0 |
+| i | 0  | 1| 0  | 0 |
+| s | 0  | 0 | 2  | 0 |
+| h | 0  | 0 | 0  | 3 |
+
+接着我们把和hsih的表格也绘制出来。下表说明最多有1个连续相同的字符串。
+
+| 字符串 | h | i | s | h |
+| --- | --- | --- | --- | --- |
+| h | 1 | 0 | 0 | 1 |
+| s | 0  | 0| 1  | 0 |
+| i | 0  | 1 | 0  | 0 |
+| h | 1 | 0 | 0  | 1|
+
+接着我们把和vista的表格也绘制出来。下表说明最多有2个连续相同的字符串。
+
+| 字符串 | h | i | s | h |
+| --- | --- | --- | --- | --- |
+| v | 0 | 0 | 0 | 0 |
+| i | 0  | 1| 0  | 0 |
+| s | 0  | 0| 2  | 0 |
+| t | 0  | 0 | 0  | 0 |
+| a | 0  | 0 | 0  | 0 |
+
+
+#### 题解
+
+```python showLineNumbers
+# 用户输入的单词
+user_word = "hish"
+
+# 备选单词列表
+candidates = ["fish", "vista", "hsih"]
+
+
+def longest_common_substring_length(a, b):
+    # 计算字符串 a 和 b 的最长公共子串长度（必须连续、顺序一致）
+
+    # 行：字符串 a 的字符个数，列：字符串 b 的字符个数
+    rows = len(a)
+    cols = len(b)
+
+    # dp[i][j] 表示：以 a 的第 i 个字符、b 的第 j 个字符结尾时
+    # 它们的「最长公共后缀子串」的长度
+    # 为了让每个点都有一个左上角，我们在前面额外补一行 0 和一列 0
+    dp = [[0] * (cols + 1) for _ in range(rows + 1)]
+
+    # 记录当前遇到的最长公共子串长度
+    longest = 0
+
+    # 从第 1 行、第 1 列开始填表（第 0 行和第 0 列是我们人为补上的 0）
+    for i in range(1, rows + 1):
+        for j in range(1, cols + 1):
+            # 如果两个字符相同，就把左上角的值 + 1
+            if a[i - 1] == b[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + 1
+                # 顺便更新目前为止的最长公共子串长度
+                longest = max(longest, dp[i][j])
+            else:
+                # 如果两个字符不同，根据「最长公共子串」的定义，这个格子只能是 0
+                dp[i][j] = 0
+
+    return longest
+
+
+# 用上面的函数分别计算每个候选单词和用户输入之间的最长公共子串长度
+result = {}
+for word in candidates:
+    # 每个候选单词和 user_word 的最长公共子串长度
+    length = longest_common_substring_length(word, user_word)
+    result[word] = length
+
+# 找到最长公共子串长度最大的那个单词
+best_word = max(result, key=result.get)
+print("最有可能是用户真正输入的单词是：", best_word)
+```
+
+至此，你可以总结出动态规划的解题步骤：
+
+- 确定维度？（在背包问题中是物品和背包空间 在最长公共子串问题中是原字符串和待比较字符串）
+- 边界条件与初始值？（首行首列前补0）
+- 状态转移方程是？（根据题目要求，确定状态转移方程，核心难点）
+- 答案在哪？（背包问题中是右下角，最长公共子串问题中是表格最大值）
+
+### 最长公共子序列
+
+当用户输入"fosh"时，下面哪个更有可能是用户真正输入的单词？
+
+- fort
+- fish
+
+#### 思路
+
+按照之前最长公共子串的思路，两个单词的最长公共子串都为2。
+
+我们可以绘制出两个单词的表格：
+
+| 字符串 | f | o | s | h |
+| --- | --- | --- | --- | --- |
+| f | 1 | 0 | 0 | 0 |
+| o | 0  | 2| 0  | 0 |
+| r | 0  | 0| 0  | 0 |
+| t | 0  | 0 | 0  | 0 |
+
+| 字符串 | f | o | s | h |
+| --- | --- | --- | --- | --- |
+| f | 1 | 0 | 0 | 0 |
+| i | 0  | 0| 0  | 0 |
+| s | 0  | 0| 1  | 0 |
+| h | 0  | 0 | 0  | 2|
+
+但是fish和fosh的相似度更高，怎么修改状态转移方程，使得fish和fosh的相似度更高？
+
+把状态转移方程改为：
+
+- 如果两个字母不相同，则<HoverText text="标记从左上角、上方和左方的值中取最大值" explanation="最长公共子串是取0"/>
+
+- 如果两个字母相同，值为右上角的邻居的值 + 1  
+
+| 字符串 | - | f | o | s | h |
+| --- | --- | --- | --- | --- | --- |
+| - | 0 | 0 | 0 | 0 | 0 |
+| f | 0  | 1 | 1 | 1 | 1 |
+| o | 0  | 1|  2  | 2  | 2 |
+| r | 0  | 1 | 2  | 2  | 2 |
+| t | 0  | 1 | 2  | 2 | 2 |
+
+表格最大值为2，说明最多有2个连续相同的字符串。
+
+| 字符串 | - | f | o | s | h |
+| --- | --- | --- | --- | --- | --- |
+| - | 0 | 0 | 0 | 0 | 0 |
+| f | 0  | 1 | 1 | 1 | 1 |
+| i | 0  | 1|  1  | 1  | 1 |
+| s | 0  | 1 | 1  | 2  | 2 |
+| h | 0  | 1 | 2  | 2 | 3 |
+
+表格最大值为3，说明最多有3个连续相同的字符串。
+
+#### 题解
+
+```python showLineNumbers
+# 用户输入的单词
+user_word = "fosh"
+
+# 备选单词列表
+candidates = ["fort", "fish"]
+
+
+def longest_common_subsequence_length(a, b):
+    # 计算字符串 a 和 b 的最长公共子序列长度（字符顺序一致，但不要求连续）
+
+    # 行：字符串 a 的字符个数，列：字符串 b 的字符个数
+    rows = len(a)
+    cols = len(b)
+
+    # dp[i][j] 表示：a 的前 i 个字符、b 的前 j 个字符之间
+    # 能得到的「最长公共子序列」的长度
+    # 为了让每个点都有一个左上角、上方和左方，我们在前面额外补一行 0 和一列 0
+    dp = [[0] * (cols + 1) for _ in range(rows + 1)]
+
+    # 从第 1 行、第 1 列开始填表（第 0 行和第 0 列是我们人为补上的 0）
+    for i in range(1, rows + 1):
+        for j in range(1, cols + 1):
+            if a[i - 1] == b[j - 1]:
+                # 如果两个字符相同，值为左上角的邻居的值 + 1
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            else:
+                # 如果两个字符不同，则从「左上角、上方和左方」三者中取最大值
+                dp[i][j] = max(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1])
+
+    # 整个表格的右下角，就是最长公共子序列的长度
+    return dp[rows][cols]
+
+
+# 用上面的函数分别计算每个候选单词和用户输入之间的最长公共子序列长度
+result = {}
+for word in candidates:
+    # 每个候选单词和 user_word 的最长公共子序列长度
+    length = longest_common_subsequence_length(word, user_word)
+    result[word] = length
+
+# 打印每个候选单词的最长公共子序列长度，方便对照
+for word, length in result.items():
+    print(f"{word} 和 {user_word} 的最长公共子序列长度为: {length}")
+
+# 找到最长公共子序列长度最大的那个单词
+best_word = max(result, key=result.get)
+print("最有可能是用户真正输入的单词是：", best_word)
 ```