【动态规划】深入动态规划—两个数组的dp问题

文章目录

前言
例题
- 一、最长公共子序列
- 二、不相交的线
- 三、不同的子序列
- 四、通配符匹配
- 五、交错字符串
- 六、两个字符串的最小ASCII删除和
- 七、最长重复子数组
结语

在这里插入图片描述

前言

问题本质
它主要围绕着给定的两个数组展开，旨在通过对这两个数组元素间关系的分析，找出满足特定目标的最优解。比如在字符串处理中，两个字符串可看作字符数组，求它们的最长公共子序列等问题；或是在数值数组场景下，计算从两个数组元素组合中得到的最大收益等。
解题关键要素
状态定义：通常构建一个二维数组 dp[i][j] 作为状态表示。这里的 i 对应第一个数组的下标，j 对应第二个数组的下标。dp[i][j] 代表在考虑第一个数组前 i 个元素和第二个数组前 j 个元素时，问题的最优解值，像上述最长公共子序列问题中，dp[i][j] 就表示对应前缀子串的最长公共子序列长度。
状态转移方程：这是解决问题的核心。需深入剖析问题特性，明确 dp[i][j] 如何由已求解的子问题状态（如 dp[i - 1][j]、dp[i][j - 1]、dp[i - 1][j - 1] 等）推导得出。例如在求两个数组元素匹配的最大得分问题中，若当前两个数组元素匹配，dp[i][j] 可能由 dp[i - 1][j - 1] 加上对应得分转移而来；若不匹配，则需比较 dp[i - 1][j] 和 dp[i][j - 1] 取较大值。
边界条件：初始化 dp 数组的第一行和第一列。如在最长公共子序列问题里，dp[0][j] 和 dp[i][0] 都初始化为 0 ，因为一个空串与另一个串不存在公共子序列。
通过合理定义状态、精准推导状态转移方程并正确处理边界条件，就能借助动态规划高效解决涉及两个数组的各类问题。

下面本篇文章，将通过例题为大家详细动态规划中的两个数组的dp问题！

例题

一、最长公共子序列

题目链接：最长公共子序列
题目描述：

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共⼦序列，返回 0 。⼀个字符串的⼦序列是指这样⼀个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 ◦ 例如，“ace” 是 “abcde” 的⼦序列，但 “aec” 不是 “abcde” 的⼦序列。
两个字符串的公共⼦序列是这两个字符串所共同拥有的⼦序列。⽰例 1：输⼊：text1 = “abcde”, text2 = “ace”
输出：3 解释：最⻓公共⼦序列是 “ace” ，它的⻓度为 3 。⽰例 2：输⼊：text1 = “abc”, text2 = “abc” 输出：3 解释：最⻓公共⼦序列是 “abc” ，它的⻓度为 3 。⽰例 3：输⼊：text1 = “abc”, text2 = “def” 输出：0 解释：两个字符串没有公共⼦序列，返回 0 。提⽰：1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由⼩写英⽂字符组成。

解法（动态规划）：
算法思路：
状态表示：对于两个数组的动态规划，我们的定义状态表⽰的经验就是：
i. 选取第⼀个数组 [0, i] 区间以及第⼆个数组 [0, j] 区间作为研究对象；
ii. 结合题目要求，定义状态表⽰。在这道题中，我们根据定义状态表示为：
dp[i][j] 表示： s1 的 [0, i] 区间以及 s2 的 [0, j] 区间内的所有的子序列中，最长公共子序列的长度。
状态转移方程：分析状态转移方程的经验就是根据「最后⼀个位置」的状况，分情况讨论。对于 dp[i][j] ，我们可以根据 s1[i] 与 s2[j] 的字符分情况讨论：
i. 两个字符相同， s1[i] = s2[j] ：那么最长公共子序列就在 s1 的 [0, i - 1] 以及 s2 的 [0, j - 1] 区间上找到⼀个最长的，然后再加上 s1[i] 即可。因此dp[i][j] = dp[i - 1][j - 1] + 1 ；
ii. 两个字符不相同， s1[i] != s2[j] ：那么最长公共子序列⼀定不会同时以 s1[i]
和 s2[j] 结尾。那么我们找最⻓公共⼦序列时，有下面三种策略：
• 去 s1 的 [0, i - 1] 以及 s2 的 [0, j] 区间内找：此时最⼤⻓度为 dp[i - 1][j] ； • 去 s1 的 [0, i] 以及 s2 的 [0, j - 1] 区间内找：此时最大长度为 dp[i][j - 1] ；
• 去 s1 的 [0, i - 1] 以及 s2 的 [0, j - 1] 区间内找：此时最大长度为dp[i - 1][j - 1] 。我们要三者的最大值即可。但是我们细细观察会发现，第三种包含在第⼀种和第二种情况里面，但是我们求的是最大值，并不影响最终结果。因此只需求前两种情况下的最大值即可。综上，状态转移方程为：
if(s1[i] == s2[j]) dp[i][j] = dp[i - 1][j - 1] + 1 ;
if(s1[i] != s2[j]) dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) 。
初始化：
a. 「空串」是有研究意义的，因此我们将原始 dp 表的规模多加上⼀⾏和⼀列，表⽰空串。
b. 引入空串后，大大的方便我们的初始化。
c. 但也要注意「下标的映射关系」，以及⾥⾯的值要「保证后续填表是正确的」。
当 s1 为空时，没有长度，同理 s2 也是。因此第⼀⾏和第⼀列里面的值初始化为 0 即可保证后续填表是正确的。
填表顺序：根据「状态转移方程」得：从上往下填写每⼀行，每⼀行从左往右。
返回值：根据「状态表示」得：返回 dp[m][n]
代码示例：

 public int longestCommonSubsequence(String s1, String s2) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = s1.length(), n = s2.length();
        s1 = " " + s1;
        s2 = " " + s2;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                if (s1.charAt(i) == s2.charAt(j))
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
        return dp[m][n];
    }

二、不相交的线

题目链接：不相交的线
题目描述：

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。现在，可以绘制⼀些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：
• nums1[i] == nums2[j]
• 且绘制的直线不与任何其他连线（非水平线）相交。
请注意，连线即使在端点也不能相交：每个数字只能属于⼀条连线。以这种方法绘制线条，并返回可以绘制的最大连线数。
示例 1：

输⼊：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2 解释：可以画出两条不交叉的线，如上图所示。但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从nums1[2]=2 到 nums2[1]=2 的直线相交。
示例 2：输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3
示例 3：输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

解法（动态规划）：
算法思路：如果要保证两条直线不相交，那么我们「下⼀个连线」必须在「上⼀个连线」对应的两个元素的「后面」寻找相同的元素。这不就转化成「最长公共子序列」的模型了嘛。那就是在这两个数组中寻找「最长的公共子序列」。
只不过是在整数数组中做⼀次「最长的公共子序列」，代码几乎⼀模⼀样，这里就不再赘述算法原理啦~
代码示例：

 public int maxUncrossedLines(int[] nums1, int[] nums2) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = nums1.length, n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] +
                        1;
                else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
        return dp[m][n];
    }

三、不同的子序列

题目链接：不同的子序列
题目描述：

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。字符串的⼀个子序列是指，通过删除⼀些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的⼀个子序列，而 “AEC” 不是）题目数据保证答案符合 32 位带符号整数范围。
示例 1：输入：s = “rabbbit”, t = “rabbit” 输出：3 解释：如下图所示, 有 3 种可以从 s 中得到 “rabbit” 的⽅案。
rabbbit
rabbbit
rabbbit
示例 2：输⼊：s = “babgbag”, t = “bag” 输出：5
解释：如下图所示, 有 5 种可以从 s 中得到 “bag” 的⽅案。
babgbag
babgbag
babgbag
babgbag
babgbag

解法（动态规划）：算法思路：
状态表示：对于两个字符串之间的 dp 问题，我们⼀般的思考方式如下：
i. 选取第⼀个字符串的 [0, i] 区间以及第⼆个字符串的 [0, j] 区间当成研究对象，结合题目的要求来定义「状态表示」；
ii. 然后根据两个区间上「最后⼀个位置的字符」，来进行「分类讨论」，从而确定「状态转移方程」。
我们可以根据上面的策略，解决大部分关于两个字符串之间的 dp 问题。
dp[i][j] 表示：在字符串 s 的 [0, j] 区间内的所有子序列中，有多少个 t 字符串 [0,
i] 区间内的子串。
状态转移方程：老规矩，根据「最后⼀个位置」的元素，结合题目要求，分情况讨论：
i. 当 t[i] == s[j] 的时候，此时的⼦序列有两种选择： • ⼀种选择是：子序列选择 s[j] 作为结尾，此时相当于在状态 dp[i - 1][j - 1]
中的所有符合要求的⼦序列的后⾯，再加上⼀个字符 s[j] （请大家结合状态表示，好好理解这句话），此时 dp[i][j] = dp[i - 1][j - 1] ； • 另⼀种选择是：我就是任性，我就不选择 s[j] 作为结尾。此时相当于选择了状态dp[i][j - 1] 中所有符合要求的⼦序列。我们也可以理解为继承了上个状态⾥⾯的求得的⼦序列。此时 dp[i][j] = dp[i][j - 1] ；两种情况加起来，就是 t[i] == s[j] 时的结果。
ii. 当 t[i] != s[j] 的时候，此时的⼦序列只能从 dp[i][j - 1] 中选择所有符合要求的子序列。只能继承上个状态里面求得的子序列， dp[i][j] = dp[i][j - 1] ；综上所述，状态转移方程为：
▪ 所有情况下都可以继承上⼀次的结果： dp[i][j] = dp[i][j - 1] ； ▪ 当 t[i] == s[j] 时，可以多选择⼀种情况： dp[i][j] += dp[i - 1][j - 1]
初始化：
a. 「空串」是有研究意义的，因此我们将原始 dp 表的规模多加上⼀⾏和⼀列，表⽰空串。
b. 引⼊空串后，⼤⼤的⽅便我们的初始化。
c. 但也要注意「下标的映射关系」，以及⾥⾯的值要「保证后续填表是正确的」。
当 s 为空时， t 的子串中有⼀个空串和它⼀样，因此初始化第⼀⾏全部为 1 。
填表顺序：「从上往下」填每⼀行，每⼀行「从左往右」。
返回值：根据「状态表⽰」，返回 dp[m][n] 的值。
代码示例：

 public int numDistinct(String s, String t) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = t.length(), n = s.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int j = 0; j <= n; j++) dp[0][j] = 1;
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++) {
                dp[i][j] = dp[i][j - 1];
                if (t.charAt(i - 1) == s.charAt(j - 1))
                    dp[i][j] += dp[i - 1][j - 1];
            }

        return dp[m][n];
    }

四、通配符匹配

题目链接：通配符匹配
题目描述：

给定⼀个字符串 (s) 和⼀个字符模式 § ，实现⼀个⽀持 ‘?’ 和 ’ * ’ 的通配符匹配。
‘?’ 可以匹配任何单个字符。
’ * ’ 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。说明: s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和。
示例 1:
输⼊: s = “aa” p = “a” 输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
示例 2:
输入: s = “aa” p = ""
输出: true
解释: ‘’ 可以匹配任意字符串。
示例 3:
输入: s = “cb” p = “?a” 输出: false
解释: ‘?’ 可以匹配 ‘c’, 但第⼆个 ‘a’ ⽆法匹配 ‘b’。⽰例 4:
输入: s = “adceb” p = “ab” 输出: true
解释: 第⼀个 '’ 可以匹配空字符串, 第⼆个 '’ 可以匹配字符串 “dce”. ⽰例 5:
输⼊: s = “acdcb” p = "ac?b" 输出: false

解法（动态规划）：
算法思路：
状态表示：对于两个字符串之间的 dp 问题，我们⼀般的思考⽅式如下：
i. 选取第⼀个字符串的 [0, i] 区间以及第二个字符串的 [0, j] 区间当成研究对象，结合题目的要求来定义「状态表示」；
ii. 然后根据两个区间上「最后⼀个位置的字符」，来进行「分类讨论」，从而确定「状态转移方程」。
我们可以根据上⾯的策略，解决大部分关于两个字符串之间的 dp 问题。因此，我们定义状态表示为：
dp[i][j] 表示： p 字符串 [0, j] 区间内的子串能否匹配字符串 s 的 [0, i] 区间内的⼦串。
状态转移方程：老规矩，根据最后⼀个位置的元素，结合题目要求，分情况讨论：
i. 当 s[i] == p[j] 或 p[j] == ‘?’ 的时候，此时两个字符串匹配上了当前的⼀个字符，只能从 dp[i - 1][j - 1] 中看当前字符前⾯的两个子串是否匹配。只能继承上个状态中的匹配结果， dp[i][j] = dp[i][j - 1] ；
ii. 当 p[j] == ‘’ 的时候，此时匹配策略有两种选择：
• ⼀种选择是： * 匹配空字符串，此时相当于它匹配了⼀个寂寞，直接继承状态 dp[i][j - 1] ，此时 dp[i][j] = dp[i][j - 1] ；
• 另⼀种选择是： * 向前匹配 1 ~ n 个字符，直⾄匹配上整个 s1 串。此时相当于从 dp[k][j - 1] (0 <= k <= i) 中所有匹配情况中，选择性继承可以成功的情况。此时 dp[i][j] = dp[k][j - 1] (0 <= k <= i) ；
iii. 当 p[j] 不是特殊字符，且不与 s[i] 相等时，无法匹配。三种情况加起来，就是所有可能的匹配结果。综上所述，状态转移⽅程为： ▪ 当 s[i] == p[j] 或 p[j] == ‘?’ 时： dp[i][j] = dp[i][j - 1] ； ▪ 当 p[j] == '’ 时，有多种情况需要讨论： dp[i][j] = dp[k][j - 1] (0 <= k <= i) ；优化：当我们发现，计算⼀个状态的时候，需要⼀个循环才能搞定的时候，我们要想到去优化。优化的⽅向就是用⼀个或者两个状态来表示这⼀堆的状态。通常就是把它写下来，然后⽤数学的方式做⼀下等价替换：当 p[j] == '’ 时，状态转移方程为：dp[i][j] = dp[i][j - 1] || dp[i - 1][j - 1] || dp[i - 2][j - 1] …
我们发现 i 是有规律的减小的，因此我们去看看 dp[i - 1][j] ：dp[i - 1][j] = dp[i - 1][j - 1] || dp[i - 2][j - 1] || dp[i - 3][j - 1] …
我们惊奇的发现， dp[i][j] 的状态转移⽅程⾥⾯除了第⼀项以外，其余的都可以用 dp[i - 1][j] 替代。因此，我们优化我们的状态转移⽅程为： dp[i][j] = dp[i - 1][j] || dp[i][j - 1] 。
初始化：由于 dp 数组的值设置为是否匹配，为了不与答案值混淆，我们需要将整个数组初始化为
false 。由于需要用到前一行和前一列的状态，我们初始化第一行、第⼀列即可。
◦ dp[0][0] 表⽰两个空串能否匹配，答案是显然的，初始化为 true 。
◦ 第一行表示 s 是⼀个空串， p 串和空串只有⼀种匹配可能，即 p 串表示为 "*" ，此时也相当于空串匹配上空串。所以，我们可以遍历 p 串，把所有前导为 "" 的 p ⼦串和空串的 dp 值设为 true 。 ◦ 第⼀列表示p 是⼀个空串，不可能匹配上 s 串，跟随数组初始化即可。
填表顺序：
从上往下填每一行，每⼀行从左往右。
返回值：根据状态表示，返回 dp[m][n] 的值。
代码示例

 public boolean isMatch(String ss, String pp) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回结果
        int m = ss.length(), n = pp.length();
        ss = " " + ss;
        pp = " " + pp;
        char[] s = ss.toCharArray();
        char[] p = pp.toCharArray();
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        for (int j = 1; j <= n; j++)
            if (p[j] == '*') dp[0][j] = true;
            else break;

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                if (p[j] == '*')
                    dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
                else
                    dp[i][j] = (p[j] == '?' || p[j] == s[i]) && dp[i - 1][j -1];
        return dp[m][n];
    }

五、交错字符串

题目链接：
题目描述：

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错组成的。
两个字符串 s 和 t 交错的定义与过程如下，其中每个字符串都会被分割成若干非空子字符串： s = s1 + s2 + … + sn
t = t1 + t2 + … + tm |n - m| <= 1 交错是 s1 + t1 + s2 + t2 + s3 + t3 + … 或者 t1 + s1 + t2 + s2 + t3 + s3 + …
注意：a + b 意味着字符串 a 和 b 连接。
示例 1：

输⼊：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac” 输出：true
示例 2：输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出：false
示例 3：输入：s1 = “”, s2 = “”, s3 = “”
输出：true

解法（动态规划）：算法思路：对于两个字符串之间的 dp 问题，我们⼀般的思考⽅式如下：
i. 选取第⼀个字符串的 [0, i] 区间以及第⼆个字符串的 [0, j] 区间当成研究对象，结合题⽬的要求来定义「状态表⽰」；
ii. 然后根据两个区间上「最后⼀个位置的字符」，来进⾏「分类讨论」，从⽽确定「状态转移⽅程」。
我们可以根据上⾯的策略，解决⼤部分关于两个字符串之间的 dp 问题。
这道题⾥⾯空串是有研究意义的，因此我们先预处理⼀下原始字符串，前⾯统⼀加上⼀个占位符：
s1 = " " + s1, s2 = " " + s2, s3 = " " + s3 。
状态表⽰：
dp[i][j] 表⽰字符串 s1 中 [1, i] 区间内的字符串以及 s2 中 [1, j] 区间内的字符串，能否拼接成 s3 中 [1, i + j] 区间内的字符串。
状态转移⽅程：先分析⼀下题目，题目中交错后的字符串为 s1 + t1 + s2 + t2 + s3 + t3… ，看似⼀个 s ⼀个 t 。实际上 s1 能够拆分成更小的⼀个字符，进而可以细化成 s1 + s2 + s3 + t1 + t2 + s4… 。也就是说，并不是前⼀个用了 s 的子串，后⼀个必须要用 t 的子串。这⼀点理解，对我们的状态转移很重要。
继续根据两个区间上「最后⼀个位置的字符」，结合题目的要求，来进行「分类讨论」：
i. 当 s3[i + j] = s1[i] 的时候，说明交错后的字符串的最后⼀个字符和 s1 的最后⼀个字符匹配了。那么整个字符串能否交错组成，变成：s1 中 [1, i - 1] 区间上的字符串以及 s2 中 [1, j] 区间上的字符串，能够交错形成 s3 中 [1, i + j - 1] 区间上的字符串，也就是 dp[i - 1][j]；此时 dp[i][j] = dp[i - 1][j]
ii. 当 s3[i + j] = s2[j] 的时候，说明交错后的字符串的最后⼀个字符和 s2 的最后⼀个字符匹配了。那么整个字符串能否交错组成，变成：s1 中 [1, i] 区间上的字符串以及 s2 中 [1, j - 1] 区间上的字符串，能够交错形成 s3 中 [1, i + j - 1] 区间上的字符串，也就是 dp[i][j - 1] ；
iii. 当两者的末尾都不等于 s3 最后⼀个位置的字符时，说明不可能是两者的交错字符串。上述三种情况下，只要有⼀个情况下能够交错组成目标串，就可以返回 true 。因此，我们可以定义状态转移为：
dp[i][j] = (s1[i - 1] == s3[i + j - 1] && dp[i - 1][j]) || (s2[j - 1] == s3[i + j - 1] && dp[i][j - 1])
只要有⼀个成立，结果就是 true 。
初始化：由于用到 i - 1 , j - 1 位置的值，因此需要初始化「第⼀个位置」以及「第⼀行」和「第⼀列」。
◦ 第⼀个位置：
dp[0][0] = true ，因为空串 + 空串能够构成⼀个空串。
◦ 第⼀行：第⼀行表示 s1 是⼀个空串，我们只用考虑 s2 即可。因此状态转移之和 s2 有关：
dp[0][j] = s2[j - 1] == s3[j - 1] && dp[0][j - 1] ， j 从 1 到 n （ n 为 s2 的⻓度） ◦ 第⼀列：第⼀列表⽰ s2 是⼀个空串，我们只⽤考虑 s1 即可。因此状态转移之和 s1 有关：
dp[i][0] = s1[i - 1] == s3[i - 1] && dp[i - 1][0] ， i 从 1 到 m （ m 为 s1 的长度）
填表顺序：根据「状态转移」，我们需要「从上往下」填每⼀行，每一行「从左往右」。
返回值：根据「状态表示」，我们需要返回 dp[m][n] 的值。
代码示例：

public boolean isInterleave(String s1, String s2, String s3) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = s1.length(), n = s2.length();
        if (m + n != s3.length()) return false; // 处理下边界条件
        s1 = " " + s1;
        s2 = " " + s2;
        s3 = " " + s3;
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true; // 初始化
        for (int j = 1; j <= n; j++) // 初始化第⼀⾏
            if (s2.charAt(j) == s3.charAt(j)) dp[0][j] = true;
            else break;
        for (int i = 1; i <= m; i++) // 初始化第⼀列
            if (s1.charAt(i) == s3.charAt(i)) dp[i][0] = true;
            else break;

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                dp[i][j] = (s1.charAt(i) == s3.charAt(i + j) && dp[i - 1][j])
                        || (s2.charAt(j) == s3.charAt(i + j) && dp[i][j - 1]);
        return dp[m][n];
    }

六、两个字符串的最小ASCII删除和

题目链接：两个字符串的最小ASCII删除和
题目描述：

给定两个字符串s1 和 s2，返回使两个字符串相等所需删除字符的 ASCII 值的最小和。
示例 1:输⼊: s1 = “sea”, s2 = “eat” 输出: 231
解释:在 “sea” 中删除 “s” 并将 “s” 的值(115)加⼊总和。在 “eat” 中删除 “t” 并将 116 加⼊总和。结束时，两个字符串相等，115 + 116 = 231 就是符合条件的最⼩和。⽰例 2:
输⼊: s1 = “delete”, s2 = “leet” 输出: 403
解释:
在 “delete” 中删除 “dee” 字符串变成 “let”，将 100[d]+101[e]+101[e] 加⼊总和。在 “leet” 中删除 “e” 将 101[e] 加⼊总和。结束时，两个字符串都等于 “let”，结果即为 100+101+101+101 = 403 。如果改为将两个字符串转换为 “lee” 或 “eet”，我们会得到 433 或 417 的结果，比答案更大。

解法（动态规划）：
算法思路：正难则反：求两个字符串的最小ASCII 删除和，其实就是找到两个字符串中所有的公共子序列里面， ASCII 最大和。因此，我们的思路就是按照「最长公共子序列」的分析方式来分析。
状态表示：
dp[i][j] 表示： s1 的 [0, i] 区间以及 s2 的 [0, j] 区间内的所有的子序列中，公共⼦序列的 ASCII 最⼤和。
状态转移⽅程：对于 dp[i][j] 根据「最后⼀个位置」的元素，结合题目要求，分情况讨论：
i. 当 s1[i] == s2[j] 时：应该先在 s1 的 [0, i - 1] 区间以及 s2 的 [0, j - 1] 区间内找⼀个公共⼦序列的最⼤和，然后在它们后面加上⼀个 s1[i] 字符即可。此时 dp[i][j] = dp[i - 1][j - 1] + s1[i] ；
ii. 当 s1[i] != s2[j] 时：公共⼦序列的最大和会有三种可能：
• s1 的 [0, i - 1] 区间以及 s2 的 [0, j] 区间内：此时 dp[i][j] = dp[i - 1][j] ； • s1 的 [0, i] 区间以及 s2 的 [0, j - 1] 区间内：此时 dp[i][j] = dp[i][j - 1] ； • s1 的 [0, i - 1] 区间以及 s2 的 [0, j - 1] 区间内：此时 dp[i][j] = dp[i - 1][j - 1] 。但是前两种情况⾥⾯包含了第三种情况，因此仅需考虑前两种情况下的最⼤值即可。综上所述，状态转移方程为：
◦ 当 s1[i - 1] == s2[j - 1] 时， dp[i][j] = dp[i - 1][j - 1] + s1[i] ；
◦ 当 s1[i - 1] != s2[j - 1] 时， dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
初始化：
a. 「空串」是有研究意义的，因此我们将原始 dp 表的规模多加上⼀⾏和⼀列，表⽰空串。
b. 引⼊空串后，大大的「方便我们的初始化」。
c. 但也要注意「下标的映射」关系，以及里面的值要保证「后续填表是正确的」。
当 s1 为空时，没有长度，同理 s2 也是。因此第一行和第⼀列里面的值初始化为 0 即可保证后续填表是正确的。
填表顺序：「从上往下」填每一行，每⼀行「从左往右」。
返回值：根据「状态表示」，我们不能直接返回 dp 表里面的某个值：
i. 先找到 dp[m][n] ，也是最大公共 ASCII 和；
ii. 统计两个字符串的 ASCII 码和 s u m；
iii. 返回 sum - 2 * dp[m][n]
代码示例：

 public int minimumDeleteSum(String s1, String s2) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = s1.length(), n = s2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++) {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (s1.charAt(i - 1) == s2.charAt(j - 1))
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + s1.charAt(i - 1));
            }

        int sum = 0; // 统计元素和
        for (char ch : s1.toCharArray()) sum += ch;
        for (char ch : s2.toCharArray()) sum += ch;
        return sum - dp[m][n] - dp[m][n];
    }

七、最长重复子数组

题目链接：最长重复子数组
题目描述：

给两个整数数组 nums1 和 nums2 ，返回两个数组中公共的、长度最长的子数组的长度。
示例 1：输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3 解释：长度最长的公共子数组是 [3,2,1] 。
示例 2：输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

解法（动态规划）：算法思路：⼦数组是数组中「连续」的⼀段，我们习惯上「以某⼀个位置为结尾」来研究。由于是两个数组，因此我们可以尝试：以第⼀个数组的 i 位置为结尾以及第⼆个数组的 j 位置为结尾来解决问题。
状态表示：
dp[i][j] 表示「以第⼀个数组的 i 位置为结尾」，以及「第⼆个数组的 j 位置为结尾公共的、长度最长的「子数组」的长度。
状态转移⽅程：对于 dp[i][j] ，当 nums1[i] == nums2[j] 的时候，才有意义，此时最长重复子数组的长度应该等于 1 加上除去最后⼀个位置时，以 i - 1, j - 1 为结尾的最长重复子数组的长度。因此，状态转移方程为： dp[i][j] = 1 + dp[i - 1][j - 1]
初始化：为了处理「越界」的情况，我们可以添加⼀行和一列， dp 数组的下标从 1 开始，这样就无需初始化。第⼀行表示第⼀个数组为空，此时没有重复子数组，因此里面的值设置成 0 即可；第一列也是同理。
填表顺序：根据「状态转移」，我们需要「从上往下」填每⼀行，每⼀行「从左往右」。
返回值：根据「状态表示」，我们需要返回 dp 表里面的「最大值」。
代码示例：

 public int findLength(int[] nums1, int[] nums2) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值
        int m = nums1.length, n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        int ret = 0;
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    ret = Math.max(ret, dp[i][j]);
                }
        return ret;
    }