LintCode: Word Break

给定字符串序列和一个字典，问给定的字符串能否用字典中的单词拼出来？

图：

　　节点：字符串的前缀长度

　　边：前缀x如果加一个字典里边的单词能形成新前缀x'，则有一条边

　　　　例如：字符串IAMxxxxx，字典里有I和AM

　　　　则有（0，1）一条边，（1，3）一条边

解：从（0，？）到（？，n）找一条路径

这是一个判断是否有解的问题

BFS／DFS

　　从当前前缀开始加一个单词

其他

　　能否dp？bool dp[x]表示能否连到x位置

　　dp[x] ＝ dp[y] && (y..x是一个单词)

思考：

　　如何求一组解？全部解？

C++ 

DFS

(lintcode: s太长的话，会溢出。64bit mac OS上字符串长度超过8881就溢出。)

(leetcode: Accepted)

class Solution {
public:
    bool help(string &s, int now, unordered_set<string> &d, vector<bool> &have) {
        if (now >= s.length()) {
            return true;
        }
        if (have[now]) {
            return false;
        }
        have[now] = true;
        for (int i = now; i < s.length(); ++i) {
            if ((d.find(s.substr(now, i - now + 1)) != d.end()) && (help(s, i + 1, d, have))) {
                return true;
            }
        }
        return false;
    }
    /**
     * @param s: A string s
     * @param dict: A dictionary of words dict
     */
    bool wordBreak(string s, unordered_set<string> &dict) {
        // write your code here
        vector<bool> have(s.length(), false);
        return help(s, 0, dict, have);
    }
};

C++

BFS

(lintcode：字符串太长，例如超过10000个字符，会超时)

(leetcode: Accepted)

class Solution {
public:
    bool help(string &s, unordered_set<string> &d) {
        if (0 == s.length()) {
            return true;
        }
        vector<bool> have(s.length(), false);
        have[0] = true;
        queue<int> q;
        for (q.push(0); !q.empty(); q.pop()) {
            int now = q.front();
            for (int i = now; i < s.length(); ++i) {
                if ((d.find(s.substr(now, i - now + 1)) != d.end())) {
                    if (i + 1 >= s.length()) {
                        return true;
                    }
                    if (!have[i + 1]) {
                        have[i + 1] = true;
                        q.push(i + 1);
                    }
                }
            }
        }
        
        return false;
    }
    /**
     * @param s: A string s
     * @param dict: A dictionary of words dict
     */
    bool wordBreak(string s, unordered_set<string> &dict) {
        // write your code here
        return help(s, dict);
    }
};

C++

DP

(lintcode：字符串太长，例如超过10000个字符，会超时)

(leetcode: Accepted)

class Solution {
public:
    bool help(string &s, unordered_set<string> &d) {
        if (0 == s.length()) {
            return true;
        }
        vector<bool> dp(s.length(), false);
        dp[0] = true;
        for (int now = 0; now < s.length(); ++now) {
            if (!dp[now]) {
                continue;
            }
            for (int i = now; i < s.length(); ++i) {
                if ((d.find(s.substr(now, i - now + 1)) != d.end())) {
                    if (i + 1 >= s.length()) {
                        return true;
                    }
                    dp[i + 1] = true;
                }
            }
        }
        
        return false;
    }
    /**
     * @param s: A string s
     * @param dict: A dictionary of words dict
     */
    bool wordBreak(string s, unordered_set<string> &dict) {
        // write your code here
        return help(s, dict);
    }
};

 Python

DP

class Solution:
    # @param s: A string s
    # @param dict: A dictionary of words dict
    def wordBreak(self, s, dict):
        if len(dict) == 0:
            return len(s) == 0
            
        n = len(s)
        f = [False] * (n + 1)
        f[0] = True
        
        maxLength = max([len(w) for w in dict])
        for i in xrange(1, n + 1):
            for j in range(1, min(i, maxLength) + 1):
                if not f[i - j]:
                    continue
                if s[i - j:i] in dict:
                    f[i] = True
                    break
        
        return f[n]