Leetcode 140. Word Break II

Problem:

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:
[]

 

Solution:　　拿到这道题的第一反映是用backtrace来做，但发现在这个测试用例上栽了跟头：

　　s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",

　　wordDict = {"a","aa","aaa","aaaa","aaaaa","aaaaaa","aaaaaaa","aaaaaaaa","aaaaaaaaa","aaaaaaaaaa"}

　　超时代码如下：

class Solution {
public:
    void backtrace(int index,string &s,vector<string> &path,vector<string> &result,unordered_set<string> &us){
        if(index == s.size()){
            string str = "";
            for(int i = 0;i != path.size();++i){
                str = str + path[i] + " ";
            }
            result.push_back(str.substr(0,str.size()-1));
            return;
        }
        string str = "";
        for(int i = index;i != s.size();++i){
            str += s[i];
            if(us.find(str) != us.end()){
                path.push_back(str);
                backtrace(i+1,s,path,result,us);
                path.pop_back();
            }
        }
    }
    vector<string> wordBreak(string s, vector<string>& wordDict) {
        int m = s.size();
        unordered_set<string> us;
        for(string str:wordDict) us.insert(str);
        vector<string> result;
        vector<string> path;
        backtrace(0,s,path,result,us);
        return result;
    }
};

　　对于这类问题，应该要想到是否能用记忆的方法来提高效率（动态规划属于记忆的特殊方式）。现在来思考发生超时的原因是什么，就这个例子而言，我们发现如果从某个位置开始，无法将后面的字符串进行分割到达最后一个字符时，那么下一次对前面的字符串通过不同的分割方案到这个位置的时候就可以提前知道，无论怎样DFS都无法完全分割后面的字符串。所以我们可以通过一个invalid的hash set记录下所有该位置开始不能到达s末尾的索引，当invalid中包含这个起始位置index时，我们就不需要执行下面的程序了，因为我们早就知道即使进行DFS我们也无法到达最后一个字符。那么判断能否到达最后一个字符的依据是什么呢，如果说在进行DFS之前和DFS之后结果集的长度没有发生变化，那么我们就可以判断这个位置开始无法产生新的分割方法，所以将该索引添加到invalid当中。

　　其实这个问题不算是动态规划，只能算DFS的优化，但这个问题的核心部分仍然是记忆问题，所以我把它放在动态规划这一大类下。

Code:

 

class Solution {
public:
    void backtrace(int index,string &s,string path,vector<string> &result,unordered_set<string> &us,unordered_set<int> &invalid){
        if(invalid.find(index) != invalid.end())
            return;
        if(index == s.size()){
            result.push_back(path.substr(0,path.size()-1));
            return;
        }
        int length = result.size();
        string str = "";
        for(int i = index;i != s.size();++i){
            str += s[i];
            if(us.find(str) != us.end()){
                backtrace(i+1,s,path+str+" ",result,us,invalid);
            }
        }
        if(result.size() == length)
            invalid.insert(index);
    }
    vector<string> wordBreak(string s, vector<string>& wordDict) {
        int m = s.size();
        unordered_set<string> us;
        unordered_set<int> invalid;
        for(string str:wordDict) us.insert(str);
        vector<string> result;
        backtrace(0,s,"",result,us,invalid);
        return result;
    }
};