单词切分

题目一：给出一个字符串s和一个词典，判断字符串s是否可以被空格切分成一个或多个出现在字典中的单词。
例子：给出s = “lintcode” dict = [“lint”,”code”] 返回 true 因为”lintcode”可以被空格切分成”lint code”

方法：动态规划。dp[i]：S[0:i-1]是否能被break。例如dp[1]表示s[0]是否能被break。
dp[0] = true
dp[i] = true if and only if:

1. 存在一个i-1>=k>=0，使s[k:i-1]存在于dict中。

2. s[0: k-1]可以被break，即dp[k] = true。

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        vector<bool> dp(s.size()+1,false);
        dp[0] = true;
        for(int i=0; i<s.size(); i++) {
            for(int j=i; j>=0; j--) {
                if(dp[j] && dict.count(s.substr(j,i-j+1))!=0) {
                    dp[i+1] = true;
                    break;
                }
            }
        }
        return dp[s.size()];
    }
};

题目二：返回所有可能的分词
例子：
s = “catsanddog”,
dict = [“cat”, “cats”, “and”, “sand”, “dog”].
返回 [“cats and dog”, “cat sand dog”]

方法：首先判断s是否能被切分（用动态规划，math[i][j] 来表示 i–j 这一段是否可以切分），如果可以，调用dfs进行遍历（k表示s的起始位置，had表示已经分出的单词，ans存最终结果）。

class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) 
    {
        int n=s.length();
        vector<vector<bool> > match(n+1,vector<bool>(n+1,false));
        for(int i=0;i<=n;i++)
            match[0][i]=true;
        for(int len=1;len<=n;len++)
        {
            for(int start=0;start+len<=n;start++)
            {
                string tmp=s.substr(start,len);
                if(dict.count(tmp)>0)
                    match[len][start]=true;
                else
                {
                    for(int left=1;left<len;left++)
                    {
                        match[len][start]=match[left][start]&&match[len-left][start+left];
                        if(match[len][start])
                            break;
                    }
                }
            }
        }
        if(match[n][0]==false)
            return vector<string>();
        vector<string> ans;
        vector<string> had;
        dfs(s,0,match,had,ans,dict);
        return ans;
    }
    void dfs(string& s,int k,vector<vector<bool> >& match,vector<string>& had,vector<string>& ans,unordered_set<string> &dict)
    {
        int n=s.length();
        if(k>=n)//结束递归
        {
            if(!had.empty())//had不为空，说明可行，记录结果
            {
                string ret;
                for(int i=0;i<had.size();i++)
                {
                    ret.append(had[i]);
                    if(i!=had.size()-1)
                        ret.push_back(' ');
                }
                ans.push_back(ret);
                return;
            }
        }
        for(int len=1;k+len<=n;len++)//从位置k开始遍历
        {
            string tmp=s.substr(k,len);
            if(dict.count(tmp)>0 && match[n-k-len][k+len])
            {
                had.push_back(tmp);
                dfs(s,k+len,match,had,ans,dict);
                had.pop_back();
            }
        }
    }   
};