[Swift]LeetCode1177. 构建回文串检测 | Can Make Palindrome from Substring

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a string s, we make queries on substrings of s.

For each query queries[i] = [left, right, k], we may rearrange the substring s[left], ..., s[right], and then choose up to k of them to replace with any lowercase English letter. 

If the substring is possible to be a palindrome string after the operations above, the result of the query is true. Otherwise, the result is false.

Return an array answer[], where answer[i] is the result of the i-th query queries[i].

Note that: Each letter is counted individually for replacement so if for example s[left..right] = "aaa", and k = 2, we can only replace two of the letters.  (Also, note that the initial string s is never modified by any query.)

 

Example :

Input: s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
Output: [true,false,false,true,true]
Explanation:
queries[0] : substring = "d", is palidrome.
queries[1] : substring = "bc", is not palidrome.
queries[2] : substring = "abcd", is not palidrome after replacing only 1 character.
queries[3] : substring = "abcd", could be changed to "abba" which is palidrome. Also this can be changed to "baab" first rearrange it "bacd" then replace "cd" with "ab".
queries[4] : substring = "abcda", could be changed to "abcba" which is palidrome.

 

Constraints:

• 1 <= s.length, queries.length <= 10^5
• 0 <= queries[i][0] <= queries[i][1] < s.length
• 0 <= queries[i][2] <= s.length
• s only contains lowercase English letters.

---

 给你一个字符串 s，请你对 s 的子串进行检测。

每次检测，待检子串都可以表示为 queries[i] = [left, right, k]。我们可以 重新排列 子串 s[left], ..., s[right]，并从中选择 最多 k 项替换成任何小写英文字母。 

如果在上述检测过程中，子串可以变成回文形式的字符串，那么检测结果为 true，否则结果为 false。

返回答案数组 answer[]，其中 answer[i] 是第 i 个待检子串 queries[i] 的检测结果。

注意：在替换时，子串中的每个字母都必须作为 独立的 项进行计数，也就是说，如果 s[left..right] = "aaa" 且 k = 2，我们只能替换其中的两个字母。（另外，任何检测都不会修改原始字符串 s，可以认为每次检测都是独立的）

 

示例：

输入：s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
输出：[true,false,false,true,true]
解释：
queries[0] : 子串 = "d"，回文。
queries[1] : 子串 = "bc"，不是回文。
queries[2] : 子串 = "abcd"，只替换 1 个字符是变不成回文串的。
queries[3] : 子串 = "abcd"，可以变成回文的 "abba"。 也可以变成 "baab"，先重新排序变成 "bacd"，然后把 "cd" 替换为 "ab"。
queries[4] : 子串 = "abcda"，可以变成回文的 "abcba"。

 

提示：

• 1 <= s.length, queries.length <= 10^5
• 0 <= queries[i][0] <= queries[i][1] < s.length
• 0 <= queries[i][2] <= s.length
• s 中只有小写英文字母

---

Runtime: 1204 ms

Memory Usage: 55.4 MB

class Solution {
    func canMakePaliQueries(_ s: String, _ queries: [[Int]]) -> [Bool] {
        var s:[Int] = Array(s).map{$0.ascii}
        var n:Int = s.count
        var m:Int = queries.count
        var res:[Bool] = [Bool](repeating:false,count:m)
        var sum:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:26),count:n)
        for i in 0..<n
        {
            if i > 0
            {
                sum[i] = sum[i-1]
            }
            sum[i][s[i] - 97] += 1
        }
        for i in 0..<m
        {
            var l:Int = queries[i][0]
            var r:Int = queries[i][1]
            var k:Int = queries[i][2]
            var cnt:Int = 0
            for j in 0..<26
            {
                var tmp:Int = sum[r][j]
                if l > 0
                {
                    tmp -= sum[l-1][j]
                }
                
                if tmp & 1 != 0
                {
                    cnt += 1
                }
            }
            if (r-l+1) & 1 != 0
            {
                cnt -= 1
            }
            res[i] = cnt <= k * 2
        }
        return res
    }
}

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

---

1328ms

 

class Solution {
    func canMakePaliQueries(_ s: String, _ queries: [[Int]]) -> [Bool] {
        let s = Array(s.utf8)
        var freqs = [Freq]()
        var freq = Freq()
        freqs.append(freq)
        for char in s {
            let f = Freq(freq, char)
            freqs.append(f)
            freq = f
        }
        
        var res = [Bool]()
        for query in queries {
            res.append(solve(query, freqs))
        }
        
        return res
    }
    
    func solve(_ query: [Int], _ freqs: [Freq]) -> Bool {
        let freq1 = freqs[query[0]]
        let freq2 = freqs[query[1] + 1]
        let num = query[2]
        let freq = freq1 - freq2
        var countOdd = 0
        for i in 0..<26 {
            if freq.arr[i] % 2 == 1 {
                countOdd += 1
            }
        }
        //print(freq, countOdd, num)
        return (countOdd - num * 2) <= 1
    }
}

struct Freq {
    var arr: [Int]
    
    init() {
        arr = [Int](repeating: 0, count:  26)
    }
    
    init(_ freq: Freq, _ char: UInt8) {
        self.arr = freq.arr
        arr[Int(char) - 97] += 1
    }
    
    init(_ str: [UInt8]) {
        arr = [Int](repeating: 0, count:  26)
        for char in str {
            arr[Int(char) - 97] += 1
        }
    }
    
    static func -(lhs: Freq, rhs: Freq) -> Freq {
        var freq = Freq()
        for i in 0..<26 {
            freq.arr[i] = rhs.arr[i] - lhs.arr[i]
        }
        return freq
    }
}

---

1452ms

class Solution {
    func canMakePaliQueries(_ s: String, _ queries: [[Int]]) -> [Bool] {   
        let chars = Array(s), n = chars.count
        let table = Array("abcdefghijklmnopqrstuvwxyz")
        var freq = [[Int]](repeating: [Int](repeating: 0, count: n+1), count: 26)
        for c in 0..<26 {
            for i in 0..<n {
                freq[c][i+1] = freq[c][i] + (chars[i] == table[c] ? 1 : 0)
            }
        }
        var ans = [Bool]()
        for que in queries {
            var i = que[0], j = que[1], k = que[2]
            j += 1
            var odd_count = 0
            for c in 0..<26 where (freq[c][j] - freq[c][i])%2 != 0 {
                odd_count += 1
            }

            let fullfill = (odd_count-1) <= 2*k
            ans.append(fullfill)
        }
        return ans
    }
}