leetcode.140. 单词拆分 II

野性酷女 2022-11-21 14:57 184阅读 0赞

### 文章目录 ###

*  单词拆分
 *   *  代码与思路
 *  单词拆分 II
 *   *  代码与思路
     *   *  方法一：记忆化搜索
         *  方法二：动态规划

# 单词拆分 #

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

*  拆分时可以重复使用字典中的单词。
 *  你可以假设字典中没有重复的单词。  
    示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
    输出: true
    解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
    输出: true
    解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
         注意你可以重复使用字典中的单词。

示例 3：

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

## 代码与思路 ##

public class Solution { 
        public boolean wordBreak(String s, List<String> wordDict) { 
            Set<String> wordDictSet = new HashSet(wordDict);
            boolean[] dp = new boolean[s.length() + 1];
            dp[0] = true;
            for (int i = 1; i <= s.length(); i++) { 
                for (int j = 0; j < i; j++) { 
                    if (dp[j] && wordDictSet.contains(s.substring(j, i))) { 
                        dp[i] = true;
                        break;
                    }
                }
            }
            return dp[s.length()];
        }
    }

参考[思路][Link 1]

# 单词拆分 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"]
    输出:
    []

## 代码与思路 ##

### 方法一：记忆化搜索 ###

对于字符串 s，如果某个前缀是单词列表中的单词，则拆分出该单词，然后对 s 的剩余部分继续拆分。如果可以将整个字符串 s 拆分成单词列表中的单词，则得到一个句子。在对 s 的剩余部分拆分得到一个句子之后，将拆分出的第一个单词（即 s 的前缀）添加到句子的头部，即可得到一个完整的句子。上述过程可以通过回溯实现。

假设字符串 s 的长度为 n，回溯的时间复杂度在最坏情况下高达 O(n^n)。时间复杂度高的原因是存在大量重复计算，可以通过记忆化的方式降低时间复杂度。

具体做法是

*  使用哈希表存储字符串 s 的每个下标和从该下标开始的部分可以组成的句子列表，用的是`Map<Integer, List<List<String>>> map`
 *  在回溯过程中如果遇到已经访问过的下标，则可以直接从哈希表得到结果，而不需要重复计算。
 *  如果到某个下标发现无法匹配，则哈希表中该下标对应的是空列表，
 *  因此可以对不能拆分的情况进行剪枝优化。

还有一个可优化之处为使用哈希集合存储单词列表中的单词，这样在判断一个字符串是否是单词列表中的单词时只需要判断该字符串是否在哈希集合中即可，而不再需要遍历单词列表。

class Solution { 
        public List<String> wordBreak(String s, List<String> wordDict) { 
            Map<Integer, List<List<String>>> map = new HashMap<Integer, List<List<String>>>();
            List<List<String>> wordBreaks = backtrack(s, s.length(), new HashSet<String>(wordDict), 0, map);
            
            List<String> breakList = new LinkedList<String>();
            for (List<String> wordBreak : wordBreaks) { 
                breakList.add(String.join(" ", wordBreak));
            }
            return breakList;
        }
    
        public List<List<String>> backtrack(String s, int length, Set<String> wordSet, 
        int index, Map<Integer, List<List<String>>> map) { 
            if (!map.containsKey(index)) { 
                List<List<String>> wordBreaks = new LinkedList<List<String>>();
                if (index == length) { 
                    wordBreaks.add(new LinkedList<String>());
                }
                for (int i = index + 1; i <= length; i++) { 
                    String word = s.substring(index, i);
                    if (wordSet.contains(word)) { 
                        List<List<String>> nextWordBreaks = backtrack(s, length, wordSet, i, map);
                        for (List<String> nextWordBreak : nextWordBreaks) { 
                            LinkedList<String> wordBreak = new LinkedList<String>(nextWordBreak);
                            wordBreak.offerFirst(word);
                            wordBreaks.add(wordBreak);
                        }
                    }
                }
                map.put(index, wordBreaks);
            }
            return map.get(index);
        }
    }

[官方][Link 2]

### 方法二：动态规划 ###

动态规划求是否有解、回溯算法求所有具体解

import java.util.ArrayDeque;
    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    
    public class Solution { 
    
        public List<String> wordBreak(String s, List<String> wordDict) { 
            // 为了快速判断一个单词是否在单词集合中，需要将它们加入哈希表
            Set<String> wordSet = new HashSet<>(wordDict);
            int len = s.length();
    
            // 第 1 步：动态规划计算是否有解
            // dp[i] 表示「长度」为 i 的 s 前缀子串可以拆分成 wordDict 中的单词
            // 长度包括 0 ，因此状态数组的长度为 len + 1
            boolean[] dp = new boolean[len + 1];
            // 0 这个值需要被后面的状态值参考，如果一个单词正好在 wordDict 中，dp[0] 设置成 true 是合理的
            dp[0] = true;
    
            for (int right = 1; right <= len; right++) { 
                // 如果单词集合中的单词长度都不长，从后向前遍历是更快的
                for (int left = right - 1; left >= 0; left--) { 
                    // substring 不截取 s[right]，dp[left] 的结果不包含 s[left]
                    if (wordSet.contains(s.substring(left, right)) && dp[left]) { 
                        dp[right] = true;
                        // 这个 break 很重要，一旦得到 dp[right] = True ，不必再计算下去
                        break;
                    }
                }
            }
    
            // 第 2 步：回溯算法搜索所有符合条件的解
            List<String> res = new ArrayList<>();
            if (dp[len]) { 
                Deque<String> path = new ArrayDeque<>();
                dfs(s, len, wordSet, dp, path, res);
                return res;
            }
            return res;
        }
    
        /** * s[0:len) 如果可以拆分成 wordSet 中的单词，把递归求解的结果加入 res 中 * * @param s * @param len 长度为 len 的 s 的前缀子串 * @param wordSet 单词集合，已经加入哈希表 * @param dp 预处理得到的 dp 数组 * @param path 从叶子结点到根结点的路径 * @param res 保存所有结果的变量 */
        private void dfs(String s, int len, Set<String> wordSet, boolean[] dp, Deque<String> path, List<String> res) { 
            if (len == 0) { 
                res.add(String.join(" ",path));
                return;
            }
    
            // 可以拆分的左边界从 len - 1 依次枚举到 0
            for (int i = len - 1; i >= 0; i--) { 
                String suffix = s.substring(i, len);
                if (wordSet.contains(suffix) && dp[i]) { 
                    path.addFirst(suffix);
                    dfs(s, i, wordSet, dp, path, res);
                    path.removeFirst();
                }
            }
        }
    }

[转自liweiwei1419][liweiwei1419]

[Link 1]: https://leetcode-cn.com/problems/word-break/solution/dan-ci-chai-fen-by-leetcode-solution/
[Link 2]: https://leetcode-cn.com/problems/word-break-ii/solution/dan-ci-chai-fen-ii-by-leetcode-solution/
[liweiwei1419]: https://leetcode-cn.com/problems/word-break-ii/solution/dong-tai-gui-hua-hui-su-qiu-jie-ju-ti-zhi-python-d/