Merge pull request 6boris#82 from kylesliu/develop

update some stock problem solution

Author: 6boris

README.md

@@ -42,6 +42,7 @@ LeetCode of algorithms with golang solution(updating:smiley:).
 
 ## Community
 
+* [ACWING](https://www.acwing.com/) 一些算法竞赛大佬创建的平台，挺适合入门的。
 * [leetbook](https://github.com/hk029/leetbook) 某位大佬写的Leetcode题解，不过已经不更新了
 * [LeetCode-in-Go](https://github.com/aQuaYi/LeetCode-in-Go) 某位算法大佬的Golang题解
 

SUMMARY-LIST.md

@@ -1,7 +1,7 @@
 # SUMMARY-LIST
 
 
-- Link List
+- Linked List
     - [19. Remove Nth Node From End of List(删除从结尾数第n个结点)](https://leetcode.kyle.link/src/0019.Remove-Nth-Node-From-End-of-List/)
     - [83. Remove Duplicates from Sorted List(删除链表中的重复元素)](https://leetcode.kyle.link/src/0083.Remove-Duplicates-from-Sorted-List/)
     - [206. Reverse Linked List(反转链表)](https://leetcode.kyle.link/src/0206.Reverse-Linked-List/)
@@ -16,11 +16,26 @@
     - [148. Sort List(链表排序)](https://leetcode.kyle.link/src/0148.Sort-List/)
     - [146. LRU Cache (LRU缓存)](https://leetcode.kyle.link/src/0146.LRU-Cache/)
 
-- DFS
+- Depth-first Search
 
 - Tree
 
-- DP
+- Dynamic Programming
+   - [53. Maximum Subarray (求最大连续子序列长度)]()
+   - [300. Longest Increasing Subsequence ()]()
+   - [72. Edit Distance ()]()
+   - [121. Best Time to Buy and Sell Stock()]()
+   - [122. Best Time to Buy and Sell Stock II ()]()
+   - [123. Best Time to Buy and Sell Stock III ()]()
+   - [188. Best Time to Buy and Sell Stock IV ()]()
+   - [309. Best Time to Buy and Sell Stock with Cooldown ()]()
+   - [198. House Robber ()]()
+   - [213. House Robber II ()]()
+   - [312. Burst Balloons ()]()
+   - [96. Unique Binary Search Trees()]()
+   - [140. Word Break II()]()
+   - [10. Regular Expression Matching ()]()
+
 
 - QUEUE/STACK
 

src/0053.Maximum-Subarray/README.md

@@ -18,29 +18,75 @@ If you have figured out the O(*n*) solution, try coding another solution using t
 
 **Tags:** Array, Divide and Conquer, Dynamic Programming
 
+## 题意
+> 给定一个整数数组 `nums` ，找到`和`最大的连续子序列（至少包含一个数字），返回该子序列的和 
 
 ## 题解
 ### 思路1
-> 普通DP 找到公式就好了
-```$xslt
-如果nums[0]>=0，则sum = sum + nums[1]
-如果nums[0]<0，则sum = nums[1]，
-```
+> (动态规划) O(n)
+
+- 1.设 dp(i)dp(i) 表示以第`i`y个数字为结尾的最大连续子序列的`和`是多少。
+- 2.初始化 dp(0)=nums[0]dp(0)=nums[0]。
+- 3.转移方程 dp(i)=max(dp(i−1)+nums[i],nums[i])dp(i)=max(dp(i−1)+nums[i],nums[i])。可以理解为当前有两种决策，一种是将第`i`个数字和前边的数字拼接起来；另一种是第`i`个数字单独作为一个新的子序列的开始。
+- 4.最终答案为ans=max(dp(k)),0≤k<n。
+
+> 时间复杂度
+- 状态数为 O(n)，决策数为 O(1)，故总时间复杂度为 O(n)。
 
 ```go
 func maxSubArray(nums []int) int {
 	dp, ans := make([]int, len(nums)), nums[0]
 	dp[0] = nums[0]
 
 	for i := 1; i < len(nums); i++ {
-		dp[i] = Max(nums[i], nums[i]+dp[i-1])
-		ans = Max(ans, dp[i])
+		dp[i] = max(nums[i], nums[i]+dp[i-1])
+		ans = max(dp[i], ans)
 	}
-
 	return ans
 }
 ```
 ### 思路2
+> (分治) O(nlogn)
+
+- 考虑区间 `[l, r]` 内的答案如何计算，令 `mid = (l + r) / 2`，则该区间的答案由三部分取最大值，分别是：
+    - (1). 区间 `[l, mid]` 内的答案（递归计算）。
+    - (2). 区间 `[mid + 1, r]` 内的答案（递归计算）。
+    - (3). 跨越 mid和mid+1 的连续子序列。
+- 其中，第(3)部分只需要从 `mid` 开始向 `l` 找连续的最大值，以及从 `mid+1` 开始向 `r` 找最大值即可，在线性时间内可以完成。
+- 递归终止条件显然是 l==r ，此时直接返回` nums[l]`。
+
+> 时间复杂度
+
+- 由递归主定理 S(n)=2S(n/2)+O(n)，解出总时间复杂度为 O(nlogn)。
+- 或者每一层时间复杂度是 O(n)，总共有 O(logn) 层，故总时间复杂度是 O(nlogn)。
+
+> Code
+```go
+func maxSubArray(nums []int) int {
+	return calc(0, len(nums)-1, nums)
+}
+
+func calc(l, r int, nums []int) int {
+	if l == r {
+		return nums[l]
+	}
+	mid := (l + r) >> 1
+	lmax, lsum, rmax, rsum := nums[mid], 0, nums[mid+1], 0
+
+	for i := mid; i >= 1; i-- {
+		lsum += nums[i]
+		lmax = max(lmax, lsum)
+	}
+
+	for i := mid + 1; i <= r; i++ {
+		rsum += nums[i]
+		rmax = max(rmax, rsum)
+	}
+
+	return max(max(calc(l, mid, nums), calc(mid+1, r, nums)), lmax+rmax)
+}
+
+```
 
 
 ## 结语

src/0053.Maximum-Subarray/Solution.go

@@ -5,16 +5,40 @@ func maxSubArray(nums []int) int {
 	dp[0] = nums[0]
 
 	for i := 1; i < len(nums); i++ {
-		dp[i] = Max(nums[i], nums[i]+dp[i-1])
-		ans = Max(ans, dp[i])
+		dp[i] = max(nums[i], nums[i]+dp[i-1])
+		ans = max(dp[i], ans)
+		//fmt.Println(i, ans, dp, nums)
 	}
-
 	return ans
 }
 
-func Max(x, y int) int {
+func max(x, y int) int {
 	if x > y {
 		return x
 	}
 	return y
 }
+
+func maxSubArray2(nums []int) int {
+	return calc(0, len(nums)-1, nums)
+}
+
+func calc(l, r int, nums []int) int {
+	if l == r {
+		return nums[l]
+	}
+	mid := (l + r) >> 1
+	lmax, lsum, rmax, rsum := nums[mid], 0, nums[mid+1], 0
+
+	for i := mid; i >= 1; i-- {
+		lsum += nums[i]
+		lmax = max(lmax, lsum)
+	}
+
+	for i := mid + 1; i <= r; i++ {
+		rsum += nums[i]
+		rmax = max(rmax, rsum)
+	}
+
+	return max(max(calc(l, mid, nums), calc(mid+1, r, nums)), lmax+rmax)
+}

src/0053.Maximum-Subarray/Solution_test.go

@@ -1,14 +1,61 @@
 package Solution
 
-import "testing"
+import (
+	"reflect"
+	"strconv"
+	"testing"
+)
 
 func TestSolution(t *testing.T) {
-	t.Run("Test-1", func(t *testing.T) {
-		got := maxSubArray([]int{-2, 1, -3, 4, -1, 2, 1, -5, 4})
-		want := 6
-		if got != want {
-			t.Error("GOT:", got, "WANT:", want)
-		}
-	})
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs []int
+		expect int
+	}{
+		{"TestCase", []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}, 6},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := maxSubArray(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+func TestSolution2(t *testing.T) {
+	//	测试用例
+	cases := []struct {
+		name   string
+		inputs []int
+		expect int
+	}{
+		{"TestCase", []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}, 6},
+	}
+
+	//	开始测试
+	for i, c := range cases {
+		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
+			got := maxSubArray2(c.inputs)
+			if !reflect.DeepEqual(got, c.expect) {
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
+					c.expect, got, c.inputs)
+			}
+		})
+	}
+}
+
+//	压力测试
+func BenchmarkSolution(b *testing.B) {
+
+}
+
+//	使用案列
+func ExampleSolution() {
 
 }

src/0072.Edit-Distance/README.md

@@ -1,34 +1,62 @@
-# [1. Add Sum][title]
+# [72. Edit Distance][title]
 
 ## Description
 
-Given two binary strings, return their sum (also a binary string).
+Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
 
-The input strings are both **non-empty** and contains only characters `1` or `0`.
+You have the following 3 operations permitted on a word:
+
+- Insert a character
+- Delete a character
+- Replace a character
 
 **Example 1:**
 
 ```
-Input: a = "11", b = "1"
-Output: "100"
+Input: word1 = "horse", word2 = "ros"
+Output: 3
+Explanation: 
+horse -> rorse (replace 'h' with 'r')
+rorse -> rose (remove 'r')
+rose -> ros (remove 'e')
 ```
 
 **Example 2:**
 
 ```
-Input: a = "1010", b = "1011"
-Output: "10101"
+Input: word1 = "intention", word2 = "execution"
+Output: 5
+Explanation: 
+intention -> inention (remove 't')
+inention -> enention (replace 'i' with 'e')
+enention -> exention (replace 'n' with 'x')
+exention -> exection (replace 'n' with 'c')
+exection -> execution (insert 'u')
 ```
 
 **Tags:** Math, String
 
 ## 题意
->给你两个二进制串，求其和的二进制串。
+>给定两个单词 word1 和 word2 ，请问最少需要进行多少次操作可以将 word1 变成 word2 。
 
 ## 题解
 
 ### 思路1
-> 按照小学算数那么来做，用 `carry` 表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
+> (动态规划) O(n2)
+
+经典的编辑距离问题。
+
+状态表示：`f[i,j]` 表示将 `word1` 的前 `i` 个字符变成 `word2` 的前 `j` 个字符，最少需要进行多少次操作。
+状态转移，一共有四种情况：
+
+- 将`word1[i]` 删除或在`word2[j]`后面添加`word1[i]`，则其操作次数等于`f[i−1,j]+1`；
+- 将`word2[j]`删除或在`word1[i]`后面添加`word2[j]`，则其操作次数等于 `f[i,j−1]+1`；
+- 如果`word1[i]=word2[j]`，则其操作次数等于 `f[i−1,j−1]`；
+- 如果`word1[i]≠word2[j]`，则其操作次数等于 `f[i−1,j−1]+1`；
+
+> 时间复杂度分析：
+
+- 状态数 O(n2)O(n2)，状态转移复杂度是 O(1)O(1)，所以总时间复杂度是 O(n2)O(n2)。
 
 ```go
 

src/0121.Best-Time-to-Buy-and-Sell-Stock/README.md

@@ -23,15 +23,40 @@ Output: "10101"
 **Tags:** Math, String
 
 ## 题意
->只允许买卖一次
+>假设你有一个数组，其中第i个元素表示第i天某个股票的价格。
+ 如果您只允许完成至多一笔交易（即买入一只股票并卖出一只股票），则设计一种算法以找到最大利润。
+ 必须先购买股票再出售股票。
 
 ## 题解
 
 ### 思路1
-> 按照小学算数那么来做，用 `carry` 表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
+> 贪心
 
-```go
+- 遍历一次即可得出结果
 
+```go
+func maxProfit2(prices []int) int {
+	profit, low := 0, prices[0]
+	for i := 0; i < len(prices); i++ {
+		profit = max(profit, prices[i]-low)
+		low = min(low, prices[i])
+	}
+	return profit
+}
+
+func min(x, y int) int {
+	if x > y {
+		return y
+	}
+	return x
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
 ```
 
 ### 思路2