前言

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

题目描述

基本思路

1. 问题定义

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

2. 理解问题和递推关系

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

$$dp[i][j]=\min (dp[i-1][j]+\mathrm{ord}(s1[i-1]),dp[i][j-1]+\mathrm{ord}(s2[j-1]),dp[i-1][j-1]+\mathrm{ord}(s1[i-1])+\mathrm{ord}(s2[j-1]))$$

3. 解决方法

3.1 动态规划方法

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

3.2 空间优化的动态规划

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

4. 进一步优化

通过空间优化，降低内存占用的同时保持时间复杂度为 $O(m\ast 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 删除和问题通过动态规划有效地解决了字符串之间的转换成本，具有广泛的实际应用。
• 理解并掌握该问题的解法，不仅对学习动态规划有帮助，还为处理其他类似问题提供了思路。