Merge pull request 6boris#104 from kylesliu/develop

add 139 140 problem solution

Author: 6boris

src/0139.Word-Break/README.md

@@ -0,0 +1,115 @@
+# [139. Word Break][title]
+
+## Description
+
+Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
+
+## Note:
+
+The same word in the dictionary may be reused multiple times in the segmentation.
+You may assume the dictionary does not contain duplicate words.
+
+**Example 1:**
+
+```
+Input: s = "leetcode", wordDict = ["leet", "code"]
+Output: true
+Explanation: Return true because "leetcode" can be segmented as "leet code".
+```
+
+**Example 2:**
+
+```
+Input: s = "applepenapple", wordDict = ["apple", "pen"]
+Output: true
+Explanation: Return true because "applepenapple" can be segmented as "apple pen apple".
+             Note that you are allowed to reuse a dictionary word.
+```
+
+**Example 3:**
+
+```
+Input: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
+Output: false
+```
+
+
+**Tags:** Math, String
+
+## 题意
+> 给定一个非空字符串ss和一个非空词典wordDictwordDict,判断ss是否能被分割成一个或多个单词分隔的序列。
+> 注意，词典中的词可以用多次，词典中没有重复的单词。
+
+## 题解
+
+### 思路1
+> 动态规划
+
+```go
+package main
+
+func wordBreak(s string, wordDict []string) bool {
+	dp := make([]bool, len(s)+1)
+	dp[0] = true
+
+	for i := 0; i < len(dp); i++ {
+		if dp[i] {
+			for _, word := range wordDict {
+				//	巧妙的运用 i + word len 避免2层循环
+				if i+len(word) <= len(s) && s[i:i+len(word)] == word {
+					dp[i+len(word)] = true
+				}
+			}
+		}
+	}
+	return dp[len(s)]
+}
+```
+
+### 递归
+> 思路2
+```go
+package main
+
+func wordBreak3(s string, wordDict []string) bool {
+	ans := make(map[string]bool)
+	return helper(s, wordDict, ans)
+}
+
+//	s 每次比对的字符串
+//	wordDict 目标字典列表
+// 	匹配结果
+func helper(s string, wordDict []string, ans map[string]bool) bool {
+	//	终止条件
+	if len(s) == 0 {
+		return true
+	}
+
+	if res, ok := ans[s]; ok {
+		return res
+	}
+
+	for _, word := range wordDict {
+		if len(word) > len(s) || word != s[:len(word)] {
+			continue
+		}
+
+		if helper(s[len(word):], wordDict, ans) {
+			ans[s] = true
+			return true
+		}
+
+	}
+	ans[s] = false
+
+	return false
+}
+
+```
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode][me]
+
+[title]: https://leetcode.com/problems/word-break
+[me]: https://github.com/kylesliu/awesome-golang-leetcode

src/0139.Word-Break/Solution.go

@@ -0,0 +1,75 @@
+package Solution
+
+//	暴力遍历 比较 时间复杂度到 O(N3)
+func wordBreak(s string, wordDict []string) bool {
+	dp := make([]bool, len(s)+1)
+	dp[0] = true
+
+	for i := 1; i <= len(s); i++ {
+		for j := 0; j <= i-1; j++ {
+			if dp[j] == true {
+				for _, word := range wordDict {
+					if s[j:i] == word {
+						dp[i] = true
+						break
+					}
+				}
+			}
+
+		}
+	}
+	return dp[len(s)]
+}
+
+//	一次遍历时间复杂度 O(N2)
+func wordBreak2(s string, wordDict []string) bool {
+	dp := make([]bool, len(s)+1)
+	dp[0] = true
+
+	for i := 0; i < len(dp); i++ {
+		if dp[i] {
+			for _, word := range wordDict {
+				//	巧妙的运用 i + word len 避免2层循环
+				if i+len(word) <= len(s) && s[i:i+len(word)] == word {
+					dp[i+len(word)] = true
+				}
+			}
+		}
+	}
+	return dp[len(s)]
+}
+
+//	递归遍历
+func wordBreak3(s string, wordDict []string) bool {
+	dict := make(map[string]bool)
+	return dfs(s, wordDict, dict)
+}
+
+//	s 每次比对的字符串
+//	wordDict 目标字典列表
+// 	匹配结果
+func dfs(s string, wordDict []string, dict map[string]bool) bool {
+	//	终止条件
+	if len(s) == 0 {
+		return true
+	}
+
+	if res, ok := dict[s]; ok {
+		return res
+	}
+
+	for _, word := range wordDict {
+		if len(word) > len(s) || word != s[:len(word)] {
+			continue
+		}
+
+		if dfs(s[len(word):], wordDict, dict) {
+			dict[s] = true
+			return true
+		}
+
+	}
+	dict[s] = false
+
+	return false
+}

src/0139.Word-Break/Solution_test.go

@@ -0,0 +1,92 @@
+package Solution
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestSolution1(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		input1 string
+		input2 []string
+		expect bool
+	}{
+		{"TestCase", "leetcode", []string{"leet", "code"}, true},
+		{"TestCase", "applepenapple", []string{"apple", "pen"}, true},
+		{"TestCase", "catsandog", []string{"cats", "dog", "sand", "and", "cat"}, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := wordBreak(c.input1, c.input2)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with input1: %v input2: %v",
+					c.expect, got, c.input1, c.input2)
+			}
+		})
+	}
+}
+
+func TestSolution2(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		input1 string
+		input2 []string
+		expect bool
+	}{
+		{"TestCase", "leetcode", []string{"leet", "code"}, true},
+		{"TestCase", "applepenapple", []string{"apple", "pen"}, true},
+		{"TestCase", "catsandog", []string{"cats", "dog", "sand", "and", "cat"}, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := wordBreak2(c.input1, c.input2)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with input1: %v input2: %v",
+					c.expect, got, c.input1, c.input2)
+			}
+		})
+	}
+}
+
+func TestSolution3(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		input1 string
+		input2 []string
+		expect bool
+	}{
+		{"TestCase", "leetcode", []string{"leet", "code"}, true},
+		{"TestCase", "applepenapple", []string{"apple", "pen"}, true},
+		{"TestCase", "catsandog", []string{"cats", "dog", "sand", "and", "cat"}, false},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := wordBreak3(c.input1, c.input2)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with input1: %v input2: %v",
+					c.expect, got, c.input1, c.input2)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+
+}
+
+//	使用案列
+func ExampleSolution() {
+
+}

src/0140.Word-Break-II/README.md

@@ -0,0 +1,64 @@
+# [140. Word Break II][title]
+
+## Description
+
+Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.
+
+Note:
+
+The same word in the dictionary may be reused multiple times in the segmentation.
+You may assume the dictionary does not contain duplicate words.
+**Example 1:**
+
+```
+Input:
+s = "catsanddog"
+wordDict = ["cat", "cats", "and", "sand", "dog"]
+Output:
+[
+  "cats and dog",
+  "cat sand dog"
+]
+```
+
+**Example 2:**
+
+```
+Input:
+s = "pineapplepenapple"
+wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
+Output:
+[
+  "pine apple pen apple",
+  "pineapple pen apple",
+  "pine applepen apple"
+]
+Explanation: Note that you are allowed to reuse a dictionary word.
+```
+
+**Tags:** Math, String
+
+## 题意
+> 求2数之和
+
+## 题解
+
+### 思路1
+> 。。。。
+
+```go
+
+```
+
+### 思路2
+> 思路2
+```go
+
+```
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-leetcode][me]
+
+[title]: https://leetcode.com/problems/word-break-ii/
+[me]: https://github.com/kylesliu/awesome-golang-leetcode

src/0140.Word-Break-II/Solution.go

@@ -0,0 +1,31 @@
+package Solution
+
+func wordBreak(s string, wordDict []string) []string {
+	return dfs(s, wordDict, map[string][]string{})
+}
+
+func dfs(s string, wordDict []string, dict map[string][]string) []string {
+	if res, ok := dict[s]; ok {
+		return res
+	}
+	if len(s) == 0 {
+		return []string{""}
+	}
+
+	var res []string
+
+	for _, word := range wordDict {
+		if len(word) <= len(s) && word == s[:len(word)] {
+			for _, str := range dfs(s[len(word):], wordDict, dict) {
+				if len(str) == 0 {
+					res = append(res, word)
+				} else {
+					res = append(res, word+" "+str)
+				}
+			}
+
+		}
+	}
+	dict[s] = res
+	return res
+}