feat: 20260302 check in

Author: NoyeArk

leetcode/3-动态规划（基础版）/6-买卖股票的最佳时间/309. 买卖股票的最佳时机含冷冻期.md

@@ -1,21 +1,61 @@
 # 309. 买卖股票的最佳时机含冷冻期
 
-> **作者:** 弘树
-> **版本:** 0.1
-> **日期:** 2024-08-06
-> **版权:** Copyright (c) 2024
-> **所用时间:** 53min
+> **日期**：2024-02-06  
+> **所用时间**：53min  
+> **知识点**：动态规划、状态机
 
-## 解题思路
-### 1.递归动态规划
+## 1. 题目描述
 
-每一个股票可以有2种选择：买或不买，如果买，那么后面2个位置的操作都唯一。如果不买，那么下一个操作仍然有2个选择。
+给定一个整数数组 `prices`，其中 `prices[i]` 表示第 `i` 天的股票价格。设计算法计算**最大利润**。
+
+**约束条件：**
+
+- 不能同时参与多笔交易：再次买入前必须先卖出之前的股票。
+- **冷冻期**：卖出股票后，**第二天不能买入**（即至少休息一天才能再买）。
+
+**示例：**
+
+- **输入**：prices = [1,2,3,0,2]
+- **输出**：3
+- **解释**：对应交易序列为：第 1 天买入、第 2 天卖出、第 3 天冷冻、第 4 天买入、第 5 天卖出。利润 (2-1) + (2-0) = 3。
+
+**约束：**
+
+- $1 \le \text{prices.length} \le 5000$
+- $0 \le \text{prices}[i] \le 1000$
+
+---
+
+## 2. 动态规划
+
+**思路：**
+
+用**三态**区分「不持股」的两种来源，避免冷冻期后立刻买入：
+
+- **$f[i][0]$**：第 $i$ 天结束时**不持股**，且**不是因为当天卖出**而不持股（即昨天就不持股或昨天是冷冻期），此时的最大现金。
+- **$f[i][1]$**：第 $i$ 天结束时**持股**，此时的最大现金。
+- **$f[i][2]$**：第 $i$ 天结束时**不持股**，且**是因为当天卖出**而不持股（即进入冷冻期），此时的最大现金。
+
+**转移：**
+
+- $f[i][0] = \max(f[i-1][0], f[i-1][2])$：昨天不持股（状态 0）或昨天刚卖（状态 2），今天不买。
+- $f[i][1] = \max(f[i-1][1], f[i-1][0] - \text{prices}[i-1])$：昨天就持股，或昨天是状态 0（可买）今天买入。注意不能从状态 2 直接买（冷冻期）。
+- $f[i][2] = f[i-1][1] + \text{prices}[i-1]$：昨天持股，今天卖出。
+
+**边界：** 第 1 天（下标 1）：$f[1][0]=f[1][2]=0$，$f[1][1]=-\text{prices}[0]$。
+
+**答案：** $\max_i \max(f[i][0], f[i][2])$（最后不持股的最大利润）。
+
+**复杂度分析：**
+
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(n)$（可压成 $O(1)$，只存前一天三个状态）
+
+**递归 DP（思路：买/不买，买则后续两天唯一；易 TLE）**
 
 - 时间复杂度：$O(3^n)$
 - 空间复杂度：$O(n)$
 
-通过208/210个样例，剩下2个TLE。
-
 ```C++
 class Solution {
 public:
@@ -45,26 +85,7 @@ public:
 };
 ```
 
-### 2.迭代动态规划
-
-怎么将递归形式的DP转化为迭代形式的DP，对于每个状态，应该维护2个属性：
-
-1. 当前的利润和
-2. 当前所购买的股票
-
-状态表示：$f[i][j]$表示在第$i$个时刻，购买股票价格为$j$，卖出股票时的最大利润
-
-不对，感觉很乱，不知道怎么继续状态计算...，感觉状态表示肯定不对啊，不会/(ㄒoㄒ)/~~
-
----
-
-上述的状态表示就错了，感觉好难，第一次做真的好难想到以下这种状态表示：
-
-$f[i][0]$: 手上不持有股票，并且今天不是由于卖出股票而不持股，我们拥有的现金数
-
-$f[i][1]$: 手上持有股票时，我们拥有的现金数
-
-$f[i][2]$: 手上不持有股票，并且今天是由于卖出股票而不持股，我们拥有的现金数
+**迭代 DP（三态状态机，推荐）**
 
 ```C++
 class Solution {

leetcode/3-动态规划（基础版）/6-买卖股票的最佳时间/714. 买卖股票的最佳时机含手续费.md

@@ -1,44 +1,91 @@
 # 714. 买卖股票的最佳时机含手续费
 
-> **作者:** 弘树
-> **日期:** 2024-09-14
+> **日期**：2024-09-14  
+> **所用时间**：15min  
+> **知识点**：动态规划、状态机
 
-## 解题思路
-### 1.动态规划
+## 1. 题目描述
 
-状态表示：
+给定一个整数数组 `prices`，其中 `prices[i]` 表示第 `i` 天的股票价格，以及一个非负整数 `fee` 表示**每笔交易的手续费**。可以**无限次**完成交易，求最大利润。
 
-1. $f[i][0]$表示在第$i$天进行完操作不持有股票的最大利润
-2. $f[i][1]$表示在第$i$天进行完操作持有股票的最大利润
+**约束条件：**
 
-状态计算：
+- 不能同时参与多笔交易：再次买入前必须先卖出之前的股票。
+- **每笔交易**（一次买入 + 一次卖出）需要支付一次手续费 `fee`。手续费可在**买入时**或**卖出时**扣除，两种约定等价（只需统一即可）。
+
+**示例 1：**
+
+- **输入**：prices = [1, 3, 2, 8, 4, 9], fee = 2
+- **输出**：8
+- **解释**：第 1 天买入（价格 1），第 4 天卖出（价格 8），利润 8-1-2=5；第 5 天买入（价格 4），第 6 天卖出（价格 9），利润 9-4-2=3。总利润 5+3=8。
+
+**示例 2：**
+
+- **输入**：prices = [1,3,7,5,10,3], fee = 3
+- **输出**：6
 
-1. 若第$i$不持有股票，则有2种可能：
+**约束：**
 
-    - 第$i - 1$就没有股票，则$f[i][0] = f[i - 1][0]$
-    - 第$i - 1$持有股票，在第$i$天出售，则$f[i][0] = f[i - 1][1] + prices[i] - fee$
-  
-对于$f[i][0]$的状态转移方程如下：
+- $1 \le \text{prices.length} \le 5 \times 10^4$
+- $1 \le \text{prices}[i] < 5 \times 10^4$
+- $0 \le \text{fee} < 5 \times 10^4$
 
-$$
-    f[i][0] = max(f[i - 1][0], f[i - 1][1] + prices[i] - fee)
-$$
+---
 
-2. 若第$i$持有股票，则有2种可能：
+## 2. 动态规划
 
-    - 第$i - 1$就持有股票，则$f[i][1] = f[i - 1][1]$
-    - 第$i - 1$持不持有股票，在第$i$天购买，则$f[i][1] = f[i - 1][0] - prices[i]$
+**思路：**
 
-对于$f[i][1]$的状态转移方程如下：
+与「122. 买卖股票的最佳时机 II」类似，无限次交易；区别在于每笔交易要扣手续费。用两态即可：
 
-$$
-    f[i][1] = max(f[i - 1][1], f[i - 1][0] - prices[i])
-$$
+- **$f[i][0]$**：第 $i$ 天结束时**不持股**的最大利润。
+- **$f[i][1]$**：第 $i$ 天结束时**持股**的最大利润。
 
-最后答案为$\max(f[i][0], f[i][1])$。
+**转移：**
+
+- 不持股：昨天就不持股，或昨天持股、今天卖出（若在卖出时扣费，则 $f[i][0] = \max(f[i-1][0], f[i-1][1] + \text{prices}[i-1] - \text{fee})$）。
+- 持股：昨天就持股，或昨天不持股、今天买入（若在买入时扣费，则 $f[i][1] = \max(f[i-1][1], f[i-1][0] - \text{prices}[i-1] - \text{fee})$）。
+
+两种扣费方式任选一种统一即可。答案取 $\max(f[n][0], f[n][1])$，实际为 $f[n][0]$（最后不持股更优）。
+
+**复杂度分析：**
 
 - 时间复杂度：$O(n)$
-- 空间复杂度：$O(n)$
+- 空间复杂度：$O(n)$（DP 数组）；可滚动为两个变量，空间 $O(1)$
+
+**记忆化搜索（Python）**
+
+```python
+class Solution:
+    def maxProfit(self, prices: List[int], fee: int) -> int:
+        @cache
+        def dfs(i, hold):
+            if i < 0:
+                return -inf if hold else 0
+            if hold:
+                return max(dfs(i - 1, hold), dfs(i - 1, False) - prices[i] - fee)
+            return max(dfs(i - 1, hold), dfs(i - 1, True) + prices[i])
+        return dfs(len(prices) - 1, False)
+```
+
+**动态规划（C++）**
+
+状态表示：
+
+1. $f[i][0]$：第 $i$ 天进行完操作不持有股票的最大利润  
+2. $f[i][1]$：第 $i$ 天进行完操作持有股票的最大利润  
+
+状态计算：
+
+- $f[i][0] = \max(f[i-1][0], f[i-1][1] + \text{prices}[i-1] - \text{fee})$
+- $f[i][1] = \max(f[i-1][1], f[i-1][0] - \text{prices}[i-1])$
+
+答案为 $\max(f[n][0], f[n][1])$。
+
+- 时间复杂度：$O(n)$  
+- 空间复杂度：$O(n)$  
+
+**C++**
 
 ```C++
 class Solution {
@@ -58,12 +105,14 @@ public:
 };
 ```
 
-### 2.滚动数组空间优化
+**滚动数组空间优化（C++）**
 
-可以看到第$i$天的状态只依赖于第$i - 1$天，所以可以使用滚动数组的思想。
+第 $i$ 天只依赖第 $i-1$ 天，可用两个变量滚动。
 
-- 时间复杂度：$O(n)$
-- 空间复杂度：$O(1)$
+- 时间复杂度：$O(n)$  
+- 空间复杂度：$O(1)$  
+
+**C++**
 
 ```C++
 class Solution {

leetcode/4-每日一题/1536. 排布二进制网格的最少交换次数.md

@@ -0,0 +1,47 @@
+# [1536. 排布二进制网格的最少交换次数](https://leetcode.cn/problems/minimum-swaps-to-arrange-a-binary-grid/description/)
+
+> **日期**：2026-03-02  
+> **所用时间**：2min  
+> **知识点**：贪心、模拟
+
+## 1. 贪心
+
+**思路：**
+
+从上到下逐行确定。对第 $i$ 行，需要满足：该行从第 $i+1$ 列到最后一列全为 0，即 `sum(grid[i][i+1:]) == 0`。
+
+- 若当前第 $i$ 行已满足，则继续下一行。
+- 若不满足，则从第 $i+1$ 行起向下找**第一个**满足「从第 $i+1$ 列起全为 0」的行（即该行可以合法放在第 $i$ 行位置）。把该行通过**相邻行交换**逐格「冒泡」到第 $i$ 行，交换次数为该行当前下标与 $i$ 的差值；同时把原来的第 $i$ 行到该行前一行整体下移一格。
+- 若找不到这样的行，说明无法使网格有效，返回 $-1$。
+
+实现时，用「把找到的那一行整行提到第 $i$ 行、其余行顺次下移」等价模拟多次相邻交换，并累加交换次数（每次相邻交换计 1，共 `t - i` 次）。
+
+**复杂度分析：**
+
+- 时间复杂度：$O(n^2)$（外层 $n$ 行，内层最坏 $O(n)$ 找行且每次 `sum(grid[j][i+1:])` 为 $O(n)$）
+- 空间复杂度：$O(1)$（仅用若干变量，若不计输入）
+
+**Python3**
+
+```python
+class Solution:
+    def minSwaps(self, grid: List[List[int]]) -> int:
+        ans = 0
+        n = len(grid)
+
+        for i in range(n):
+            if sum(grid[i][i + 1:]) == 0:
+                continue
+            t = -1
+            for j in range(i + 1, n):
+                if sum(grid[j][i + 1:]) == 0:
+                    t = j
+                    break
+            if t == -1:
+                return -1
+            arr = grid[t][:]
+            grid[i + 1: t + 1] = grid[i:t]
+            grid[i] = arr
+            ans += t - i
+        return ans
+```