leetcode刷题笔记一百三十九题与一百四十题 单词拆分与单词拆分II

leetcode刷题笔记一百三十九题与一百四十题 单词拆分与单词拆分II

源地址：

139. 单词拆分

140. 单词拆分 II

问题描述：

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

140题问题描述

定一个非空字符串 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"]
输出:[]

//139题
//139题使用动态规划的思想 以当前位置i做切割，若之前的字符串符合要求即dp(i) = true, 判断之后的字符串是否符合要求更新
//初始状态方程：dp(0) = true
//dp(i) == dp(j) && checkBool(s.substring(j,i))
object Solution {
    def wordBreak(s: String, wordDict: List[String]): Boolean = {
        val dp = Array.fill(s.length+1)(false)
        dp(0) = true

        for (i <- 1 to s.length){
            for(j <- 0 to i){
                if (dp(j) == true && wordDict.contains(s.substring(j, i)))
                dp(i) = true
            }
        }
        return dp(s.length)
    }
}

//140题
//本题使用了递归的想法，当判断前串符合要求，继而判断右侧串是否符合要求，若右侧符合则添加
import scala.collection.mutable
object Solution {
    def wordBreak(s: String, wordDict: List[String]): List[String] = {
        val cache = mutable.HashMap[Int, List[String]]()
        val dict = wordDict.toSet
        
        cache.put(s.length, List(" "))
        
        def rec(start: Int): List[String] = {
            if (cache.contains(start))  return cache(start)
            else {
                val list = mutable.ListBuffer[String]()
                for (i <- start+1 to s.length){
                    val left = s.substring(start, i)
                    if (dict.contains(left)){
                        val right = rec(i)
                        list ++= right.map(x => s"$left $x".trim)
                    }
                }
                cache.put(start, list.toList)
                list.toList
            }
        }
        return rec(0)
    }
}