[Swift]LeetCode140. 单词拆分 II | Word Break II

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

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.

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 = "catsanddog"
wordDict = ["cat", "cats", "and", "sand", "dog"]
Output:
[
  "cats and dog",
  "cat sand dog"
]

Example 2:

Input:
s = "pineapplepenapple"
wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
Output:
[
  "pine apple pen apple",
  "pineapple pen apple",
  "pine applepen apple"
]
Explanation: Note that you are allowed to reuse a dictionary word.

Example 3:

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

---

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。

说明：

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

示例 1：

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

示例 2：

输入:
s = "pineapplepenapple"
wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
输出:
[
  "pine apple pen apple",
  "pineapple pen apple",
  "pine applepen apple"
]
解释: 注意你可以重复使用字典中的单词。

示例 3：

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

---

36ms

class Solution {
     func wordBreak(_ s: String, _ wordDict: [String]) -> [String] {
        if s.isEmpty || wordDict.isEmpty {
            return []
        }
        
        let cs = Set(wordDict.map{$0.count})
        var carr = [Int]()
        for count in cs {
            carr.append(count)
        }
        let wordSet = Set(wordDict)
        var res = [String]()
        
        var subCounts : [[Int]?] = Array(repeating: nil, count: s.count + 1)
        subCounts[0] = [Int]()
       
        for i in 0..<s.count where subCounts[i] != nil {
            for j in 0..<carr.count {
                if i + carr[j] <= s.count && wordSet.contains((s as NSString).substring(with: NSRange(location: i, length: carr[j]))) {
                    subCounts[i]?.append(carr[j])
                    if subCounts[i + carr[j]] == nil {
                        subCounts[i + carr[j]] = [Int]()
                    }
                }
            }
        }
        
        if subCounts[s.count] == nil {
            return []
        }
        
        var words = [String]()
        
       dfs(s, subCounts, 0, &words, &res)
        
        return res
    }
    
    func dfs(_ s : String , _ subLengths : [[Int]?] , _ from : Int, _ words : inout [String], _ res : inout [String]) {
        
        if s.count == from {
            let ser = words.joined(separator: " ")
            res.append(ser)
            return
        }
        
        let tar = subLengths[from]!
        
        for length in tar {
            words.append((s as NSString).substring(with: NSRange(location: from, length: length)))
            dfs(s, subLengths, from + length, &words, &res)
            words.removeLast()
        }
        
    }
}

---

40ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> [String] {

        var map = [String: [String]]()
        var wordDict = wordDict
        return helper(s, &wordDict, &map)
    }
    func helper(_ s: String, _ wordDict: inout [String], _ map: inout [String: [String]]) -> [String] {
        if s.count == 0 { return [""] }
        if let value = map[s] {
            return value
        }       
        var res = [String]()
        for word in wordDict {
            if !s.hasPrefix(word) { continue }
            let subs = helper(s.substring(from: word.endIndex), &wordDict, &map)
            for sub in subs {
                if sub.isEmpty {
                    res.append(word)
                }
                else {
                    res.append(word + " " + sub)
                }
            }
        }
        map[s] = res
        return res
    }
}

---

68ms

class Solution {
    func wordBreak(_ s: String, _ wordDict: [String]) -> [String] {
        var computedSentences = [String: [String]]()
        return sentences(s, wordDict, &computedSentences)
    }
    
    func sentences(_ s: String, _ wordDict: [String], _ computedSentences: inout [String: [String]]) -> [String] {
        
        if let precomputed = computedSentences[s] {
            return precomputed
        }
        
        if s.isEmpty {
            return [""]
        }
        
        var results = [String]()
        for word in wordDict where s.starts(with: word) {
            let subSentences = sentences(String(s.dropFirst(word.count)), wordDict, &computedSentences)
            for subSentence in subSentences {
                if subSentence.isEmpty {
                    results.append(word)
                } else {
                    results.append("(word) (subSentence)")
                }
            }
        }
        
        computedSentences[s] = results
        return results
    }
}

---

88ms

class Solution {
    var word_set: Set<String> = []
    var cache: [String: [String]] = [:]
    
    func wordBreak(_ s: String, _ wordDict: [String]) -> [String] {
        guard s.count > 0 else {
            return []
        }
        word_set = Set<String>(wordDict)
        return self.word_Break(s)
    }
    
    func word_Break(_ s: String) -> [String] {
        guard s.count > 0 else {
            return [""]
        }
        
        if let answer = cache[s] {
            return answer
        }
        
        var answers:[String] = []
        for i in 0..<s.count {
            let index = s.index(s.startIndex, offsetBy: i)
            let mySubstring = s[...index]
            
            if word_set.contains(String(mySubstring)) {
                let nextIndex = s.index(index, offsetBy: 1)
                let subReturn = word_Break(String(s[nextIndex...]))
                let fullReturn = subReturn.map(){ partialPath -> String in
                    if partialPath == "" {
                        return "(mySubstring)"
                    }
                    return "(mySubstring) (partialPath)"
                }
                
                answers += fullReturn
            }
        }
        
        cache[s] = answers
        return answers
    }
}