feat: 20260228 check in

Made-with: Cursor

Author: NoyeArk

leetcode/3-动态规划（基础版）/6-买卖股票的最佳时间/123. 买卖股票的最佳时机 III.md

@@ -1,95 +1,65 @@
-# [123. 买卖股票的最佳时机 III](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/description/?envType=study-plan-v2&envId=dynamic-programming)
+# [123. 买卖股票的最佳时机 III](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/description)
 
-> **作者**：弘树
-> **日期**：2024-09-21
-> **所用时间**：13min
+> **日期**：2024-09-21、2025-02-06  
+> **所用时间**：13min  
+> **知识点**：动态规划、记忆化搜索
 
-## 1. 动态规划
+## 1. 题目描述
 
-状态表示：
+给定一个整数数组 `prices`，其中 `prices[i]` 表示第 `i` 天的股票价格。要求计算能够获得的最大利润。
 
-1. $f[i][0]$表示在第$i$天进行完操作不持有股票同时购买股票次数为0的最大利润
-2. $f[i][1]$表示在第$i$天进行完操作不持有股票同时购买股票次数为1的最大利润
-3. $f[i][2]$表示在第$i$天进行完操作不持有股票同时购买股票次数为2的最大利润
-4. $f[i][3]$表示在第$i$天进行完操作持有股票同时购买股票次数为0的最大利润
-5. $f[i][4]$表示在第$i$天进行完操作持有股票同时购买股票次数为1的最大利润
+**限制条件：**
 
-状态计算：
+- 最多可以完成 **两笔** 交易（一笔交易指一次买入 + 一次卖出）。
+- 不能同时参与多笔交易：再次买入前必须先卖出当前持有的股票。
 
-1. 若第$i$不持有股票，则有2种可能：
+**示例 1：**
 
-    - 第$i - 1$就没有股票，则
+- **输入**：prices = [3,3,5,0,0,3,1,4]
+- **输出**：6
+- **解释**：第 4 天买入（价格 0），第 6 天卖出（价格 3），利润 3；第 7 天买入（价格 1），第 8 天卖出（价格 4），利润 3。总利润 3 + 3 = 6。
 
-    $$f[i][0] = f[i - 1][0]$$
+**示例 2：**
 
-    $$f[i][1] = f[i - 1][1]$$
-    
-    $$f[i][2] = f[i - 1][2]$$
+- **输入**：prices = [1,2,3,4,5]
+- **输出**：4
+- **解释**：第 1 天买入（价格 1），第 5 天卖出（价格 5），利润 4。只需一笔交易即可达到最大利润。
 
-    - 第$i - 1$持有股票，在第$i$天出售，则
-  
-    $$f[i][0] = f[i - 1][2] + prices[i]$$
+**示例 3：**
 
-    $$f[i][1] = f[i - 1][3] + prices[i]$$
+- **输入**：prices = [7,6,4,3,1]
+- **输出**：0
+- **解释**：价格单调不升，无法通过交易获利，最大利润为 0。
 
-对于$f[i][0]$的状态转移方程如下：
+**约束：**
 
-$$
-    f[i][j] = max(f[i - 1][j], f[i - 1][j + 3] + prices[i]), j \in [0, 1]
-$$
+- $1 \le \text{prices.length} \le 10^5$
+- $0 \le \text{prices}[i] \le 10^5$
 
-$$
-    f[i][2] = f[i - 1][2]
-$$
+---
 
-2. 若第$i$持有股票，则有2种可能：
+## 2. 「动态规划 / 记忆化搜索」
 
-    - 第$i - 1$就持有股票，则
+下面代码用**记忆化搜索**实现：`dfs(i, j, hold)` 表示考虑前 `i+1` 天、剩余可完成 `j` 笔交易、当前是否持有股票时的最大利润，答案为 `dfs(n-1, 2, False)`。
 
-    $$f[i][3] = f[i - 1][3]$$
+**复杂度分析：**
 
-    $$f[i][4] = f[i - 1][4]$$
+- 时间复杂度：$O(n)$（状态数 $O(n \times 2 \times 2)$，每状态 $O(1)$ 转移）
+- 空间复杂度：$O(n)$（递归栈与 cache，若用二维 DP 数组则为 $O(5n)$）
 
-    - 第$i - 1$不持有股票，在第$i$天购买，则
+**Python3**
 
-    $$f[i][3] = f[i - 1][1] - prices[i]$$
-    
-    $$f[i][4] = f[i - 1][2] - prices[i]$$
-
-对于$f[i][1]$的状态转移方程如下：
-
-$$
-    f[i][j] = max(f[i - 1][j], f[i - 1][j - 2] - prices[i]), j \in [3, 4]
-$$
-
-最后答案为$\max(f[n][j]), j\in [0, 4]$。
-
-- 时间复杂度：$O(n)$
-- 空间复杂度：$O(5n)$
-
-```C++
-class Solution {
-public:
-    long long f[100010][5];
-
-    int maxProfit(vector<int>& prices) {
-        f[1][4] = -prices[0];
-        f[1][0] = f[1][1] = f[1][3] = INT_MIN;
-        for (int i = 2; i <= prices.size(); i ++)
-        {
-            f[i][0] = max(f[i - 1][0], f[i - 1][3] + prices[i - 1]);
-            f[i][1] = max(f[i - 1][1], f[i - 1][4] + prices[i - 1]);
-            f[i][2] = f[i - 1][2];
-            f[i][3] = max(f[i - 1][3], f[i - 1][1] - prices[i - 1]);
-            f[i][4] = max(f[i - 1][4], f[i - 1][2] - prices[i - 1]);
-        }
-        long long ans = 0;
-        for (int i = 0; i < 5; i ++) ans = max(ans, f[prices.size()][i]);
-        return ans;
-    }
-};
-```
-
-## 2. 滚动数组空间优化
-
-可以发现第$i$个时刻的状态总依赖于第$i - 1$时刻的状态，所以可以使用5个常量保存上一个时刻的状态，这里不再演示
+```python
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        @cache
+        def dfs(i, j, hold):
+            if j == 0:
+                return 0
+            if i < 0:
+                return -inf if hold else 0
+            if hold:
+                return max(dfs(i - 1, j, True), dfs(i - 1, j - 1, False) - prices[i])
+            return max(dfs(i - 1, j, False), dfs(i - 1, j, True) + prices[i])
+        return dfs(len(prices) - 1, 2, False)
+```

leetcode/3-动态规划（基础版）/6-买卖股票的最佳时间/188. 买卖股票的最佳时机 IV.md

@@ -1,127 +1,69 @@
-# [188. 买卖股票的最佳时机 IV](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description/?envType=study-plan-v2&envId=dynamic-programming)
+# [188. 买卖股票的最佳时机 IV](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description)
 
-> **作者**：弘树
-> **日期**：2024-09-22
-> **所用时间**：11min
+> **日期**：2024-09-22、2026-02-28  
+> **所用时间**：11min  
+> **知识点**：动态规划、记忆化搜索
 
-## 1. 动态规划
+## 1. 题目描述
 
-### 1.1 状态表示
+给定一个整数 `k` 和一个整数数组 `prices`，其中 `prices[i]` 表示第 `i` 天的股票价格。要求计算能够获得的最大利润。
 
-可以分为2种情况，分别为$f[i][0]$和$f[i][1]$
+**限制条件：**
 
-对于$f[i][0]$来说：
+- 最多可以完成 **k 笔** 交易（一笔交易指一次买入 + 一次卖出）。
+- 不能同时参与多笔交易：再次买入前必须先卖出当前持有的股票。
 
-1. $f[i][0][0]$表示在第$i$天进行完操作不持有股票同时购买股票次数为0的最大利润
-2. $f[i][0][1]$表示在第$i$天进行完操作不持有股票同时购买股票次数为1的最大利润
-3. ......
-4. $f[i][0][k]$表示在第$i$天进行完操作不持有股票同时购买股票次数为k的最大利润
+**示例 1：**
 
-对于$f[i][1]$来说：
+- **输入**：k = 2, prices = [2,4,1]
+- **输出**：2
+- **解释**：第 1 天买入（价格 2），第 2 天卖出（价格 4），利润 2。
 
-1. $f[i][1][0]$表示在第$i$天进行完操作不持有股票同时购买股票次数为0的最大利润
-2. $f[i][1][1]$表示在第$i$天进行完操作不持有股票同时购买股票次数为1的最大利润
-3. ......
-4. $f[i][1][k - 1]$表示在第$i$天进行完操作持有股票同时购买股票次数为$k - 1$的最大利润
+**示例 2：**
 
-### 1.2 状态计算
+- **输入**：k = 2, prices = [3,2,6,5,0,3]
+- **输出**：7
+- **解释**：第 2 天买入（价格 2），第 3 天卖出（价格 6），利润 4；第 5 天买入（价格 0），第 6 天卖出（价格 3），利润 3。总利润 4 + 3 = 7。
 
-#### 1.2.1 $f[i][0]$状态计算
+**约束：**
 
-若第$i$不持有股票，则有2种可能：
+- $1 \le k \le 100$
+- $1 \le \text{prices.length} \le 1000$
+- $0 \le \text{prices}[i] \le 1000$
 
- - 第$i - 1$就没有股票，则
+---
 
-    $$f[i][0][0] = f[i - 1][0][0]$$
+## 2. 「动态规划 / 记忆化搜索」
 
-    $$f[i][0][1] = f[i - 1][0][1]$$
+**思路：**
 
-    $$……$$
-    
-    $$f[i][0][k] = f[i - 1][0][k]$$
+与「123. 买卖股票的最佳时机 III」相同，将**最多 2 笔**推广为**最多 k 笔**。用**记忆化搜索**：`dfs(i, j, hold)` 表示考虑前 `i+1` 天、**剩余**可完成 `j` 笔交易、当前是否持有股票时的最大利润。
 
-  - 第$i - 1$持有股票，在第$i$天出售，则
-  
-    $$f[i][0][0] = f[i - 1][1][0] + prices[i]$$
+- 若 `j == 0`：不能再交易，返回 0。
+- 若 `i < 0`：没有天数，持有则非法返回 $-\infty$，否则返回 0。
+- 若当前持有：今天可**不卖**（`dfs(i-1, j, True)`）或**卖出**（`dfs(i-1, j-1, False) + prices[i]`，用掉 1 笔交易）。
+- 若当前不持有：今天可**不买**（`dfs(i-1, j, False)`）或**买入**（`dfs(i-1, j, True) - prices[i]`）。
 
-    $$f[i][0][1] = f[i - 1][1][1] + prices[i]$$
+答案为 `dfs(len(prices)-1, k, False)`，即从最后一天、剩余 k 笔、不持有出发的最大利润。
 
-    $$……$$
+**复杂度分析：**
 
-    $$f[i][0][k - 1] = f[i - 1][1][k - 1] + prices[i]$$
+- 时间复杂度：$O(n \cdot k)$（状态 $(i, j, \text{hold})$ 共 $O(n \cdot k \cdot 2)$，每状态 $O(1)$ 转移）
+- 空间复杂度：$O(n \cdot k)$（递归栈与 cache）
 
+**Python3**
 
-综上，当$j \in [0, k - 1]$时，$f[i][0][j]$的状态转移方程为：
-
-$$
-    f[i][0][j] = max(f[i - 1][0][j], f[i - 1][1][j] + prices[i])
-$$
-
-当$j = k$时，$f[i][0][j]$的状态转移方程为：
-
-$$
-    f[i][0][k] = f[i - 1][0][k]
-$$
-
-#### 1.2.2 $f[i][1]$状态计算
-
-若第$i$持有股票，则有2种可能：
-
-  - 第$i - 1$就持有股票，则
-
-    $$f[i][1][0] = f[i - 1][1][0]$$
-
-    $$f[i][1][1] = f[i - 1][1][1]$$
-
-    $$……$$
-
-    $$f[i][1][k - 1] = f[i - 1][1][k - 1]$$
-
-  - 第$i - 1$不持有股票，在第$i$天购买，则
-
-    $$f[i][1][0] = f[i - 1][0][1] - prices[i]$$
-    
-    $$f[i][1][1] = f[i - 1][0][2] - prices[i]$$
-
-    $$……$$
-
-    $$f[i][1][k - 1] = f[i - 1][0][k] - prices[i]$$
-
-对于$f[i][1]$的状态转移方程如下：
-
-$$
-    f[i][1][j] = max(f[i - 1][1][j], f[i - 1][0][j + 1] - prices[i]), j \in [0, k - 1]
-$$
-
-最后答案为$\max(f[n][j]), j\in [0, k]$。
-
-- 时间复杂度：$O(nk)$
-- 空间复杂度：$O(2nk)$
-
-```C++
-class Solution {
-public:
-    long long f[1010][2][110];
-
-    int maxProfit(int k, vector<int>& prices) {
-        for (int i = 0; i < k; i ++) f[1][0][i] = INT_MIN;
-        for (int i = 0; i < k - 1; i ++) f[1][1][i] = INT_MIN;
-        f[1][0][k] = 0, f[1][1][k - 1] = -prices[0];
-        for (int i = 2; i <= prices.size(); i ++)
-        {
-            for (int j = 0; j < k; j ++) 
-                f[i][0][j] = max(f[i - 1][0][j], f[i - 1][1][j] + prices[i - 1]);
-            f[i][0][k] = f[i - 1][0][k];
-            for (int j = 0; j < k; j ++)
-                f[i][1][j] = max(f[i - 1][1][j], f[i - 1][0][j + 1] - prices[i - 1]);
-        }
-        long long ans = 0;
-        for (int i = 0; i <= k; i ++) ans = max(ans, f[prices.size()][0][i]);
-        return ans;
-    }
-};
-```
-
-## 2. 滚动数组空间优化
-
-可以发现第$i$个时刻的状态总依赖于第$i - 1$时刻的状态，所以可以使用$2k$个常量保存上一个时刻的状态，这里不再演示
+```python
+class Solution:
+    def maxProfit(self, k: int, prices: List[int]) -> int:
+        @cache
+        def dfs(i, j, hold):
+            if j == 0:
+                return 0
+            if i < 0:
+                return -inf if hold else 0
+            if hold:
+                return max(dfs(i - 1, j, hold), dfs(i - 1, j - 1, False) - prices[i])
+            return max(dfs(i - 1, j, hold), dfs(i - 1, j, True) + prices[i])
+        return dfs(len(prices) - 1, k, False)
+```

leetcode/4-每日一题/1680. 连接连续二进制数字.md

@@ -0,0 +1,67 @@
+# [1680. 连接连续二进制数字](https://leetcode.cn/problems/concatenation-of-consecutive-binary-numbers/description/)
+
+> **日期**：2025-02-06  
+> **所用时间**：10min  
+> **知识点**：位运算、模拟、数学
+
+## 1. 题目描述
+
+给定一个整数 `n`，将 `1` 到 `n` 的二进制表示**按顺序连接**成一个二进制字符串，返回该二进制串对应的**十进制值**并对 $10^9 + 7$ **取模**的结果。
+
+**示例 1：**
+
+- **输入**：n = 1  
+- **输出**：1  
+- **解释**：只有数字 1，二进制为 `"1"`，十进制值为 1。
+
+**示例 2：**
+
+- **输入**：n = 3  
+- **输出**：27  
+- **解释**：1、2、3 的二进制分别为 `"1"`、`"10"`、`"11"`，连接后为 `"11011"`，对应十进制 $1 \times 2^4 + 1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 1 \times 2^0 = 27$。
+
+**示例 3：**
+
+- **输入**：n = 12  
+- **输出**：505379714  
+- **解释**：连接得到的二进制串很长，其十进制值对 $10^9 + 7$ 取模后为 505379714。
+
+**约束：**
+
+- $1 \le n \le 10^5$
+
+---
+
+## 2. 「位运算 / 模拟」
+
+**思路：**
+
+- **方法一（模拟拼接）**：从 1 到 n 遍历，把每个数的二进制去掉前导 `"0b"` 后拼成一个字符串，最后用 `int(s, 2)` 转成十进制再对 $10^9+7$ 取模。实现简单，但字符串会很长，时间和空间都偏大。
+- **方法二（位运算）**：不显式构造字符串。维护当前结果 `ans`，对每个 $i$，把 `ans` 左移 `i.bit_length()` 位（为 $i$ 的二进制腾出位置），再与 $i$ 做按位或，即 `ans = (ans << i.bit_length() | i) % mod`。这样每次都是在“二进制串末尾”接上 $i$ 的二进制表示，等价于题目要求的连接，且无需字符串，空间 $O(1)$。
+
+**复杂度分析：**
+
+- 时间复杂度：$O(n)$（遍历 1 到 n，每次位运算与取模为 $O(1)$）
+- 空间复杂度：方法一 $O(n \log n)$（字符串长度），方法二 $O(1)$
+
+**Python3**
+
+```python
+class Solution:
+    def concatenatedBinary(self, n: int) -> int:
+        s = ""
+        for i in range(1, n + 1):
+            s += bin(i)[2:]
+        return int(s, 2) % int(1e9 + 7)
+```
+
+**Python3**
+
+```python
+class Solution:
+    def concatenatedBinary(self, n: int) -> int:
+        ans = 0
+        for i in range(1, n + 1):
+            ans = (ans << i.bit_length() | i) % int(1e9 + 7)
+        return ans
+```