LeetCode_139: 单词拆分

最新推荐文章于 2022-04-22 17:02:46 发布

AnEra

最新推荐文章于 2022-04-22 17:02:46 发布

阅读量386

点赞数

分类专栏： # 经典算法题文章标签： LeetCode

本文链接：https://blog.youkuaiyun.com/qq_38975553/article/details/108647685

版权

经典算法题专栏收录该内容

13 篇文章

订阅专栏

链接

LeetCode_139: 单词拆分

问题

给定一个非空字符串 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

我的题解

题解1: 记忆化递归

逐个截取字符串s中的前i个字符, 进行比较, 一旦前i个字符存在于字典集中, 那么将剩下的字符串截取出来, 重复之前的步骤, 直至s的长度为0, 并且在递归过程中, 对于已经确认不存在于字典集中的字符串加入set集合, 防止重复校验

/**
 * 思路一:
 * 记忆化递归
 */
public static boolean wordBreak(String s, List<String> wordDict) {
    if(s == null || s.length() == 0) return false;
    if(wordDict == null || wordDict.size() == 0) return false;
    Set<String> checkedSet = new HashSet<>();
    return wordBreak_1(s,wordDict,checkedSet);
}

public static boolean wordBreak_1(String s, List<String> wordDict,Set<String> checkedSet) {
    int length = s.length();
    if(length == 0) return true;
    if(checkedSet.contains(s)) return false;
    for(int i = 1; i <= length; i++){
        String subString1 = s.substring(0,i);
        if(!wordDict.contains(subString1)){
            checkedSet.add(s);
        } else if(wordBreak_1(s.substring(i, length),wordDict,checkedSet)){
            return true;
        }
    }
    return false;
}

题解2: 动态规划

状态定义
dp(i) --> 字符串s的前 i个字符是否可以被空格拆分为一个或多个在字典中出现的单词
dp(j) --> 字符串s的前 j个字符是否可以被空格拆分为一个或多个在字典中出现的单词
初始化状态
dp(0) = true
装填转移方程
dp(i) = dp(j) && wordDict.contain([j,i])

/**
 * 思路二
 * 动态规划
 *
 * 状态定义
 * dp(i) --> 字符串s的前 i个字符是否可以被空格拆分为一个或多个在字典中出现的单词
 * dp(j) --> 字符串s的前 j个字符是否可以被空格拆分为一个或多个在字典中出现的单词
 * 初始化状态
 * dp(0) = true
 * 装填转移方程
 * dp(i) = dp(j) && wordDict.contain([j,i])
 */
public static boolean wordBreak(String s, List<String> wordDict) {
    //合法性校验
    if(s == null || s.length() == 0) return true;
    if(wordDict == null || wordDict.size() == 0) return false;
    //list转为set, 在计算是否包含时速度更快
    Set<String> wordDictSet = new HashSet<>(wordDict);
    //前i个字符是否可以被空格拆分为一个或多个在字典中出现的单词
    boolean[] dp = new boolean[s.length()+1];
    dp[0] = true;
    //如果字符串为"", 默认为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()];
}

题解3: 动态规划 -- 剪枝优化

/**
 * 动态规划 -- 剪枝优化
 */
public static boolean wordBreak_Better(String s, List<String> wordDict) {
    //合法性校验
    if(s == null || s.length() == 0) return true;
    if(wordDict == null || wordDict.size() == 0) return false;
    //list转为set, 在计算是否包含时速度更快
    Set<String> wordDictSet = new HashSet<>();
    int maxLen = 0;
    for (String word : wordDict) {
        wordDictSet.add(word);
        maxLen = Math.max(maxLen,word.length());
    }
    //前i个字符是否可以被空格拆分为一个或多个在字典中出现的单词
    boolean[] dp = new boolean[s.length()+1];
    dp[0] = true;
    //如果字符串为"", 默认为true
    for (int i = 1; i <= s.length(); i++) {
       /**
        * for (int j = 0; j < i; j++) {
            //dp[j]为字符串s的子串, 那么如果dp[j]为true, 那么j一定小于等于字典集合中最长的字符串
            if(dp[j] && wordDictSet.contains(s.substring(j,i))){
                dp[i] = true;
                break;
            }
        }
        */
        /**
         * j >= i - maxLen ==> maxLen >= i - j, 即i与j之前的字符串长度最长不能超过字典集中最大的字符串
         */
         for(int j = i; j >= 0 && j >= i - maxLen; j--){
             // dp[j]: 已校验完成的前j个字符
             // s.substring(j, i): 此次校验的字符
            if(dp[j] && wordDictSet.contains(s.substring(j, i))){
              dp[i] = true;
              break;
            }
         }
    }
    return dp[s.length()];
}