Word Break

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

思路：

直接使用DFS会超时，增加状态记录，用canForm[j]表示从j到s的末尾是否可以用字典里的词表示，AC。

还可以改成DP的方法。

代码:

    int *canForm;
    bool wordBreak(string s, int len, unordered_set<string> &dict, int maxlen, int minlen){
        if(s.length() < minlen){
            return false;
        }
        if(canForm[len-1] != -1)
            return canForm[len-1] == 1;
        for(int i = maxlen; i >= minlen; i--){
            string tmp = s.substr(0, i);
            if(dict.find(tmp) == dict.end())
                continue;
            if(tmp == s){
                canForm[len-1] = 1;
                return true;
            }
            if(wordBreak(s.substr(i), len-i, dict, maxlen, minlen)){
                canForm[len-1] = 1;
                return true;
            }
        }
        canForm[len-1] = 0;
        return false;
    }
    bool wordBreak(string s, unordered_set<string> &dict) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if(s == "")
            return true;
        int maxlen = 0;
        int minlen = INT_MAX;
        canForm = new int[s.length()];
        memset(canForm, -1, sizeof(int)*s.length());
        for(unordered_set<string>::iterator it = dict.begin(); it != dict.end(); it++){
            if(maxlen < (*it).length())
                maxlen = (*it).length();
            if(minlen > (*it).length())
                minlen = (*it).length();
        }
        int l = s.length();
        return wordBreak(s, l, dict, maxlen, minlen);
    }

 DFS第二遍：

    bool search(string s, int index, int canBreak[],  unordered_set<string> &dict){
        if(canBreak[index] != -1)
            return canBreak[index] == 1;
        for(int i = index; i < s.length(); i++){
            string tmp = s.substr(index, i-index+1);
            if(dict.find(tmp) != dict.end()){
                if(search(s, i+1, canBreak, dict)){
                    canBreak[index] = 1;
                    return true;
                }
            }
        }
        canBreak[index] = 0;
        return false;
    }
    bool wordBreak(string s, unordered_set<string> &dict) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int l = s.length();
        if(l == 0)
            return true;
        int canBreak[l+1];
        memset(canBreak, -1, sizeof(canBreak));
        canBreak[l] = 1;
        return search(s, 0, canBreak, dict);
    }

DP的解法：

    bool wordBreak(string s, unordered_set<string> &dict) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int l = s.length();
        bool canBreak[l+1];
        memset(canBreak, false, sizeof(canBreak));
        canBreak[0] = true;
        int i,j;
        for(i = 1; i <= l; i++){
            if(canBreak[i-1]){
                for(j = i-1; j < l; j++){
                    string tmp = s.substr(i-1, j-i+2);
                    if(dict.find(tmp) != dict.end())
                        canBreak[j+1] = true;
                }
            }
        }
        return canBreak[l];
    }