[Swift]LeetCode72. 编辑距离 | Edit Distance

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

Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.

You have the following 3 operations permitted on a word:

1. Insert a character
2. Delete a character
3. Replace a character

Example 1:

Input: word1 = "horse", word2 = "ros"
Output: 3
Explanation: 
horse -> rorse (replace 'h' with 'r')
rorse -> rose (remove 'r')
rose -> ros (remove 'e')

Example 2:

Input: word1 = "intention", word2 = "execution"
Output: 5
Explanation: 
intention -> inention (remove 't')
inention -> enention (replace 'i' with 'e')
enention -> exention (replace 'n' with 'x')
exention -> exection (replace 'n' with 'c')
exection -> execution (insert 'u')

---

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

1. 插入一个字符
2. 删除一个字符
3. 替换一个字符

示例 1:

输入: word1 = "horse", word2 = "ros"
输出: 3
解释: 
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')

示例 2:

输入: word1 = "intention", word2 = "execution"
输出: 5
解释: 
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

---

40ms

class Solution {
    func minDistance(_ word1: String, _ word2: String) -> Int {
        if word1.count == 0 {
            return word2.count
        }
        if word2.count == 0 {
            return word1.count
        }

        let c1 = Array(word1)
        let c2 = Array(word2)
        var cache = [[Int]](repeating: [Int](repeating: -1, count: c2.count), count: c1.count)

        return match(c1, c2, 0, 0, &cache)
    }

    fileprivate func match(_ c1: [Character], _ c2: [Character], _ i: Int, _ j: Int, _ cache: inout [[Int]]) -> Int {
        if c1.count == i {
            return c2.count - j
        }
        if c2.count == j {
            return c1.count - i
        }

        if cache[i][j] != -1 {
            return cache[i][j]
        }

        if c1[i] == c2[j] {
            cache[i][j] = match(c1, c2, i + 1, j + 1, &cache)
        } else {
            let insert = match(c1, c2, i, j + 1, &cache)
            let delete = match(c1, c2, i + 1, j, &cache)
            let replace = match(c1, c2, i + 1, j + 1, &cache)

            cache[i][j] = min(min(insert, delete), replace) + 1
        }

        return cache[i][j]
    }
}

---

80ms

class Solution {
    func minDistance(_ word1: String, _ word2: String) -> Int {
        var w1arr = Array(word1.characters)
        var w2arr = Array(word2.characters)
        var w1len  = w1arr.count
        var w2len = w2arr.count
        
        if(word1.isEmpty && word2.isEmpty) {
            return 0
        }
        if(word1.isEmpty) {
            return word2.count
        }
        else if(word2.isEmpty) {
            return word1.count
        }
        
        var dp = Array(repeating:Array(repeating:0,count:w2len+1),count:w1len+1)
    
        for i in 0...w2len {
            dp[0][i] = i
        }
        for i in 0...w1len {
            dp[i][0] = i
        }
        
        for idx1 in 1...w1len {
            for idx2 in 1...w2len {
                var minChange = min(min(dp[idx1-1][idx2],dp[idx1-1][idx2-1]),dp[idx1][idx2-1])
                dp[idx1][idx2] = w1arr[idx1-1] == w2arr[idx2-1] ?  dp[idx1-1][idx2-1] : minChange + 1
            }
        }
        
        return dp[w1len][w2len]
        
    }
}

---

92ms

class Solution {
    func minDistance(_ word1: String, _ word2: String) -> Int {
        var res = Array(repeating: Array(repeating: 0, count: word2.count + 1), count: word1.count + 1)
        let word1Array = Array(word1)
        let word2Array = Array(word2)
        for i in 0...word1.count {
            for j in 0...word2.count {
                if i == 0 {
                    res[i][j] = j
                }else if j == 0 {
                    res[i][j] = i
                }else if word1Array[i - 1] == word2Array[j - 1] {
                    res[i][j] = res[i - 1][j - 1]
                }else {
                    res[i][j] = min(res[i - 1][j - 1], min(res[i - 1][j], res[i][j - 1])) + 1
                }
            }
        }
        return res[word1.count][word2.count]
    }
}

---

120ms

class Solution {
//向word1插入：dp[i][j] = dp[i][j-1] + 1;
//从word1删除：dp[i][j] = dp[i-1][j] + 1;
//替换word1元素：dp[i][j] = dp[i-1][j-1] + 1;
    func minDistance(_ word1: String, _ word2: String) -> Int {
        
        let m = word1.count
        let n = word2.count
        
        if m == 0 { return n }
        if n == 0 { return m }
        
        let chars1 = Array(word1.characters)
        let chars2 = Array(word2.characters)
        
        var f = [[Int]](repeating:[Int](repeating: 0, count: n + 1), count: m + 1)
        
        for i in 0...m {
            f[i][0] = i
        }
        
        for i in 0...n {
            f[0][i] = i
        }
        
        for i in 1...m {
            for j in 1...n {
                
                if chars1[i - 1] == chars2[j - 1] {
                    f[i][j] = f[i - 1][j - 1]
                } else {
                    f[i][j] = min(f[i][j - 1], f[i - 1][j], f[i - 1][j - 1]) + 1  
                }
            }
        }
        
        return f[m][n]
    }
}

---

124ms

class Solution {
    func minDistance(_ word1: String, _ word2: String) -> Int {
        let word1 = Array(word1.characters)
        let word2 = Array(word2.characters)
        let len1 = word1.count
        let len2 = word2.count
        var res = Array(repeating: Array(repeating: 0, count: len2+1), count: len1+1)
        // res[i][j] = (word1[i] == word2[j] ? res[i+1][j+1] : min(1+res[i][j+1], 1 + res[i+1][j+1], res[i+1][j]))
        var j = len2
        while j >= 0 {
            var i = len1
            while i >= 0 {
                if j == len2 { 
                    res[i][j] = (len1 - i) // Delete
                } else {
                    if i == len1 {
                        res[i][j] = (len2 - j) // Insert
                    } else {
                        res[i][j] = (word1[i] == word2[j] ? res[i+1][j+1] : min(1+res[i][j+1], 1+res[i+1][j+1], 1+res[i+1][j]))
                    }
                }
                i -= 1
            }
            j -= 1
        }
        
        return res[0][0]
    }
}