[Swift]LeetCode516. 最长回文子序列 | Longest Palindromic Subsequence

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

Given a string s, find the longest palindromic subsequence's length in s. You may assume that the maximum length of s is 1000.

Example 1:
Input:

"bbbab"

Output:

4

One possible longest palindromic subsequence is "bbbb". 

Example 2:
Input:

"cbbd"

Output:

2

One possible longest palindromic subsequence is "bb".

---

给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。

示例 1:
输入:

"bbbab"

输出:

4

一个可能的最长回文子序列为 "bbbb"。

示例 2:
输入:

"cbbd"

输出:

2

一个可能的最长回文子序列为 "bb"。

---

280ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        let s = Array(s)
        guard s.count > 0 else {
            return 0
        }
        
        let len = s.count
        var dp = [Int](repeating: 1, count: len)
        var i = 1
        while i<len {
            var maxLen = 0
            var j = i-1
            while j >= 0 {
                let previousMax = maxLen
                maxLen = max(dp[j], maxLen)
                if s[j] == s[i] {
                    dp[j] = previousMax + 2
                }
                j-=1
            }
            i+=1
        }
        var maxLen = 1
        for v in dp { maxLen = max(maxLen,v) }
        return maxLen
    }
}

---

Runtime: 292 ms

Memory Usage: 19.7 MB

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        var arr:[Character] = Array(s)
        var n:Int = s.count
        var res:Int = 0
        var dp:[Int] = [Int](repeating:1,count:n)
        for i in stride(from:n - 1,through:0,by:-1)
        {
            var len:Int = 0
            for j in (i + 1)..<n
            {
                var t:Int = dp[j]
                if arr[i] == arr[j]
                {
                    dp[j] = len + 2
                }
                len = max(len, t)
            }
        }
        return dp.max()!
    }
}

---

300ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        let s = Array(s.utf16)
        guard s.count > 0 else {
            return 0
        }
        
        let count = s.count
        var dp = [Int](repeating: 1, count: count)
        for j in 1..<count {
            var temp = 0
            var i=j-1
            while i >= 0 {
                (temp, dp[i]) = (dp[i], (s[i] == s[j]) ? temp + 2 : max(dp[i], dp[i+1]))
                i-=1
            }
        }
        return dp[0]
    }
}

---

440ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        guard s.count > 1 else { return s.count }
        let chars = Array(s)
        
        var lminus2 = [Int](repeating: 0, count: s.count+1)
        var lminus1 = [Int](repeating: 1, count: s.count+1)
        var l = [Int](repeating: 0, count: s.count+1)

        for len in (2...s.count) {
            for start in (0..<s.count - len + 1) {
                if chars[start] == chars[start+len-1] {
                    l[start] = len == 2 ? 2 : lminus2[start+1] + 2
                } else {
                    l[start] = max(lminus1[start+1], lminus1[start])
                }
            }
            lminus2 = lminus1
            lminus1 = l
        }
        return l[0]
    }
}

---

768ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        let sArray = Array(s)
        var cache = Dictionary<State, Int>() 
        return countPalindrome(sArray, 0, sArray.count - 1, &cache)
    }
    
    private func countPalindrome(
        _ s: Array<Character>,
        _ i: Int,
        _ j: Int,
        _ cache: inout Dictionary<State, Int>) -> Int {
        let len = j - i + 1
        if len == 1 {
            return 1
        }
        let curEqual = s[i] == s[j]
        guard i <= j else { return 0 }
        let state = State(i: i, j: j)
        guard cache[state] == nil else { return cache[state]! }
        
        var totalPalin = Int.min
        if curEqual {
         totalPalin = 2 + countPalindrome(s, i + 1, j - 1, &cache)
        } else {
            totalPalin = max(totalPalin, countPalindrome(s, i + 1, j, &cache))
            totalPalin = max(totalPalin, countPalindrome(s, i, j - 1, &cache))
        }
        cache[state] = totalPalin
        return totalPalin
    }
    
    private struct State: Hashable {
        var i: Int
        var j: Int
    }
}

---

784ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        let chars = Array(s)
        let N = chars.count
        var dp = [[Int]](repeating: [Int](repeating: 0, count: N), count: N)
        var i = N-1
        while i >= 0 {
            dp[i][i] = 1
            for j in i+1..<N {
                if chars[i] == chars[j] {
                    dp[i][j] = dp[i+1][j-1] + 2
                }
                else {
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
                }
            }
            i -= 1
        }
        return dp[0][N-1]
    }
}

---

816ms

class Solution {
    func longestPalindromeSubseq(_ s: String) -> Int {
        var dp:[[Int]] = Array(repeating: Array(repeating: 0, count: s.count), count: s.count)
        let arr = Array(s)
        for i in stride(from: arr.count - 1, to: -1, by: -1) {
            dp[i][i] = 1
            for j in i + 1..<arr.count {
                if arr[i] == arr[j] {
                    dp[i][j] = dp[i + 1][j - 1] + 2
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
                }
            }
        }
        return dp[0][arr.count - 1]
    }
}