首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >【LeetCode】动态规划—712. 两个字符串的最小ASCII删除和(附完整Python/C++代码)

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

作者头像
用户9613193
发布2026-06-16 20:01:36
发布2026-06-16 20:01:36
470
举报
动态规划—712. 两个字符串的最小ASCII删除和

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

前言

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

题目描述

在这里插入图片描述
在这里插入图片描述

基本思路

1. 问题定义

最小 ASCII 删除和问题要求我们找出将两个字符串

s 1

s 2

转换为相同字符串所需删除的字符的最小 ASCII 值之和。换句话说,计算出为了使两个字符串相同,所需删除的字符的 ASCII 值的总和。

2. 理解问题和递推关系

  • 对于两个字符串
s 1

s 2

,我们可以定义 dp[i][j] 为将

s 1

的前

i

个字符和

s 2

的前 j个字符变为相同的最小 ASCII 删除和。

  • 递推关系如下:
    • 如果
    s 1[i-1]==s 2[j-1]

    ,那么不需要删除任何字符,

    d p[i][j]=d p[i-1][j-1]

    • 如果
    s 1[i-1]!=s 2[j-1]

    , 则有三种情况:

    • 删除
    s1[i-1]

    ,代价为

    \operatorname{ord}(s 1[i-1])+d p[i-1][j]

    • 删除
    s 2[j-1]

    ,代价为

    \operatorname{ord}(s 2[j-1])+d p[i][j-1]

    • 同时删除
    s 1[i-1]

    s 2[j-1]

    ,代价为

    \operatorname{ord}(s 1[i-1])+\operatorname{ord}(s 2[j-1])+\operatorname{dp}[i-1][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]))

3. 解决方法

3.1 动态规划方法
  1. 创建一个二维数组
d p

,大小为

(m+1) \times(n+1)

,其中

m

n

分别是

s 1

s 2

的长度。

  1. 初始化边界条件:
    dp[i][0]=\sum_{k=0}^{i-1} \text{ord}(s1[k])

    ,表示将

    s 1

    的前

    i

    个字符转换为空字符串所需删除的 ASCII 值之和。

    dp[0][j]=\sum_{k=0}^{j-1} \text{ord}(s2[k])

    ,表示将

    s 2

    的前

    j

    个字符转换为空字符串所需删除的 ASCII 值之和。

  2. 使用双重石环填充 dp 数组,依赖于前面的状态。
  3. 最终结果为
\mathrm{dp}[\mathrm{m}][\mathrm{n}]

3.2 空间优化的动态规划
  • 可以使用一维数组来优化空间复杂度,减少内存占用。

4. 进一步优化

通过空间优化,降低内存占用的同时保持时间复杂度为

O(m * n)

,适合中等规模的字符串比较。

5. 小总结

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

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

代码实现

Python

Python3代码实现
代码语言:javascript
复制
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 数组并设置边界条件,分别表示将 s1s2 转换为空字符串的操作。
  • 填充 dp 数组:使用双重循环计算每个子问题的最小 ASCII 删除和,依赖于之前的结果。
  • 返回结果:最终返回 dp[m][n],即将 s1 转换为 s2 所需的最小 ASCII 删除和。

C++

C++代码实现
代码语言:javascript
复制
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 数组并设置边界条件,分别表示将 s1s2 转换为空字符串的操作。
  • 动态规划填充:使用双重循环遍历每个可能的子问题,依据字符是否相同来更新 dp 数组。
  • 返回结果:返回 dp[m][n],即将 s1 转换为 s2 所需的最小 ASCII 删除和。

总结:

  • 最小 ASCII 删除和问题通过动态规划有效地解决了字符串之间的转换成本,具有广泛的实际应用。
  • 理解并掌握该问题的解法,不仅对学习动态规划有帮助,还为处理其他类似问题提供了思路。
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2024-10-08,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 动态规划—712. 两个字符串的最小ASCII删除和
  • 前言
  • 题目描述
  • 基本思路
    • 1. 问题定义
    • 2. 理解问题和递推关系
    • 3. 解决方法
      • 3.1 动态规划方法
      • 3.2 空间优化的动态规划
    • 4. 进一步优化
    • 5. 小总结
  • 代码实现
    • Python
      • Python3代码实现
      • Python 代码解释
    • C++
      • C++代码实现
      • C++ 代码解释
  • 总结:
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档