139. 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”.
思路一：采用动态规划的思想，定义一个数组dp, 其中dp[i]表示前i个字符是否可以由字典里的单词组成，例如若dp[1]=0,意味着s[0]被包含在字典中。
这里的递推式：如果已知dp[i]为真，即前i个字符可以表示出来，从第i个字符s[i]到第j个字符组成的单词s[i,…,j]如果在字典内，则dp[j]为真。

 bool wordBreak(string s, unordered_set<string>& wordDict) {
        int n=s.size();
        vector<bool> dp(n+1);
        dp[0]=true;
        for(int i=1;i<=s.size();i++)
        {
            for(int j=0;j<i;j++)
            {
                string str(s,j,i-j);//子字符串s[j,...,i-1]
                if(wordDict.find(str)!=wordDict.end()&&dp[j])
                {
                    dp[i]=true;
                    break;
                }
            }
        }
        return dp[n];
    }

思路二：采用回溯法，类似于图BFS遍历的思想。把第一个字符看成图的起点，把字符串末尾看成终点，字典里的每一个单词代表各个可能的边。你需要判断是否存在一条路径可以由起点到终点。例如”leetcode”,字典有[“lee”, “leet”,”leetc”, “code”], 它的起点是0，下一个能到达2，也能到达3和4,用一个队列存储它们，当你沿着leetc达到4之后，不能继续，返回则沿着leet到达3，发现可以到达。这里需要用set纪录已经访问的节点，如果2已经经过，但不能到达终点，下次就不访问它。
0–2；
0–3–7；
0–4；
过程：
1. queue:<0, 2,3,4>
2. 访问4，达不到，queue: <0,2,3>
3. 访问3，到达5
这里有set记录，主要用于剪枝，让走错的路不再重新走一遍。假设还是上述的”leetcode”,字典：[“le”, “etcode”, “lee”, “tc”,”leetc”]。其有如下路线：
0–2–8;
0–3–5;
0–5;
1. queue: <0,2,3,5>
2. 访问5，不可达，set: <5> ,queu:<0,2,3>
3. 访问3，再到5,在set中，停止搜索。queu:<0,2>
4. 访问2，可达8,返回true.

 bool wordBreak(string s, unordered_set<string>& wordDict) {
        int n=s.size();
        queue<int> bfs;
        bfs.push(0);
        unordered_set<int>  visited;
        while(!bfs.empty())
        {
            int vis=bfs.front();
            bfs.pop();
            if(visited.find(vis)==visited.end())
            {
                visited.insert(vis);
            for(int j=n-1;j>=vis;j--)
            {
                string tmp(s,vis,j-vis+1);
                if(wordDict.find(tmp)!=wordDict.end())
                {
                    if(j+1==n)
                    return true;
                    bfs.push(j+1);
                }
            }
            }
        }
        return false;
    }