Word Break II

https://oj.leetcode.com/problems/word-break-ii/

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.

Return all such possible sentences.

For example, given
s = "catsanddog",
dict = ["cat", "cats", "and", "sand", "dog"].

A solution is ["cats and dog", "cat sand dog"].

这道题目与上题看似相似，其实只多一步还是有很大的区别。首先想到可以借助上题的思路，首先判断s是不是可以word break，并在这个过程中生成一个数组，每个数组是一个ArrayList，divideList[m].contains(n)就表示s.substring(m.n)在dict中。

考虑上面的例子。divideList的形式如下：

0——3，4

3——7

4——7

7——10

这是不是就是图的邻接表表示法，当然用邻接矩阵（二维数组）也是同样可以的。就是这个问题，困了我两天，期间还忙了很多事情。还是基本功不扎实。

于是剩下的问题，就是从0到10的所有可能路径。推广，找出所有可能的word break，就是找出divideList[]中所有从0到length - 1的路径。这就是图中的DFS或者BFS，可以用递归或者迭代来做。

public class Solution {

    public List<String> wordBreak(String s, Set<String> dict) {

        List<String> list = new ArrayList<String>();

        boolean[] dp = new boolean[s.length()];

        //一个邻接表表示的图，divideList[m] = n表示s的m到n的子串在dict中

        //找出所有可能的word break，就是找出所有从0到length - 1的路径

        List[] divideList = new ArrayList[s.length()];



        if (s.length() == 0) {

            return list;

        }



        if (dict.contains(s.substring(0, 1))) {

            dp[0] = true;

            divideList[0] = new ArrayList<Integer>();

            divideList[0].add(1);

        }



        for (int i = 1; i < s.length(); i++) {

            divideList[i] = new ArrayList<Integer>();

            if (dict.contains(s.substring(0, i + 1))) {

                if (divideList[0] == null) {

                    divideList[0] = new ArrayList<Integer>();

                }

                divideList[0].add(i + 1);

            }



            for (int j = 0; j < i; j++) {

                if (dict.contains(s.substring(0, i + 1)) || (dp[j] == true && dict.contains(s.substring(j + 1, i + 1)))) {

                    dp[i] = true;

//                    divideList[i].add(j);

                }



                if (dp[j] == true && dict.contains(s.substring(j + 1, i + 1))) {

                    divideList[j + 1].add(i + 1);

                }

            }

        }



        if (dp[s.length() - 1] == false) {

            return list;

        }



        //dfs divideList

        StringBuffer bf = new StringBuffer();

        dfsStringList(s, 0, list, bf, divideList);

        return list;

    }



    public static void dfsStringList(String s, int start, List<String> list, StringBuffer bf, List[] divideList) {

        //递归结束条件，到达string的结尾

        if (start == s.length()) {

            list.add(new String(bf));

            return;

        }

        

        //根据divideList的定义，如果调用到这个方法，必然从divideList[0]开始

        for (int i = 0; i < divideList[start].size(); i++) {

            int lengthBeforeAppend = bf.length();

            int end = (Integer) divideList[start].get(i);

            

            //每个单词后加上空格

            if(lengthBeforeAppend != 0){

                bf = bf.append(" ");

            }

            //将一个分词加入bf

            bf = bf.append(s.substring(start, end));

            //对这个分词后的子串递归dfs

            dfsStringList(s, end, list, bf, divideList);

            //考虑一个例子，0——3，4；3——7；4——7；7——10。0-3结束后递归3-10

            //递归结束后list.add(new String(bf));然后弹出栈，删除bf中7-10的子串，i向后，因为此时i只有一个，所以直到0，i到1，处理0-4

            bf = bf.delete(lengthBeforeAppend, bf.length());

        }

    }

}

事实上，这道题，dp只用来判断是否可以word break就可以了。如果dp[s.length() - 1] == fals，直接return 空list。后面索性将dict传入dfs方法，直接做dfs，反而较为简便。问题是，没有剪枝的过程，和上述方法相比，多了不少计算。下面是网上搜索的代码，下面会说明出处。

public class Solution {

    public ArrayList<String> wordBreak(String s, Set<String> dict) {

        ArrayList<String> ret = new ArrayList<String>();

        if (s==null || s.length()==0) return ret;

        int n = s.length();

        boolean[] dp = new boolean[n+1];

        dp[0] = true;

        for (int i=1; i<=n; i++) {

            if (dict.contains(s.substring(0, i))) {

                dp[i] = true;

                continue;

            }

            for (int j=0; j<i; j++) {

                if (dp[j] && dict.contains(s.substring(j, i))) {

                    dp[i] = true;

                }

            }

        }

        if (dp[n] == false) return ret; //DP的作用就这一行！！！

        StringBuilder cur = new StringBuilder();

        dfs(s, 0, cur, ret, dict);

        return ret;

    }



    public void dfs(String s, int start, StringBuilder cur, ArrayList<String> ret, Set<String> dict)  {

        int n = s.length();

        if (start >= n) {

            ret.add(new String(cur));

            return;

        }

        for (int i=start+1; i<=n; i++) {

            String sub = s.substring(start, i);

            if (dict.contains(sub)) {

                int oldLen = cur.length();

                if (oldLen!=0) cur.append(" ");

                cur.append(sub);

                dfs(s, i, cur, ret, dict);

                cur.delete(oldLen, cur.length());

            }

        }

    }

}

参考地址：

https://stupidcodergoodluck.wordpress.com/2013/11/16/leetcode-word-break-ii/

http://www.cnblogs.com/feiling/p/3357067.html

http://www.acmerblog.com/word-break-ii-6128.html

http://fisherlei.blogspot.jp/2013/11/leetcode-wordbreak-ii-solution.html