[Swift]LeetCode712. 两个字符串的最小ASCII删除和 | Minimum ASCII Delete Sum for Two Strings

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10506712.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given two strings s1, s2, find the lowest ASCII sum of deleted characters to make two strings equal.

Example 1:

Input: s1 = "sea", s2 = "eat"
Output: 231
Explanation: Deleting "s" from "sea" adds the ASCII value of "s" (115) to the sum.
Deleting "t" from "eat" adds 116 to the sum.
At the end, both strings are equal, and 115 + 116 = 231 is the minimum sum possible to achieve this.

Example 2:

Input: s1 = "delete", s2 = "leet"
Output: 403
Explanation: Deleting "dee" from "delete" to turn the string into "let",
adds 100[d]+101[e]+101[e] to the sum.  Deleting "e" from "leet" adds 101[e] to the sum.
At the end, both strings are equal to "let", and the answer is 100+101+101+101 = 403.
If instead we turned both strings into "lee" or "eet", we would get answers of 433 or 417, which are higher.

Note:

• 0 < s1.length, s2.length <= 1000.
• All elements of each string will have an ASCII value in [97, 122].

---

给定两个字符串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]之间。

---

Runtime: 196 ms

Memory Usage: 20 MB

class Solution {
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
        var arr1:[Character] = Array(s1)
        var arr2:[Character] = Array(s2)
        var nums1:[Int] = arr1.map{$0.ascii}
        var nums2:[Int] = arr2.map{$0.ascii}
        var m:Int = s1.count
        var n:Int = s2.count
        var dp:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n + 1),count:m + 1)
        for i in 1...m
        {
            for j in 1...n
            {
                if arr1[i - 1] == arr2[j - 1]
                {
                    dp[i][j] = dp[i - 1][j - 1] + nums1[i - 1]
                }
                else
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
                }
            }
        }
        var sum1:Int = nums1.reduce(0,+)
        var sum2:Int = nums2.reduce(0,+)
        return sum1 + sum2 - 2 * dp[m][n]
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }    
}

---

200ms

final class Solution {
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
        let s1 = Array(s1.utf8).map(Int.init)
        let s2 = Array(s2.utf8).map(Int.init)
        var dp = [[Int]](repeating: Array(repeating: 0, count: s2.count &+ 1), count: s1.count &+ 1)
        
        for i in 0..<s1.count {
            dp[i &+ 1][0] = dp[i][0] &+ s1[i]
        }
        for j in 0..<s2.count {
            dp[0][j &+ 1] = dp[0][j] &+ s2[j]
        }
        for i in 1..<s1.count &+ 1 {
            for j in 1..<s2.count &+ 1 {
                if s1[i - 1] == s2[j - 1] {
                    dp[i][j] = dp[i - 1][j - 1]
                } else {
                    dp[i][j] = min(s2[j - 1] &+ dp[i][j - 1], s1[i - 1] &+ dp[i - 1][j])
                }
            }
        }
        
        return dp[s1.count][s2.count]
    }
}

---

436ms

class Solution {
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
       var v = 97
        var map = [Character: Int]()
       "abcdefghijklmnopqrstuvwxyz".map { map[$0] = v; v += 1}
        let m = s1.count, n = s2.count
        let chars1 = Array(s1), chars2 = Array(s2)
        var dp = [[Int]](repeating: [Int](repeating: 0, count: n+1), count: m+1)
        for j in 1...n {
            dp[0][j] = dp[0][j-1] + map[chars2[j-1]]!
        }
        for i in 1...m {
            dp[i][0] = dp[i-1][0] + map[chars1[i-1]]!
            for j in 1...n {
                if chars1[i-1] == chars2[j-1] {
                    dp[i][j] = dp[i-1][j-1]
                }
                else {
                    dp[i][j] = min(dp[i-1][j] + map[chars1[i-1]]!, dp[i][j-1] + map[chars2[j-1]]!)
                }
            }
        }
        return dp[m][n]
    }
}

extension Character {
    var ascii: Int {
        return Int(unicodeScalars.first?.value ?? 0)
    }
}

---

548ms

class Solution {
    var map = [Character: Int]()
    var ans = Int.max
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
        var v = 97
       "abcdefghijklmnopqrstuvwxyz".map { map[$0] = v; v += 1}
        let m = s1.count, n = s2.count
        let chars1 = Array(s1), chars2 = Array(s2)
        var dp = [[Int]](repeating: [Int](repeating: 0, count: n+1), count: m+1)
        for j in 1...n {
            dp[0][j] = dp[0][j-1] + map[chars2[j-1]]!
        }
        for i in 1...m {
            dp[i][0] = dp[i-1][0] + map[chars1[i-1]]!
            for j in 1...n {
                if chars1[i-1] == chars2[j-1] {
                    dp[i][j] = dp[i-1][j-1]
                }
                else {
                    dp[i][j] = min(dp[i-1][j] + map[chars1[i-1]]!, dp[i][j-1] + map[chars2[j-1]]!)
                }
            }
        }
        return dp[m][n]
    }

    func dfs(_ s1: [Character], _ index1: Int, _ s2: [Character], _ index2: Int, _ sum: Int) {
                
        if sum > ans {
            return
        }

        if index1 >= s1.count && index2 >= s2.count {
            ans = min(ans, sum)
            return
        }

        if index1 < s1.count && index2 < s2.count {

            if s1[index1] == s2[index2] {
                dfs(s1, index1+1, s2, index2+1, sum)
                return
            }
            dfs(s1, index1+1, s2, index2, sum + map[s1[index1]]!)
            dfs(s1, index1, s2, index2+1, sum + map[s2[index2]]!)
            dfs(s1, index1+1, s2, index2+1, sum + map[s2[index2]]! + map[s1[index1]]!)
        }
        else if index1 >= s1.count && index2 < s2.count {            
            dfs(s1, index1, s2, index2+1, sum + map[s2[index2]]!)
        }
        else if index1 < s1.count && index2 >= s2.count {
            dfs(s1, index1+1, s2, index2, sum + map[s1[index1]]!)
        }
    }
}

---

604ms

class Solution {
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
    var mem = [[Int?]](repeating: [Int?](repeating: nil, count: s2.count + 1), count: s1.count + 1)
    return minimumDeleteSumRecursion(Array(s1), Array(s2), 0, s2Index: 0, mem: &mem)
}

func minimumDeleteSumRecursion(_ s1 : [Character], _ s2 : [Character], _ s1Index : Int, s2Index : Int, mem : inout [[Int?]])->Int{
    
    guard s1Index < s1.count || s2Index < s2.count else{
        return 0
    }
    
    if let answer = mem[s1Index][s2Index]{
        return answer
    }
    
    if s1Index == s1.count{
        mem[s1Index][s2Index] = Int(s2[s2Index].unicodeScalars.first!.value) + minimumDeleteSumRecursion(s1, s2, s1Index, s2Index: s2Index + 1, mem: &mem)
        return mem[s1Index][s2Index]!
    }else if s2Index == s2.count{
        mem[s1Index][s2Index] = Int(s1[s1Index].unicodeScalars.first!.value) + minimumDeleteSumRecursion(s1, s2, s1Index + 1, s2Index: s2Index, mem: &mem)
        return mem[s1Index][s2Index]!
    }else{
        if s1[s1Index] == s2[s2Index]{
            mem[s1Index][s2Index] = minimumDeleteSumRecursion(s1, s2, s1Index + 1, s2Index: s2Index + 1, mem: &mem)
            return mem[s1Index][s2Index]!
        }else{
            // we need to delete
            let firstValue = Int(s1[s1Index].unicodeScalars.first!.value) + minimumDeleteSumRecursion(s1, s2, s1Index + 1, s2Index: s2Index, mem: &mem)
            let secondValue = Int(s2[s2Index].unicodeScalars.first!.value) + minimumDeleteSumRecursion(s1, s2, s1Index, s2Index: s2Index + 1, mem: &mem)
            mem[s1Index][s2Index] = min(firstValue, secondValue)
            return mem[s1Index][s2Index]!
        }
    }
  }
}

---

632ms

class Solution {
    func minimumDeleteSum(_ s1: String, _ s2: String) -> Int {
    let s1 = Array(s1)
    let s2 = Array(s2)
    var matrix = [[Int]](repeating: [Int](repeating: 0, count: s2.count + 1), count: s1.count + 1)
    for s1Index in (0..<s1.count).reversed(){
        matrix[s1Index][s2.count] = matrix[s1Index + 1][s2.count] +  Int(s1[s1Index].unicodeScalars.first!.value)
    }
    for s2Index in (0..<s2.count).reversed(){
        matrix[s1.count][s2Index] = matrix[s1.count][s2Index + 1] +  Int(s2[s2Index].unicodeScalars.first!.value)
    }
    for s1Index in (0..<s1.count).reversed(){
        for s2Index in (0..<s2.count).reversed(){
            if s1[s1Index] == s2[s2Index]{
                matrix[s1Index][s2Index] = matrix[s1Index + 1][s2Index + 1]
            }else{
                let firstValue = Int(s1[s1Index].unicodeScalars.first!.value) + matrix[s1Index + 1][s2Index]
                let secondValue = Int(s2[s2Index].unicodeScalars.first!.value) + matrix[s1Index][s2Index + 1]
                matrix[s1Index][s2Index] = min(firstValue, secondValue)
            }
        }
    }
    return matrix[0][0]
    }
}