LeetCode - Word Break

Word Break

2014.2.27 01:46

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".

Solution:

　　Whenever you see a problem about string, and the result is only a "Yes" or "No", you should try to solve it without using DFS. Most probably there is an efficient solution using dynamic programming.

　　Here we define the string as "breakable" if it can be segmented into pieces such that every piece is a word from the given dictionary.

　　If s[1:i] is breakable and s[i+1:j] is in the dictionary, s[1:j] is breakable, too.

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

Accepted code:

// 1CE, 1TLE, 1AC, O(n^2) solution with DP. DFS will cause timeout.
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        int n;
        int i, j;
        string str;
        vector<int> dp;
        
        n = (int)s.length();
        if (n == 0 || dict.empty()) {
            return false;
        }
        dp.resize(n);
        for (i = 0; i < n; ++i) {
            str = s.substr(0, i + 1);
            if (dict.find(str) != dict.end()) {
                dp[i] = 1;
            } else {
                for (j = 0; j < i; ++j) {
                    if (dp[j] && dict.find(s.substr(j + 1, i - j)) != dict.end()) {
                        dp[i] = 1;
                        break;
                    }
                }
                if (j == i) {
                    dp[i] = 0;
                }
            }
        }
        
        i = dp[n - 1];
        dp.clear();
        return i == 1;
    }
};