[Swift]LeetCode1143. 最长公共子序列 | Longest Common Subsequence

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

Given two strings text1 and text2, return the length of their longest common subsequence.

A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, "ace" is a subsequence of "abcde" while "aec" is not). A common subsequence of two strings is a subsequence that is common to both strings.

If there is no common subsequence, return 0.

Example 1:

Input: text1 = "abcde", text2 = "ace" 
Output: 3  
Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2:

Input: text1 = "abc", text2 = "abc"
Output: 3
Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3:

Input: text1 = "abc", text2 = "def"
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints:

• 1 <= text1.length <= 1000
• 1 <= text2.length <= 1000
• The input strings consist of lowercase English characters only.

---

给定两个字符串text1和text2，返回它们最长公共子序列的长度。

字符串的子序列是从原始字符串生成的新字符串，删除了一些字符（不能为无），而不更改其余字符的相对顺序。（例如，“ace”是“abcde”的子序列，而“aec”不是）。两个字符串的公共子序列是两个字符串的公共子序列。

如果没有公共子序列，则返回0。

例1：

输入：text1=“abcde”，text2=“ace”

输出：3

说明：最长的常见子序列是“ace”，其长度为3。

例2：

输入：text1=“abc”，text2=“abc”

输出：3

说明：最长的常见子序列为“abc”，其长度为3。

例3：

输入：text1=“abc”，text2=“def”

输出：0

说明：没有这种常见的子序列，所以结果是0。

限制条件：

• 1<=text1.长度<=1000
• 1<=text2.长度<=1000
• 输入字符串仅由小写英文字符组成。

---

76ms

sample 76 ms submission
class Solution {
    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
        var chars1 = Array(text1)
        var chars2 = Array(text2)
        var memo = [[Int]](repeating:[Int](repeating: 0, count:chars2.count+1), count: chars1.count+1)
        
        for i in chars1.indices {
            for j in chars2.indices {
                
                if chars1[i] == chars2[j] {
                    memo[i+1][j+1] = memo[i][j] + 1
                } else {
                    memo[i+1][j+1] = max(memo[i][j+1], memo[i+1][j])
                }
            }
        }
        return memo[chars1.count][chars2.count]
    }
}

---

76ms

class Solution {
    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
        var outer = Array(text1) // outer
        var inner = Array(text2) // inner
        var T = Array(repeating: Array(repeating: 0, count: outer.count+1), count: inner.count+1)
        
        for j in 1...inner.count {
            for i in 1...outer.count {
                if inner[j-1] == outer[i-1] {
                    T[j][i] = T[j-1][i-1]+1
                } else {
                    T[j][i] = max(T[j][i-1], T[j-1][i])
                }
            }
        }
        return T[inner.count][outer.count]
    }
}

---

84ms

class Solution {
    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
        return solu(text1: text1, text2: text2)
    }
    
    private func solu(text1: String, text2: String) -> Int {
        var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: text2.count + 1), count: text1.count + 1)
        
        let t1 = text1.map { String($0) }
        let t2 = text2.map { String($0) }
        for i in 0 ..< t1.count {
            for j in 0 ..< t2.count {
                if t1[i] == t2[j] {
                    dp[i + 1][j + 1] = 1 + dp[i][j]                    
                } else {
                    dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])
                }
            }
        }
        return dp[text1.count][text2.count]
    }
    
    private func find(text1: String, text2: String, dp: inout [String: Int]) -> Int {
        guard text1 != text2 else { 
            return text1.count
        }
        guard text1.count > 0 && text2.count > 0 else { return 0 }
        
        let key = text1 + "|" + text2
        
        if let cache = dp[key] {
            return cache
        }
        
        var result = 0
        for i in 0 ..< text1.count {
            for j in 0 ..< text2.count {
                var t1 = text1
                var t2 = text2
                
                let i1 = text1.index(text1.startIndex, offsetBy: i)
                t1.remove(at: i1)
                
                let j1 = text2.index(text2.startIndex, offsetBy: j)
                t2.remove(at: j1)
                
                result = max(
                    find(text1: text1, text2: t2, dp: &dp), 
                    find(text1: t1, text2: text2, dp: &dp), 
                    result
                )
            }
        }
        dp[key] = result
        return result
    }
}

---

88ms

class Solution {
    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
        var dp = [[Int]](repeating: [Int](repeating: 0, count: text2.count + 1), count: text1.count + 1)
        let text1 = Array(text1)
        let text2 = Array(text2)
        for i in 1..<text1.count + 1 {
            for j in 1..<text2.count + 1 {
                if text1[i-1] == text2[j-1] {
                    dp[i][j] = 1 + dp[i-1][j-1]
                } else {
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
                }
            }
        }
        return dp.last!.last!
    }
}

---

Runtime: 92 ms

Memory Usage: 26.6 MB

class Solution {
    func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
        let m:Int = text1.count
        let n:Int = text2.count
        let arr1:[Character] = Array(text1)
        let arr2:[Character] = Array(text2)
        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] + 1
                }
                else
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
                }
            }
        }
        return dp[m][n]
    }
}