[Swift]LeetCode139. 单词拆分 | Word Break

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

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

Note:

• The same word in the dictionary may be reused multiple times in the segmentation.
• You may assume the dictionary does not contain duplicate words.

Example 1:

Input: s = "leetcode", wordDict = ["leet", "code"]
Output: true
Explanation: Return true because "leetcode" can be segmented as "leet code".

Example 2:

Input: s = "applepenapple", wordDict = ["apple", "pen"]
Output: true
Explanation: Return true because "applepenapple" can be segmented as "apple pen apple".
             Note that you are allowed to reuse a dictionary word.

Example 3:

Input: s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
Output: false

---

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

• 拆分时可以重复使用字典中的单词。
• 你可以假设字典中没有重复的单词。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
     注意你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

---

20ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        var dp = Array(repeating:false,count:s.count + 1)
        var wordSet = Set(wordDict)
        var maxWordLen = 0
        for word in wordDict {
            maxWordLen = max(maxWordLen,word.count)
        }

        dp[0] = true
        var s = Array(s)
        for start in stride(from:0,to:s.count,by:1) {
            if !dp[start] {
                continue
            }
            for end in stride(from:start, to:s.count, by:1) {
                if end - start + 1 > maxWordLen {
                    break
                }
                if dp[start] && wordSet.contains(String(s[start...end])) {
                    dp[end + 1] = true
                }
            }
        }
        return dp[s.count]
    }
}

---

28ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        let wordSet = Set(wordDict)
        var dp = Array(repeating: false, count: s.count + 1), maxLength = 0
        dp[0] = true
        for word in wordSet {
            maxLength = max(maxLength, word.count)
        }
        for i in 1...s.count {
            for j in 0..<i {
                if i - j <= maxLength && dp[j] && wordSet.contains(String(s.prefix(i).suffix(i - j))) {
                    dp[i] = true
                    break
                }
            }
        }
        return dp.last!
    }
}

---

36ms

class Solution {
    var memo: [String: Bool] = [:]
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        // print("This is s: (s) and dict : (wordDict)")
        if memo[s] != nil && memo[s] == false {
            return false
        }
        if s.isEmpty {
            return true
        }
        for word in wordDict {
            var newS = s
            if newS.hasPrefix(word) {
                let range = 0...word.count 
                let replace = ""
                newS = String(newS.dropFirst(word.count))
                // print("new2 : (newS)")
                if wordBreak(newS, wordDict) {
                    memo[s] = true
                    return true
                }
            }
        }
        memo[s] = false
        return false
    }
}

---

40ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        var hash = [String:Bool]()
        var mem = [Int:Bool]()
        for word in wordDict {
            hash[word] = true
        }
        let chars = Array(s).map { String($0) }
        return helper(chars,0,"",hash,&mem)
    }
    func helper(_ chars: [String], _ index: Int, _ curString:String, _ hash:[String:Bool],  _ mem: inout [Int:Bool] ) -> Bool {
        if index == chars.count { return curString == "" }
        if curString == "" {
            if mem[index] == true { return false }
            else { mem[index] = true }
        }
        let newStr = curString + chars[index]
        if hash[newStr] == true {
            return helper(chars,index+1,"",hash,&mem) || helper(chars,index+1,newStr,hash,&mem)
        } else {
            return helper(chars,index+1,newStr,hash,&mem)
        }
    }
}

---

112ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        let dict = Dictionary(grouping: wordDict, by: { $0 })
        var helper = [Int](repeating: -1, count: s.count)
        
        func wordBreak(_ start: Int) -> Bool {
            if start == s.count { return true }
            if helper[start] != -1 { return helper[start] == 1 }
            for j in start..<s.count {
                let str: String = String(s[s.index(s.startIndex, offsetBy: start)...s.index(s.startIndex, offsetBy: j)])
                if dict[str] != nil && wordBreak(j+1) {
                    helper[start] = 1
                    return true
                }
            }
            helper[start] = 0
            return false
        }
        return wordBreak(0)
    }
}

---

120ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
        var wordSet:Set<String> = Set<String>(wordDict)
        var dp:[Bool] = [Bool](repeating:false,count:s.count + 1)
        dp[0] = true
        for i in 0..<dp.count
        {
            for j in 0..<i
            {
                if dp[j] && wordSet.contains(s.subString(j, i - j))
                {
                    dp[i] = true
                    break
                }
            }
        }
        return dp.last!
    }
}
extension String {
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}