[Swift]LeetCode1208. 尽可能使字符串相等 | Get Equal Substrings Within Budget

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

You are given two strings s and t of the same length. You want to change s to t. Changing the i-th character of s to i-th character of t costs |s[i] - t[i]| that is, the absolute difference between the ASCII values of the characters.

You are also given an integer maxCost.

Return the maximum length of a substring of s that can be changed to be the same as the corresponding substring of twith a cost less than or equal to maxCost.

If there is no substring from s that can be changed to its corresponding substring from t, return 0.

Example 1:

Input: s = "abcd", t = "bcdf", cost = 3
Output: 3
Explanation: "abc" of s can change to "bcd". That costs 3, so the maximum length is 3.

Example 2:

Input: s = "abcd", t = "cdef", cost = 3
Output: 1
Explanation: Each charactor in s costs 2 to change to charactor in t, so the maximum length is 1.

Example 3:

Input: s = "abcd", t = "acde", cost = 0
Output: 1
Explanation: You can't make any change, so the maximum length is 1.

Constraints:

• 1 <= s.length, t.length <= 10^5
• 0 <= maxCost <= 10^6
• s and t only contain lower case English letters.

---

给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

示例 1：

输入：s = "abcd", t = "bcdf", cost = 3
输出：3
解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

示例 2：

输入：s = "abcd", t = "cdef", cost = 3
输出：1
解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。

示例 3：

输入：s = "abcd", t = "acde", cost = 0
输出：1
解释：你无法作出任何改动，所以最大长度为 1。

提示：

• 1 <= s.length, t.length <= 10^5
• 0 <= maxCost <= 10^6
• s 和 t 都只含小写英文字母。

---

Runtime: 64 ms

Memory Usage: 24 MB

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        let s:[Int] = Array(s).map{$0.ascii}
        let t:[Int] = Array(t).map{$0.ascii}
        var ans:Int = 0
        var l:Int = 0
        var r:Int = -1
        var curCost:Int = 0
        for i in 0..<s.count
        {
            r += 1
            curCost += abs(s[r] - t[r])
            while(curCost > maxCost && l <= r)
            {
                curCost -= abs(s[l] - t[l])
                l += 1
            }
            ans = max(ans, r - l + 1)
        }
        return ans
    }
}


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

---

24ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        let s = Array(s.utf8)
        let t = Array(t.utf8)
        var res = [Int](repeating: 0, count: s.count)
        for i in 0..<s.count {
            res[i] = abs(Int(s[i]) - Int(t[i]))
        }
        //print(res)
        var left = 0
        var right = 0
        var cost = 0
        var ans = 0
        while right < res.count {
            cost += res[right]
            ans = max(ans, right - left)
            while cost > maxCost && left <= right {
                cost -= res[left]
                left += 1
            }
            right += 1
        }
        ans = max(ans, right - left)
        return ans
    }
}

---

36ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        guard s.count == t.count else {
            return 0
        }
        
        let arrayS = Array(s)
        let arrayT = Array(t)
        
        var diffs = [0]
        
        for i in 0..<arrayS.count {
            guard let v1 = arrayS[i].asciiValue, let v2 = arrayT[i].asciiValue else {
                return 0
            }
            
            let diff = abs(Int(v1) - Int(v2))
            diffs.append(diff)
        }
        var head = 0
        var currentCost = 0
        var length = 0
        var maxLength = 0
        
        // print(diffs)
        
        for tail in 1..<diffs.count {
            currentCost += diffs[tail]
            length += 1
            
            if currentCost <= maxCost, currentCost >= 0 {
                // print("head:(head)...tail:(tail)....(currentCost)")
                maxLength = max(maxLength, length)
            } else {
                for h in head+1..<tail {
                    currentCost -= diffs[h]
                    length -= 1
                    head = h
                    if currentCost <= maxCost, currentCost >= 0 {
                        // print("head:(head)...tail:(tail)....(currentCost)")
                        maxLength = max(maxLength, length)
                        break
                    }
                }
            }
        }
        return maxLength
    }
}

---

40ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        var diff = [Int](repeating: 0, count: t.count)
        var sArr: [Character] = Array(s)
        var tArr: [Character] = Array(t)
        
        for i in 0..<s.count {
            diff[i] = absoluteDifference(sArr[i], tArr[i])
        }

        var result = 0
        var startIndex = 0
        var endIndex = 0
        var sum = 0
        
        while endIndex < diff.count {
            if sum <= maxCost {
                sum += diff[endIndex]
                if sum <= maxCost {
                    result = max((endIndex - startIndex) + 1, result)
                }
                endIndex += 1
            } else {
                if startIndex < endIndex {
                    sum -= diff[startIndex]
                    startIndex += 1
                } else {
                    startIndex += 1
                    endIndex += 1
                }
            }

        }
        
        return result
    }
    
    private func absoluteDifference(_ charOne: Character, _ charTwo: Character) -> Int {
        return abs(Int(charOne.asciiValue!) - Int(charTwo.asciiValue!))
    }
}

---

44ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        
        var sa = s.map { Int($0.asciiValue!) }
        var ta = t.map { Int($0.asciiValue!) }
        
        var i = 0
        var j = 0
        var k = maxCost
        
        while j < sa.count {
            
            let cost = abs(sa[j] - ta[j])
            k -= cost
            
            if k < 0 {
                k += abs(sa[i] - ta[i])
                i += 1
            }
            
            j += 1
        }
        
        return j - i
    }
}

---

52ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        guard s.count == t.count else {
            return 0
        }
        
        let arrayS = Array(s)
        let arrayT = Array(t)
        
        var diffs = [0]
        
        for i in 0..<arrayS.count {
            guard let v1 = arrayS[i].asciiValue, let v2 = arrayT[i].asciiValue else {
                return 0
            }
            
            let diff = abs(Int(v1) - Int(v2))
            diffs.append(diff)
        }
        
        var head = 0
        var currentCost = 0
        var length = 0
        var maxLength = 0
        
        for tail in 1..<diffs.count {
            currentCost += diffs[tail]
            length += 1
            
            if currentCost <= maxCost, currentCost >= 0 {
                maxLength = max(maxLength, length)
            } else {
                for h in head+1..<tail {
                    currentCost -= diffs[h]
                    length -= 1
                    head = h
                    if currentCost <= maxCost, currentCost >= 0 {
                        maxLength = max(maxLength, length)
                        break
                    }
                }
            }
            
        }
        
        return maxLength
    }
}

---

56ms

class Solution {
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        let s = s.map({Int(Character(String($0)).asciiValue!)})
        let t = t.map({Int(Character(String($0)).asciiValue!)})
        var diff: [Int] = []
        for i in 0..<s.count {
            diff.append(abs(s[i] - t[i]))
        }
        
        var l = 0
        var r = 0
        var count = diff[0]
        var maxLength = diff[0] == 0 ? 1 : 0
        
        while l < diff.count - maxLength {
            r += 1
            count += diff[r]
            if count > maxCost {
                count -= diff[r]
                count -= diff[l]
                l += 1
                r -= 1
            } else {
                if r - l + 1 > maxLength {
                    maxLength = r - l + 1
                }
            }
        }
        //print(diff)
        return maxLength
    }
}

---

108ms

class Solution {
    func asciiValue(_ char: Character) -> Int {
        let s = String(char).unicodeScalars
        return Int(s[s.startIndex].value)
    }
    
    func equalSubstring(_ s: String, _ t: String, _ maxCost: Int) -> Int {
        
        let codesS = s.map(asciiValue)
        let codesT = t.map(asciiValue)
        
        var costs = [Int]()

        for i in 0..<codesS.count {
            costs.append(abs(codesS[i] - codesT[i]))
        }
        
        print(costs)
        
        var maxLen = 0
        var currentLen = 0
        
        var budget = maxCost
        for (index, cost) in costs.enumerated() {
            
            // try to increase substring
            budget -= cost
            
            // if within the budget increment current length
            if budget >= 0 {
                currentLen += 1
            } else {
                // otherwise check if we
                if currentLen > maxLen {
                    maxLen = currentLen
                }
                
                // update current len and budget
                while budget < 0 && currentLen > 0 {
                    budget += costs[index - currentLen]
                    currentLen -= 1
                }
                
                if budget >= 0 {
                    currentLen += 1
                    maxLen = max(maxLen, currentLen)
                }
                
                if currentLen == 0 {
                    budget += costs[index]
                }
            }
        }
        
        return max(maxLen, currentLen)
    }
}