LeetCode

Word Break II

2014.2.27 02:03

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.

Return all such possible sentences.

For example, given
s = "catsanddog",
dict = ["cat", "cats", "and", "sand", "dog"].

A solution is ["cats and dog", "cat sand dog"].

Solution:

　　This problem request you to find out all breaking methods.

　　I tried DFS, but first I got an TLE because I looked up the segment in the dictionary in the recursive function. Later I realized it would be better to look up every segment in the dictionary and store the result in a 2d array.

　　After this optimization things should be good enough, but the result was still TLE.

　　Then I changed the direction of DFS, from right to left and got an AC at last. Don't know why, maybe the input data will tell me. Forget about it, pal.

　　Total time complexity is O(n!). Space complexity is O(n^2).

Accepted code:

// 3CE, 2TLE, 1WA, 1AC, DFS from right to left will do, while from left to right it wouldn't.
class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) {
        result.clear();
        n = (int)s.length();
        if (n == 0 || dict.empty()) {
            return result;
        }
        
        dp.resize(n);
        int i, j;
        for (i = 0; i < n; ++i) {
            dp[i].resize(n - i);
        }
        
        string str;
        for (i = 0; i < n; ++i) {
            for (j = i; j < n; ++j) {
                str = s.substr(i, j - i + 1);
                if (dict.find(str) != dict.end()) {
                    dp[i][j - i] = 1;
                } else {
                    dp[i][j - i] = 0;
                }
            }
        }
        
        words.clear();
        dfs(s, n - 1);
        for (i = 0; i < n; ++i) {
            dp[i].clear();
        }
        dp.clear();
        
        return result;
    }
private:
    int n;
    vector<string> result;
    vector<string> words;
    vector<vector<int> > dp;
    
    void dfs(const string &s, int idx) {
        if (idx == -1) {
            getResultString();
        } else {
            int i;
            for (i = 0; i <= idx; ++i) {
                if (dp[i][idx - i]) {
                    words.push_back(s.substr(i, idx - i + 1));
                    dfs(s, i - 1);
                    words.pop_back();
                }
            }
        }
    }
    
    void getResultString() {
        if (words.empty()) {
            return;
        }
        string str = words[(int)words.size() - 1];
        int i;
        for (i = (int)words.size() - 2; i >= 0; --i) {
            str += (" " + words[i]);
        }
        result.push_back(str);
    }
};