【LeetCode】动态规划—712. 两个字符串的最小ASCII删除和（附完整Python/C++代码）

动态规划---712. 两个字符串的最小ASCII删除和

• 前言
• 题目描述
• 基本思路
• • [1. 问题定义](#1. 问题定义)
  • [2. 理解问题和递推关系](#2. 理解问题和递推关系)
  • [3. 解决方法](#3. 解决方法)
  • • [3.1 动态规划方法](#3.1 动态规划方法)
    • [3.2 空间优化的动态规划](#3.2 空间优化的动态规划)
  • [4. 进一步优化](#4. 进一步优化)
  • [5. 小总结](#5. 小总结)
• 代码实现
• • Python
  • • Python3代码实现
    • [Python 代码解释](#Python 代码解释)
  • C++
  • • C++代码实现
    • [C++ 代码解释](#C++ 代码解释)
• 总结:

前言

在字符串处理的过程中，如何有效地将两个字符串转换为相同的形式是一个重要的问题。最小 ASCII 删除和问题提供了一种评估字符串相似性的有效方法，通过计算所需删除字符的 ASCII 值和，为我们提供了清晰的转换成本。本文将探讨这一问题的基本思路，并给出动态规划的实现方法，最后展示 Python 和 C++ 的具体代码。

题目描述

基本思路

1. 问题定义

最小 ASCII 删除和问题要求我们找出将两个字符串 s 1 s 1 s1 和 s 2 s 2 s2 转换为相同字符串所需删除的字符的最小 ASCII 值之和。换句话说，计算出为了使两个字符串相同，所需删除的字符的 ASCII 值的总和。

2. 理解问题和递推关系

• 对于两个字符串 s 1 s 1 s1 和 s 2 s 2 s2 ，我们可以定义 dp[i][j] 为将 s 1 s 1 s1 的前 i i i 个字符和 s 2 s 2 s2 的前 j个字符变为相同的最小 ASCII 删除和。
• 递推关系如下：
  • 如果 s 1 [ i − 1 ] = = s 2 [ j − 1 ] s 1[i-1]==s 2[j-1] s1[i−1]==s2[j−1] ，那么不需要删除任何字符， d p [ i ] [ j ] = d p [ i − 1 ] [ j − 1 ] d p[i][j]=d p[i-1][j-1] dp[i][j]=dp[i−1][j−1] 。
  • 如果 s 1 [ i − 1 ] ! = s 2 [ j − 1 ] s 1[i-1]!=s 2[j-1] s1[i−1]!=s2[j−1], 则有三种情况:
    • 删除 s 1 [ i − 1 ] s1[i-1] s1[i−1]，代价为 ord ⁡ ( s 1 [ i − 1 ] ) + d p [ i − 1 ] [ j ] \operatorname{ord}(s 1[i-1])+d p[i-1][j] ord(s1[i−1])+dp[i−1][j] 。
    • 删除 s 2 [ j − 1 ] s 2[j-1] s2[j−1] ，代价为 ord ⁡ ( s 2 [ j − 1 ] ) + d p [ i ] [ j − 1 ] \operatorname{ord}(s 2[j-1])+d p[i][j-1] ord(s2[j−1])+dp[i][j−1] 。
    • 同时删除 s 1 [ i − 1 ] s 1[i-1] s1[i−1] 和 s 2 [ j − 1 ] s 2[j-1] s2[j−1] ，代价为 ord ⁡ ( s 1 [ i − 1 ] ) + ord ⁡ ( s 2 [ j − 1 ] ) + dp ⁡ [ i − 1 ] [ j − \operatorname{ord}(s 1[i-1])+\operatorname{ord}(s 2[j-1])+\operatorname{dp}[i-1][j- ord(s1[i−1])+ord(s2[j−1])+dp[i−1][j− 1].
  • 因此，综合以上情况:

d p [ i ] [ j ] = min ⁡ ( d p [ i − 1 ] [ j ] + ord ⁡ ( s 1 [ i − 1 ] ) , d p [ i ] [ j − 1 ] + ord ⁡ ( s 2 [ j − 1 ] ) , d p [ i − 1 ] [ j − 1 ] + ord ⁡ ( s 1 [ i − 1 ] ) + ord ⁡ ( s 2 [ j − 1 ] ) ) d p[i][j]=\min (d p[i-1][j]+\operatorname{ord}(s 1[i-1]), d p[i][j-1]+\operatorname{ord}(s 2[j-1]), d p[i-1][j-1]+\operatorname{ord}(s 1[i-1])+\operatorname{ord}(s 2[j-1])) dp[i][j]=min(dp[i−1][j]+ord(s1[i−1]),dp[i][j−1]+ord(s2[j−1]),dp[i−1][j−1]+ord(s1[i−1])+ord(s2[j−1]))

3. 解决方法

3.1 动态规划方法

1. 创建一个二维数组 d p d p dp ，大小为 ( m + 1 ) × ( n + 1 ) (m+1) \times(n+1) (m+1)×(n+1) ，其中 m m m 和 n n n 分别是 s 1 s 1 s1 和 s 2 s 2 s2 的长度。
2. 初始化边界条件：
   • d p [ i ] [ 0 ] = ∑ k = 0 i − 1 ord ( s 1 [ k ] ) dp[i][0]=\sum_{k=0}^{i-1} \text{ord}(s1[k]) dp[i][0]=∑k=0i−1ord(s1[k])，表示将 s 1 s 1 s1 的前 i i i 个字符转换为空字符串所需删除的 ASCII 值之和。
   • d p [ 0 ] [ j ] = ∑ k = 0 j − 1 ord ( s 2 [ k ] ) dp[0][j]=\sum_{k=0}^{j-1} \text{ord}(s2[k]) dp[0][j]=∑k=0j−1ord(s2[k])，表示将 s 2 s 2 s2 的前 j j j 个字符转换为空字符串所需删除的 ASCII 值之和。
3. 使用双重石环填充 dp 数组，依赖于前面的状态。
4. 最终结果为 d p [ m ] [ n ] \mathrm{dp}[\mathrm{m}][\mathrm{n}] dp[m][n] 。

3.2 空间优化的动态规划

• 可以使用一维数组来优化空间复杂度，减少内存占用。

4. 进一步优化

通过空间优化，降低内存占用的同时保持时间复杂度为 O ( m ∗ n ) O(m * n) O(m∗n)，适合中等规模的字符串比较。

5. 小总结

• 最小 ASCII 删除和问题通过动态规划有效地解决了两个字符串之间的转换成本。
• 该问题的解法展示了如何设计状态转移方程，并且可以通过空间优化提高性能。
• 理解该问题不仅有助于掌握动态规划的应用，还为处理相似问题提供了思路。

以上就是两个字符串的最小ASCII删除和问题的基本思路。

代码实现

Python

Python3代码实现

class Solution:
    def minimumDeleteSum(self, s1: str, s2: str) -> int:
        m, n = len(s1), len(s2)
        # 创建dp数组
        dp = [[0] * (n + 1) for _ in range(m + 1)]

        # 初始化边界条件
        for i in range(1, m + 1):
            dp[i][0] = dp[i - 1][0] + ord(s1[i - 1])  # 删除s1的字符
        for j in range(1, n + 1):
            dp[0][j] = dp[0][j - 1] + ord(s2[j - 1])  # 删除s2的字符
        
        # 填充dp数组
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if s1[i - 1] == s2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1]  # 字符相同
                else:
                    dp[i][j] = min(dp[i - 1][j] + ord(s1[i - 1]),    # 删除s1的字符
                                   dp[i][j - 1] + ord(s2[j - 1]),    # 删除s2的字符
                                   dp[i - 1][j - 1] + ord(s1[i - 1]) + ord(s2[j - 1]))  # 同时删除

        # 返回最小ASCII删除和
        return dp[m][n]

Python 代码解释

• 初始化 ：创建 dp 数组并设置边界条件，分别表示将 s1 和 s2 转换为空字符串的操作。
• 填充 dp 数组：使用双重循环计算每个子问题的最小 ASCII 删除和，依赖于之前的结果。
• 返回结果 ：最终返回 dp[m][n]，即将 s1 转换为 s2 所需的最小 ASCII 删除和。

C++

C++代码实现

class Solution {
public:
    int minimumDeleteSum(string s1, string s2) {
        int m = s1.size(), n = s2.size();
        // 创建dp数组
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));

        // 初始化边界条件
        for (int i = 1; i <= m; i++) {
            dp[i][0] = dp[i - 1][0] + s1[i - 1];  // 删除s1的字符
        }
        for (int j = 1; j <= n; j++) {
            dp[0][j] = dp[0][j - 1] + s2[j - 1];  // 删除s2的字符
        }
        
        // 填充dp数组
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1[i - 1] == s2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];  // 字符相同
                } else {
                    dp[i][j] = min({dp[i - 1][j] + s1[i - 1],    // 删除s1的字符
                                    dp[i][j - 1] + s2[j - 1],    // 删除s2的字符
                                    dp[i - 1][j - 1] + s1[i - 1] + s2[j - 1]});  // 同时删除
                }
            }
        }

        // 返回最小ASCII删除和
        return dp[m][n];
    }
};

C++ 代码解释

• 初始化 ：创建 dp 数组并设置边界条件，分别表示将 s1 和 s2 转换为空字符串的操作。
• 动态规划填充：使用双重循环遍历每个可能的子问题，依据字符是否相同来更新 dp 数组。
• 返回结果 ：返回 dp[m][n]，即将 s1 转换为 s2 所需的最小 ASCII 删除和。

---

总结:

• 最小 ASCII 删除和问题通过动态规划有效地解决了字符串之间的转换成本，具有广泛的实际应用。
• 理解并掌握该问题的解法，不仅对学习动态规划有帮助，还为处理其他类似问题提供了思路。