Medium | LeetCode 140. 单词拆分 II | 回溯(递归)

140. 单词拆分 II

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。

说明：

• 分隔时可以重复使用字典中的单词。
• 你可以假设字典中没有重复的单词。

示例 1：

输入:
s = "catsanddog"
wordDict = ["cat", "cats", "and", "sand", "dog"]
输出:
[
  "cats and dog",
  "cat sand dog"
]

示例 2：

输入:
s = "pineapplepenapple"
wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
输出:
[
  "pine apple pen apple",
  "pineapple pen apple",
  "pine applepen apple"
]
解释: 注意你可以重复使用字典中的单词。

示例 3：

输入:
s = "catsandog"
wordDict = ["cats", "dog", "sand", "and", "cat"]
输出:
[]

解题思路

此题和 Medium | LeetCode 139. 单词拆分 | 动态规划 基本一致。在LeetCode 139题中, 只需要判断是否能够拆分。解决办法是使用迭代的办法, 在判断[0, i)是否能够拆分的时候, 遍历[0, i)中的所有的j, 判断[0, j]是否可拆分以及[j, i]是否在字典中。一旦发现是可以拆分的, 就结束当前的遍历[0, i)的循环。所以最终的时间复杂度是O(n^2)。

而要求所有的拆分的情况时, 时间复杂度是高多了。因为[0, i]可以有很多种情况的拆分。最终的结果是[0, i]以及(i, len)的所有的情况的排列组合的结果。

可以采用回溯的方法, 遍历所有的可能性。并且采用记忆化回溯的方式, 保存在某个位置的[0, i]拆分的所有结果。最终对结果进行排序组合输出即可。

public List<String> wordBreak(String s, List<String> wordDict) {
    // <数组下标, [0, i]的所有切分的方案> 保存在Hashmap当中
    Map<Integer, List<List<String>>> map = new HashMap<>();
    List<List<String>> wordBreaks = backtrack(s, s.length(), new HashSet<>(wordDict), 0, map);
    List<String> breakList = new LinkedList<>();
    for (List<String> wordBreak : wordBreaks) {
        breakList.add(String.join(" ", wordBreak));
    }
    return breakList;
}

/**
 * 回溯方法暴力遍历所有切分的可能结果
 * @param s         原始的数组
 * @param length    数组长度, 回溯的出口
 * @param wordSet   全局的不变的字典
 * @param index     回溯过程的数组的下标
 * @param map       保存在[i, length]的切分的所有组合, 记忆化回溯
 * @return          所有切分的结果
 */
public List<List<String>> backtrack(String s, int length, Set<String> wordSet,
        int index, Map<Integer, List<List<String>>> map) {
    // 记忆化回溯, 直接返回保存的结果
    if (map.containsKey(index)) {
        return map.get(index);
    }
    // 在[0, index]处所有的切分的方案
    List<List<String>> wordBreaks = new LinkedList<>();

    if (index == length) {
        // 递归出口, 递归到最后一个字符
        wordBreaks.add(new LinkedList<>());
        return wordBreaks;
    }

    for (int i = index + 1; i <= length; i++) {
        String word = s.substring(index, i);
        // 处理[index, i (length)]所有的在字典中出现的单词
        if (!wordSet.contains(word)) {
            // 剪枝, 跳过所有不包含在字典中的情况
            continue;
        }
        // 如果这个词在字典中出现, 则从新的index(i)处回溯, 返回[index, length]处所有的可能的方案
        List<List<String>> nextWordBreaks = backtrack(s, length, wordSet, i, map);
        for (List<String> nextWordBreak : nextWordBreaks) {
            // 遍历所有的方案
            LinkedList<String> wordBreak = new LinkedList<>(nextWordBreak);
            // 将当前[index, i]的这个单词加进[i, length]的结果集, 得到了[index, length]的其中一种结果
            wordBreak.offerFirst(word);
            // 将所有的这种结果加入最终的[index, length]的结果集
            wordBreaks.add(wordBreak);
        }
    }
    // 将当前位置的[i, length)的所有切分的方案保存起来
    map.put(index, wordBreaks);
    // 返回当前[i, length)回溯的结果
    return wordBreaks;
}