feat: 20260219 check in

Author: NoyeArk

leetcode/3-动态规划（基础版）/3-动态规划在字符串的应用/712. 两个字符串的最小ASCII删除和.md

@@ -1,7 +1,8 @@
 # [712. 两个字符串的最小ASCII删除和](https://leetcode.cn/problems/minimum-ascii-delete-sum-for-two-strings/description/)
 
-> **日期:** 2025-05-21
+> **日期:** 2025-05-21、2026-02-15
 > **所用时间:** 6min
+> **知识点**: 动态规划
 
 ## 1. 动态规划
 
@@ -25,6 +26,8 @@ $$
     f[i][j] = min(f[i][j], f[i - 1][j - 1] + s1[i] + s2[j]);
 $$
 
+复杂度分析：
+
 - 时间复杂度：$O(nm)$
 - 空间复杂度：$O(nm)$
 

leetcode/3-动态规划（基础版）/3-动态规划在字符串的应用/72. 编辑距离.md

@@ -1,7 +1,8 @@
 # [72. 编辑距离](https://leetcode.cn/problems/edit-distance/description/)
 
-> **日期:** 2024-08-02
+> **日期:** 2024-08-02、2026-02-15
 > **所用时间:** 8min
+> **知识点**: 动态规划
 
 ## 1. 动态规划
 
@@ -23,6 +24,8 @@ $$
 	f[i][j] = (f[i][j - 1], f[i - 1][j], f[i - 1][j - 1]) + 1
 $$
 
+复杂度分析：
+
 - 时间复杂度: $O(nm)$
 - 空间复杂度: $O(nm)$
 

leetcode/3-动态规划（基础版）/5-最长公共子序列/1035. 不相交的线.md

@@ -1,7 +1,8 @@
 # [1035. 不相交的线](https://leetcode.cn/problems/uncrossed-lines/description/)
 
-> **日期:** 2024-08-05
+> **日期:** 2024-08-05、2026-02-15
 > **所用时间:** 10min
+> **知识点**: 动态规划
 
 ## 1. 动态规划
 

leetcode/4-每日一题/190. 颠倒二进制位.md

@@ -0,0 +1,49 @@
+# [190. 颠倒二进制位](https://leetcode.cn/problems/reverse-bits/description/)
+
+> **日期**：2026-02-17
+> **所用时间**：10min
+> **知识点**：位运算
+
+## 1. 题目描述
+
+颠倒给定的 32 位无符号整数的二进制位。
+
+**提示：**
+
+- 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
+- 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。
+
+**示例 1：**
+
+```
+输入：n = 00000010100101000001111010011100
+输出：964176192 (00111001011110000010100101000000)
+解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
+     因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
+```
+
+**示例 2：**
+
+```
+输入：n = 11111111111111111111111111111101
+输出：3221225471 (10111111111111111111111111111111)
+解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
+     因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111。
+```
+
+**提示：** 输入是一个长度为 32 的二进制字符串。
+
+## 2. 位运算
+
+从低位到高位遍历 n 的 32 位，每次取出第 i 位 `(n >> i) & 1`，将其放到结果的第 `31 - i` 位，即乘以 `2^(31-i)`，累加得到最终结果。
+
+- 时间复杂度: $O(1)$（固定 32 次循环）
+- 空间复杂度: $O(1)$
+
+**Python3**
+
+```python
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        return sum(((n >> i) & 1) * (2 ** (31-i)) for i in range(32))
+```

leetcode/4-每日一题/693. 交替位二进制数.md

@@ -0,0 +1,55 @@
+# [693. 交替位二进制数](https://leetcode.cn/problems/binary-number-with-alternating-bits/description/)
+
+> **日期**：2026-02-18  
+> **所用时间**：11min  
+> **知识点**：位运算 / 模拟
+
+## 1. 题目描述
+
+给定一个正整数 `n`，请你检查它的二进制表示是否满足：所有**相邻**的两个数字都不同。即二进制表示中不存在连续相同的 0 或 1。
+
+**示例 1：**
+
+```
+输入：n = 5
+输出：true
+解释：5 的二进制表示是 "101"，相邻位 1-0、0-1 均不同，满足交替。
+```
+
+**示例 2：**
+
+```
+输入：n = 7
+输出：false
+解释：7 的二进制表示是 "111"，存在连续相同的 1，不满足交替。
+```
+
+**示例 3：**
+
+```
+输入：n = 11
+输出：false
+解释：11 的二进制表示是 "1011"，第二、三位均为 1，不满足交替。
+```
+
+**提示：**
+
+- `1 <= n <= 2^31 - 1`
+
+## 2. 字符串模拟
+
+将整数转为二进制字符串，用 `pairwise` 遍历相邻字符，若存在相邻两位相同则返回 `False`，否则返回 `True`。
+
+- 时间复杂度: $O(\log n)$（二进制位数）
+- 空间复杂度: $O(\log n)$（存储二进制字符串）
+
+**Python3**
+
+```python
+class Solution:
+    def hasAlternatingBits(self, n: int) -> bool:
+        for a, b in pairwise(str(bin(n))):
+            if a == b:
+                return False
+        return True
+```

leetcode/4-每日一题/696. 计数二进制子串.md

@@ -0,0 +1,57 @@
+# [696. 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings/description/)
+
+> **日期**：2026-02-19
+> **所用时间**：11min
+> **知识点**：分组计数 / 滑动窗口
+
+## 1. 题目描述
+
+给定一个二进制字符串 `s`，统计并返回具有相同数量的 `0` 和 `1` 的非空子字符串的数量，并且这些子字符串中的所有 `0` 和所有 `1` 都是连续的。
+
+重复出现的子串要统计它们出现的次数。
+
+**示例 1：**
+
+```
+输入：s = "00110011"
+输出：6
+解释：6 个子串满足具有相同数量的连续 1 和 0：
+- "0011"，"01"，"1100"，"10"，"0011" 和 "01"。
+注意，一些重复出现的子串（不同位置）要统计它们出现的次数。
+另外，"00110011" 不是有效的子串，因为所有的 0（和 1）没有组合在一起。
+```
+
+**示例 2：**
+
+```
+输入：s = "10101"
+输出：4
+解释：有 4 个子串："10"，"01"，"10"，"01"，具有相同数量的连续 1 和 0。
+```
+
+**提示：**
+
+- `1 <= s.length <= 10^5`
+- `s[i]` 为 `'0'` 或 `'1'`
+
+## 2. 分组计数
+
+将字符串按连续相同字符分组，例如 `"00110011"` 可分为 `[2, 2, 2, 2]`（2 个 0、2 个 1、2 个 0、2 个 1）。相邻两组之间能形成的满足条件的子串数量为 `min(pre, cur)`。使用 `pairwise` 遍历相邻字符，`pre` 记录上一段长度，`cur` 记录当前段长度，遇到字符变化时累加 `min(pre, cur)` 并更新 `pre, cur`。
+
+- 时间复杂度: $O(n)$
+- 空间复杂度: $O(1)$
+
+**Python3**
+
+```python
+class Solution:
+    def countBinarySubstrings(self, s: str) -> int:
+        ans, pre, cur = 0, 0, 1
+        for a, b in pairwise(s):
+            if a == b:
+                cur += 1
+            else:
+                ans += min(pre, cur)
+                pre, cur = cur, 1
+        return ans + min(pre, cur)
+```