opt stock problems

Author: 6boris

.gitignore

@@ -21,3 +21,4 @@ node_modules/
 .env.yml
 /python
 package-lock.json
+.hugo_build.lock

.prettierrc

@@ -0,0 +1,14 @@
+{
+  "overrides": [
+    {
+      "files": ".prettierrc",
+      "options": { "parser": "json" }
+    },
+    {
+      "files": ["*.md"],
+      "options": {
+        "tabWidth": 2
+      }
+    }
+  ]
+}

content/zh/docs/jzof/_index.md

@@ -1,5 +1,5 @@
 ---
-weight: 1
+weight: 11
 bookFlatSection: true
 title: "剑指 Offer"
 ---

…ntent/zh/docs/leetcode/0000-0099/0001.md …ntent/zh/docs/leetcode/0001-0100/0001.mdcontent/zh/docs/leetcode/0000-0099/0001.md renamed to content/zh/docs/leetcode/0001-0100/0001.md content/zh/docs/leetcode/0000-0099/0001.md renamed to content/zh/docs/leetcode/0001-0100/0001.md

@@ -1,7 +1,7 @@
 ---
 weight: 1
-title: "0000-0099"
+title: "0001-0100"
 bookCollapseSection: true
 ---
 
-# 0000-0099
+# 0001-0100

…ntent/zh/docs/leetcode/0000-0099/0002.md …ntent/zh/docs/leetcode/0001-0100/0002.mdcontent/zh/docs/leetcode/0000-0099/0002.md renamed to content/zh/docs/leetcode/0001-0100/0002.md content/zh/docs/leetcode/0000-0099/0002.md renamed to content/zh/docs/leetcode/0001-0100/0002.md

@@ -0,0 +1,211 @@
+---
+weight: 21
+bookFlatSection: true
+title: "121.买卖股票的最佳时机"
+description: "121.买卖股票的最佳时机"
+---
+
+# 121.买卖股票的最佳时机
+
+{{< hint danger >}}
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 算法 题解：[Awesome Golang Algorithm](https://github.com/kylesliu/awesome-golang-algorithm)
+{{< /hint >}}
+
+## 题目描述
+
+{{< button href="https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/" >}}题目地址{{< /button >}}
+{{< button href="https://github.com/kylesliu/awesome-golang-algorithm/tree/master/leetcode/101-200/0121.Best-Time-to-Buy-and-Sell-Stock" >}}代码{{< /button >}}
+
+给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
+你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
+返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
+
+{{< hint info >}}
+**提示**
+
+只能卖一次股票
+{{< /hint >}}
+
+### **示例 1**
+
+```text
+输入：[7,1,5,3,6,4]
+输出：5
+解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
+     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
+```
+
+### **示例 2**
+
+```text
+输入：prices = [7,6,4,3,1]
+输出：0
+解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
+```
+
+### **限制**
+
+- 1 <= prices.length <= 105
+- 0 <= prices[i] <= 104
+
+## 题解
+
+我们需要找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）。形式上，对于每组 `i` 和 `j`（其中 `j > i`）我们需要找出 {{< katex >}}\max(prices[j]−prices[i]){{< /katex >}}。
+
+### 思路 1：**暴力循环**
+
+**算法流程：**
+
+2 次循环分别找出最大价格和最小价格
+
+**复杂度分析：**
+
+- **时间复杂度:** {{< katex >}}\Omicron(N^{2}){{< /katex >}} , 循环运行 {{< katex >}}\cfrac{n (n-1)}{2}{{< /katex >}} 次。
+- **空间复杂度:** {{< katex >}}\Omicron(1){{< /katex >}} , 只使用了常数个变量。
+
+#### 代码
+
+{{< tabs "lc121-01" >}}
+{{< tab "Go" >}}
+
+```go
+func maxProfit_1(prices []int) int {
+	ans := 0
+	for i := 0; i < len(prices); i++ {
+		for j := i + 1; j < len(prices); j++ {
+			ans = max(ans, prices[j]-prices[i])
+		}
+	}
+	return ans
+}
+```
+
+{{< /tab >}}
+{{< /tabs >}}
+
+### 思路 2：**贪心**
+
+#### 算法流程
+
+![leetcode_121_2](https://s.gin.sh/blog/leetcode/leetcode_121_2.png)
+
+因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。
+
+#### 复杂度分析
+
+- **时间复杂度:** {{< katex >}}\Omicron(N){{< /katex >}}
+- **空间复杂度:** {{< katex >}}\Omicron(1){{< /katex >}}
+
+{{< tabs "lc121-02" >}}
+{{< tab "Go" >}}
+
+```go
+func maxProfit_2(prices []int) int {
+	ans, lowPrice := 0, prices[0]
+	for i := 0; i < len(prices); i++ {
+		ans = max(ans, prices[i]-lowPrice)
+		lowPrice = min(lowPrice, prices[i])
+	}
+	return ans
+}
+```
+
+{{< /tab >}}
+{{< /tabs >}}
+
+### 思路 3：**动态规划**
+
+#### 算法流程
+
+- 确定 dp 数组（Dynamic Planning）以及下标的含义：
+
+<!-- prettier-ignore -->
+{{< katex display >}}
+	\begin{dcases}
+	dp[i][0] & 第 i 天持有股票所得最多现金
+	\\
+	dp[i][1] & 第 i 天不持有股票所得最多现金
+	\end{dcases}
+{{< /katex >}}
+
+- 确定递推公式
+
+<!-- prettier-ignore -->
+{{< mermaid >}}
+flowchart LR
+    A[第 i 天是否持有股票] -->|持有| B(第 i-1 天是否持有股票)
+    A[第 i 天是否持有股票] -->|未持有| C(第 i-1 天是否持有股票)
+    B -->|持有| D["保存不动：dp[i - 1][0]"]
+    B -->|未持有| E["购买股票：-prices[i]"]
+		C -->|持有| F["保存不动：dp[i - 1][1]"]
+    C -->|未持有| G["购买股票：prices[i] + dp[i - 1][0]"]
+{{< /mermaid >}}
+
+<!-- prettier-ignore -->
+{{< katex display >}}
+	\begin{dcases}
+		dp[i][0] = \max(dp[i-1][0], -prices[i])
+		\\
+		dp[i][1] = \max(dp[i-1][1], dp[i-1][0]+prices[i])
+	\end{dcases}
+{{< /katex >}}
+
+- dp 数组如何初始化
+
+<!-- prettier-ignore -->
+{{< katex display >}}
+	\begin{dcases}
+	dp[0][0] = -prices[0]
+	\\
+	dp[0][1] = 0
+	\end{dcases}
+{{< /katex >}}
+
+- 确定遍历顺序
+
+<!-- prettier-ignore -->
+{{< katex display >}}
+	\int_{prices_i}\ 1<=i<len(prices)-1
+{{< /katex >}}
+
+- 举例推导 dp 数组，输入：`[7,1,5,3,6,4]`
+
+<!-- prettier-ignore -->
+{{< katex display>}}
+\begin{bmatrix}
+   i & dp[i][0] & dp[i][1] \\
+   0 & -7 & 0 \\
+   1 & -1 & 0 \\
+   2 & -1 & 4 \\
+   3 & -1 & 4 \\
+   4 & -1 & 5 \\
+   5 & -1 & \boxed{5} \\
+\end{bmatrix}
+{{< /katex >}}
+
+#### 复杂度分析
+
+- **时间复杂度:** {{< katex >}}\Omicron(N){{< /katex >}}
+- **空间复杂度:** {{< katex >}}\Omicron(N){{< /katex >}}
+
+{{< tabs "lc121-03" >}}
+{{< tab "Go" >}}
+
+```go
+func maxProfit_3(prices []int) int {
+	dp, n := make([][2]int, len(prices)), len(prices)
+	dp[0][0], dp[0][1] = -prices[0], 0
+	for i := 1; i < n; i++ {
+		dp[i][0] = max(dp[i-1][0], -prices[i])
+		dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i])
+	}
+	return dp[n-1][1]
+}
+```
+
+{{< /tab >}}
+{{< /tabs >}}
+
+## 总结
+
+...

…ent/zh/docs/leetcode/0000-0099/_index.md …ent/zh/docs/leetcode/0001-0100/_index.mdcontent/zh/docs/leetcode/0000-0099/_index.md renamed to content/zh/docs/leetcode/0001-0100/_index.md content/zh/docs/leetcode/0000-0099/_index.md renamed to content/zh/docs/leetcode/0001-0100/_index.md

@@ -0,0 +1,117 @@
+---
+weight: 33
+bookFlatSection: true
+title: "122.买卖股票的最佳时机 II"
+description: "122.买卖股票的最佳时机 II"
+---
+
+# 122.买卖股票的最佳时机 II
+
+## 题目描述
+
+{{< button href="https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/" >}}题目地址{{< /button >}}
+{{< button href="https://github.com/kylesliu/awesome-golang-algorithm/tree/master/leetcode/101-200/0122.Best-Time-To-Buy-And-Sell-Stock-II" >}}代码{{< /button >}}
+
+给定一个数组 prices ，其中`prices[i]`是一支给定股票第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
+
+{{< hint info >}}
+**提示**
+
+可以买卖多次
+{{< /hint >}}
+
+### **示例 1**
+
+```text
+输入: prices = [7,1,5,3,6,4]
+输出: 7
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+    随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 
+```
+
+### **示例 2**
+
+```text
+
+输入: prices = [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+    注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+```
+
+### **限制**
+
+- 1 <= prices.length <= 3 * 104
+- 0 <= prices[i] <= 104
+
+## 题解
+
+### 思路 1：**暴力循环**
+
+**算法流程：**
+
+2 次循环分别找出最大价格和最小价格
+
+**复杂度分析：**
+
+- **时间复杂度** `O(N^2))`
+- **空间复杂度** `O(1)`
+
+#### 代码
+
+{{< tabs "lc122-01" >}}
+{{< tab "Go" >}}
+
+```go
+package main
+func maxProfit_1(prices []int) int {
+	ans := 0
+	for i := 1; i < len(prices); i++ {
+		if prices[i] > prices[i-1] {
+			ans += prices[i] - prices[i-1]
+		}
+	}
+	return ans
+}
+```
+
+{{< /tab >}}
+
+{{< /tabs >}}
+
+
+### 思路 2：**动态规划**
+
+#### 算法流程
+
+基本动态规划操作...
+
+#### 复杂度分析
+
+- **时间复杂度** `O(N)`
+- **空间复杂度** `O(N)`
+
+{{< tabs "lc733-02" >}}
+{{< tab "Go" >}}
+
+```go
+func maxProfit_2(prices []int) int {
+	dp, n := make([][2]int, len(prices)), len(prices)
+	dp[0][0], dp[0][1] = -prices[0], 0
+	for i := 1; i < n; i++ {
+		dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i])
+		dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i])
+	}
+	return dp[n-1][1]
+}
+```
+
+{{< /tab >}}
+
+{{< /tabs >}}
+
+## 总结
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 算法 题解：[awesome-golang-algorithm](https://github.com/kylesliu/awesome-golang-algorithm)