712. 两个字符串的最小ASCII删除和

链表算法题（程序员面试宝典）

解题思路主要来源于leetcode官方与《程序员面试宝典》。

712. 两个字符串的最小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 的结果，比答案更大。
注意:

0 < s1.length, s2.length <= 1000。
所有字符串中的字符ASCII值在[97, 122]之间。

解题方法

参考资料1:https://mp.weixin.qq.com/s/ZhPEchewfc03xWv9VP3msg

解题思路1

class Solution {

    //备忘录
    int[][] memo;
    public int minimumDeleteSum(String s1, String s2) {
        //带备忘录的递归法
        //与最长公共子序列算法相似
        memo = new int[s1.length()][s2.length()];
        for(int[] row:memo){
            //-1 表示未进行操作
            Arrays.fill(row,-1);
        }

        return dp(s1,0,s2,0);
    }

    //定义：将 s1[i..] s2[j..] 删除成相同的子序列，最小的 ASCII 码之和为 dp(s1, i, s2, j)
    public int dp(String s1,int i,String s2,int j){

        //base case
        int res = 0;
        if(i==s1.length()){
            //如果一个字符串为空，肯定要将另一个字符串删除完
            for(;j<s2.length();j++){
                res += s2.charAt(j);
            }
            return res;
        }
        if(j==s2.length()){
            //如果一个字符串为空，肯定要将另一个字符串删除完
            for(;i<s1.length();i++){
                res += s1.charAt(i);
            }
            return res;
        }

        if(memo[i][j]!=-1){
            return memo[i][j];
        }

        if(s1.charAt(i)==s2.charAt(j)){
            //不进行删除操作
            memo[i][j] = dp(s1,i+1,s2,j+1);
        }else{
            //s1[i] s2[j] 至少删除一个
            memo[i][j] = Math.min(
                s1.charAt(i) + dp(s1,i+1,s2,j),
                s2.charAt(j) + dp(s1,i,s2,j+1)
            );
        }
        return memo[i][j];

    }
}

解题思路2

动态规划，迭代

class Solution {


    public int minimumDeleteSum(String s1, String s2) {

        //动态规划 迭代
        //dp[i][j] 代表s1[1..i]  s2[1..j] 删除成相同子序列，最小的ASCII值
        int[][] dp = new int[s1.length()+1][s2.length()+1];
        //base case
        for(int[] row:dp){
            Arrays.fill(row,0);
        }
        int val = 0;
        for(int i=1;i<=s1.length();i++){
            val += s1.charAt(i-1);
            dp[i][0] = val;  
        }
        val = 0;
        for(int i=1;i<=s2.length();i++){
            val += s2.charAt(i-1);
            dp[0][i] = val;  
        }

        for(int i=1;i<=s1.length();i++){
            for(int j=1;j<=s2.length();j++){
                if(s1.charAt(i-1)==s2.charAt(j-1)){
                    //相同的字符不用进行删除操作
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    //不同的话，s1[i-1] s2[j-1] 两个至少删除一个字符
                    dp[i][j] = Math.min(s1.charAt(i-1)+dp[i-1][j],s2.charAt(j-1)+dp[i][j-1]);
                }
            }
        }

        return dp[s1.length()][s2.length()];

    }

    
}

解题思路3

class Solution {


    public int minimumDeleteSum(String s1, String s2) {
        //将最小ASCII删除和  转换为最大公共子序列的最大ASCII值和
        //动态规划 迭代
        //dp[i][j] 代表s1[1..i]  s2[1..j] 中最大公共子序列的最大ACSII值
        int[][] dp = new int[s1.length()+1][s2.length()+1];
        //base case
        for(int[] row:dp){
            Arrays.fill(row,0);
        }

        for(int i=1;i<=s1.length();i++){
            for(int j=1;j<=s2.length();j++){
                if(s1.charAt(i-1)==s2.charAt(j-1)){
                    //相同的字符
                    dp[i][j] = dp[i-1][j-1]+s1.charAt(i-1);
                }else{
                    //不同的话，
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        int sum = 0;
        for(int i=0;i<s1.length();i++){
            sum += s1.charAt(i);
        }
        for(int i=0;i<s2.length();i++){
            sum += s2.charAt(i);
        }

        //返回值：两数的ASCII值和  减去 2* 最大公共子序列的最大ASCII值和
        return sum-2*dp[s1.length()][s2.length()];

    }
}