【Lintcode】107. Word Break

题目地址：

https://www.lintcode.com/problem/word-break/description

给定一个字符串和一个含字符串的哈希表，问该字符串是否可以由哈希表中的字符串拼接而成。

思路是DFS。枚举从某个位置开始对该字符串进行切割的长度，如果切割出哈希表里有的字符串，则进入下一层递归，继续枚举切割，直到切割完毕。为了节省时间，可以先将哈希表里的字符串的最短和最长的长度记下，这样对字符串进行切割时切割的长度就有个合法的范围了。代码如下：

import java.util.HashSet;
import java.util.Set;

public class Solution {
    /*
     * @param s: A string
     * @param dict: A dictionary of words dict
     * @return: A boolean
     */
    public boolean wordBreak(String s, Set<String> dict) {
        // write your code here
        if (s == null || s.isEmpty()) {
            return true;
        }
        // 求出dict里字符串的最短和最长的长度
        int min = s.length(), max = 0;
        for (String word : dict) {
            min = Math.min(min, word.length());
            max = Math.max(max, word.length());
        }
        
        return dfs(s, 0, dict, min, max);
    }
    
    // 从s的s[pos]开始切割，并返回从此处开始切割能否切出合法的分割
    private boolean dfs(String s, int pos, Set<String> dict, int min, int max) {
    	// 如果pos等于了字符串尾，说明产生了一个合法的切割，则返回true
        if (pos == s.length()) {
            return true;
        }
        // s[pos, i]的长度是i - pos + 1，其范围为[min, max]，
        // 所以i的范围是[pos + min - 1, pos + max - 1]，
        // 此外i还应该小于s的长度
        for (int i = pos + min - 1; i <= pos + max - 1 && i < s.length(); i++) {
        	// 如果切出一个含于dict的字符串，则进入下一层递归，
        	// 如果下一层递归返回true，说明能产生一个合法的切割，则返回true
            if (dict.contains(s.substring(pos, i + 1))) {
                if (dfs(s, i + 1, dict, min, max)) {
                    return true;
                }
            }
        }
   		// 若枚举了所有方式都没有产生合法的切割，则返回false     
        return false;
    }
}

时间复杂度$O(max(max-min{)}^{\frac{n}{min}})$（递归树的分叉数是$max-min$，树深度是$\frac{n}{min}$，每个节点要做字符串是否在dict里的check，最差需要$O(max)$），空间$O(\frac{n}{min})$（递归深度）。