add 3136 3163

Author: 2xiao

src/.vuepress/sidebar.ts

@@ -620,6 +620,14 @@ export default sidebar({
       "2938"
     ]
   },
+  {
+    "text": "3100-3199",
+    "collapsible": true,
+    "children": [
+      "3136",
+      "3163"
+    ]
+  },
   {
     "text": "3300-3399",
     "collapsible": true,

src/offer2/jz_offer_II_083.md

@@ -49,7 +49,11 @@
 #### 复杂度分析
 
 - **时间复杂度**：`O(n * n!)`，其中 `n` 是 `nums` 的长度。主要由递归调用栈的深度决定，递归深度（即排列的数量 `n!`）乘以每次操作的时间复杂度 `O(n)`，总时间复杂度为 `O(n * n!)`。
-- **空间复杂度**：`O(n)`（不包含结果数组使用的空间）递归调用栈的深度为 `n`，`used` 数组的大小为 `n`。
+- **空间复杂度**：`O(n * n!)`，空间复杂度主要由以下几个部分组成：
+  - 结果数组`res` 用于存储所有生成的唯一排列，在最坏情况下（所有元素都不相同），生成的排列数为 `n!`，因此结果数组的空间复杂度为 `O(n * n!)`；
+  - 临时数组 `track`，在每个递归调用中，`track` 的最大长度为 `n`，因此其空间复杂度为 `O(n)`；
+  - 布尔数组 `used` 用于标记哪些元素已经被使用，大小为 `n`，因此占用 `O(n)` 的空间。
+  - 综合考虑，最主要的空间复杂度来源于结果数组 `res`，因此整体空间复杂度为 `O(n * n!)`。
 
 ## 代码
 

src/offer2/jz_offer_II_084.md

@@ -55,7 +55,11 @@
   - 在回溯过程中，每次递归都要遍历 `n` 个元素，递归树的每一层都要做选择；
   - 对于每一层的递归，最多需要处理 `n!` 种情况；
   - 因此总的时间复杂度是 `O(n * n!)`。
-- **空间复杂度**：`O(n)`（不包含结果数组使用的空间）递归调用栈的深度为 `n`，`used` 数组的大小为 `n`。
+- **空间复杂度**：`O(n * n!)`，空间复杂度主要由以下几个部分组成：
+  - 结果数组`res` 用于存储所有生成的唯一排列，在最坏情况下（所有元素都不相同），生成的排列数为 `n!`，因此结果数组的空间复杂度为 `O(n * n!)`；
+  - 临时数组 `track`，在每个递归调用中，`track` 的最大长度为 `n`，因此其空间复杂度为 `O(n)`；
+  - 布尔数组 `used` 用于标记哪些元素已经被使用，大小为 `n`，因此占用 `O(n)` 的空间。
+  - 综合考虑，最主要的空间复杂度来源于结果数组 `res`，因此整体空间复杂度为 `O(n * n!)`。
 
 ## 代码
 

src/plan/contest_list.md

@@ -384,7 +384,7 @@ headerDepth: 0
 | 题号 | 标题 | 题解 | 标签 | 难度 |
 | :------: | :------ | :------: | :------ | :------ |
 | 3162 | [优质数对的总数 I](https://leetcode.com/problems/find-the-number-of-good-pairs-i) |  |  [`数组`](/tag/array.md) [`哈希表`](/tag/hash-table.md) | <font color=#15bd66>Easy</font> |
-| 3163 | [压缩字符串 III](https://leetcode.com/problems/string-compression-iii) |  |  [`字符串`](/tag/string.md) | <font color=#ffb800>Medium</font> |
+| 3163 | [压缩字符串 III](https://leetcode.com/problems/string-compression-iii) | [[✓]](/problem/3163.md) |  [`字符串`](/tag/string.md) | <font color=#ffb800>Medium</font> |
 | 3164 | [优质数对的总数 II](https://leetcode.com/problems/find-the-number-of-good-pairs-ii) |  |  [`数组`](/tag/array.md) [`哈希表`](/tag/hash-table.md) | <font color=#ffb800>Medium</font> |
 | 3165 | [不包含相邻元素的子序列的最大和](https://leetcode.com/problems/maximum-sum-of-subsequence-with-non-adjacent-elements) |  |  [`线段树`](/tag/segment-tree.md) [`数组`](/tag/array.md) [`分治`](/tag/divide-and-conquer.md) `1+` | <font color=#ff334b>Hard</font> |
 
@@ -443,7 +443,7 @@ headerDepth: 0
 <!-- prettier-ignore -->
 | 题号 | 标题 | 题解 | 标签 | 难度 |
 | :------: | :------ | :------: | :------ | :------ |
-| 3136 | [有效单词](https://leetcode.com/problems/valid-word) |  |  [`字符串`](/tag/string.md) | <font color=#15bd66>Easy</font> |
+| 3136 | [有效单词](https://leetcode.com/problems/valid-word) | [[✓]](/problem/3136.md) |  [`字符串`](/tag/string.md) | <font color=#15bd66>Easy</font> |
 | 3137 | [K 周期字符串需要的最少操作次数](https://leetcode.com/problems/minimum-number-of-operations-to-make-word-k-periodic) |  |  [`哈希表`](/tag/hash-table.md) [`字符串`](/tag/string.md) [`计数`](/tag/counting.md) | <font color=#ffb800>Medium</font> |
 | 3138 | [同位字符串连接的最小长度](https://leetcode.com/problems/minimum-length-of-anagram-concatenation) |  |  [`哈希表`](/tag/hash-table.md) [`字符串`](/tag/string.md) [`计数`](/tag/counting.md) | <font color=#ffb800>Medium</font> |
 | 3139 | [使数组中所有元素相等的最小开销](https://leetcode.com/problems/minimum-cost-to-equalize-array) |  |  [`贪心`](/tag/greedy.md) [`数组`](/tag/array.md) [`枚举`](/tag/enumeration.md) | <font color=#ff334b>Hard</font> |

src/problem/0046.md

@@ -50,7 +50,11 @@ permutations_. You can return the answer in **any order**.
 #### 复杂度分析
 
 - **时间复杂度**：`O(n * n!)`，其中 `n` 是 `nums` 的长度。主要由递归调用栈的深度决定，递归深度（即排列的数量 `n!`）乘以每次操作的时间复杂度 `O(n)`，总时间复杂度为 `O(n * n!)`。
-- **空间复杂度**：`O(n)`（不包含结果数组使用的空间）递归调用栈的深度为 `n`，`used` 数组的大小为 `n`。
+- **空间复杂度**：`O(n * n!)`，空间复杂度主要由以下几个部分组成：
+  - 结果数组`res` 用于存储所有生成的唯一排列，在最坏情况下（所有元素都不相同），生成的排列数为 `n!`，因此结果数组的空间复杂度为 `O(n * n!)`；
+  - 临时数组 `track`，在每个递归调用中，`track` 的最大长度为 `n`，因此其空间复杂度为 `O(n)`；
+  - 布尔数组 `used` 用于标记哪些元素已经被使用，大小为 `n`，因此占用 `O(n)` 的空间。
+  - 综合考虑，最主要的空间复杂度来源于结果数组 `res`，因此整体空间复杂度为 `O(n * n!)`。
 
 ## 代码
 

src/problem/0047.md

@@ -56,7 +56,11 @@ _all possible unique permutations **in any order**._
   - 在回溯过程中，每次递归都要遍历 `n` 个元素，递归树的每一层都要做选择；
   - 对于每一层的递归，最多需要处理 `n!` 种情况；
   - 因此总的时间复杂度是 `O(n * n!)`。
-- **空间复杂度**：`O(n)`（不包含结果数组使用的空间）递归调用栈的深度为 `n`，`used` 数组的大小为 `n`。
+- **空间复杂度**：`O(n * n!)`，空间复杂度主要由以下几个部分组成：
+  - 结果数组`res` 用于存储所有生成的唯一排列，在最坏情况下（所有元素都不相同），生成的排列数为 `n!`，因此结果数组的空间复杂度为 `O(n * n!)`；
+  - 临时数组 `track`，在每个递归调用中，`track` 的最大长度为 `n`，因此其空间复杂度为 `O(n)`；
+  - 布尔数组 `used` 用于标记哪些元素已经被使用，大小为 `n`，因此占用 `O(n)` 的空间。
+  - 综合考虑，最主要的空间复杂度来源于结果数组 `res`，因此整体空间复杂度为 `O(n * n!)`。
 
 ## 代码
 

src/problem/0443.md

@@ -172,5 +172,5 @@ var compress = function (chars) {
 | 271 | [字符串的编码与解码 🔒](https://leetcode.com/problems/encode-and-decode-strings) |  |  [`设计`](/tag/design.md) [`数组`](/tag/array.md) [`字符串`](/tag/string.md) | <font color=#ffb800>Medium</font> |
 | 604 | [迭代压缩字符串 🔒](https://leetcode.com/problems/design-compressed-string-iterator) |  |  [`设计`](/tag/design.md) [`数组`](/tag/array.md) [`字符串`](/tag/string.md) `1+` | <font color=#15bd66>Easy</font> |
 | 1313 | [解压缩编码列表](https://leetcode.com/problems/decompress-run-length-encoded-list) |  |  [`数组`](/tag/array.md) | <font color=#15bd66>Easy</font> |
-| 3163 | [压缩字符串 III](https://leetcode.com/problems/string-compression-iii) |  |  [`字符串`](/tag/string.md) | <font color=#ffb800>Medium</font> |
+| 3163 | [压缩字符串 III](https://leetcode.com/problems/string-compression-iii) | [[✓]](/problem/3163.md) |  [`字符串`](/tag/string.md) | <font color=#ffb800>Medium</font> |
 | 3167 | [字符串的更好压缩 🔒](https://leetcode.com/problems/better-compression-of-string) |  |  [`哈希表`](/tag/hash-table.md) [`字符串`](/tag/string.md) [`计数`](/tag/counting.md) `1+` | <font color=#ffb800>Medium</font> |

src/problem/1233.md

@@ -121,7 +121,7 @@ followed by one or more lowercase English letters.
 #### 复杂度分析
 
 - **时间复杂度**：`O(n log n)`，其中 `n` 是文件夹的数量，主要开销在对 `folder` 数组进行排序。
-- **空间复杂度**：`O(1)`，不包含结果数组的存储空间。
+- **空间复杂度**：`O(n)`，用于存储结果数组，最坏情况下（当所有文件夹都是独立的，没有子文件夹），`res` 的长度与输入数组相同。
 
 ## 代码
 

src/problem/1957.md

@@ -120,7 +120,7 @@ will always be **unique**.
 #### 复杂度分析
 
 - **时间复杂度**：`O(n)`，其中 `n` 是字符串 `s` 的长度，只遍历一次字符串，每个字符的处理是常数时间。
-- **空间复杂度**：`O(1)`，不包含结果存储空间，只使用了常数个变量。
+- **空间复杂度**：`O(n)`，用于存储结果字符串，最坏情况下（输入字符串中没有重复字符），`res` 字符串的长度与输入字符串相同。
 
 ## 代码
 

src/problem/2352.md

@@ -85,19 +85,19 @@ the same order (i.e., an equal array).
 1. **初始化变量**：
 
    - 获取矩阵的行数和列数 `n`。
-   - 创建一个哈希表 `map` 来存储行的字符串表示的出现次数。
-   - 创建一个数组 `arr` 用于构建列的字符串表示。
+   - 创建一个哈希表 `rows` 来存储行的字符串表示的出现次数。
+   - 创建一个数组 `cols` 用于构建列的字符串表示。
 
 2. **统计行的出现次数**：
 
-   - 遍历每一行，将每一行的元素拼接成字符串 `str`（以逗号分隔）。
-   - 将这个字符串作为键存入哈希表 `map`，并记录其出现次数。
-   - 同时，将每一行的元素拼接到对应的列字符串 `arr[j]` 中，构建列的字符串表示。
+   - 遍历每一行，将每一行的元素拼接成字符串 `rowStr`（以逗号分隔）。
+   - 将这个字符串作为键存入哈希表 `rows`，并记录其出现次数。
+   - 同时，将每一行的元素拼接到对应的列字符串 `cols[j]` 中，构建列的字符串表示。
 
 3. **统计行列对的数量**：
 
    - 初始化结果 `res` 为 0。
-   - 遍历构建的列字符串 `arr`，对每个列字符串，在哈希表中查找其出现次数。
+   - 遍历构建的列字符串 `cols`，对每个列字符串，在哈希表中查找其出现次数。
    - 将出现次数累加到结果 `res` 中。
 
 4. **返回结果**：
@@ -106,7 +106,7 @@ the same order (i.e., an equal array).
 #### 复杂度分析
 
 - **时间复杂度**：`O(n^2)`，因为需要遍历整个 `grid` 矩阵一次，构建行和列字符串。
-- **空间复杂度**：`O(n)`，哈希表 `map` 和数组 `arr` 存储了行和列的字符串表示。
+- **空间复杂度**：`O(n)`，哈希表 `rows` 和数组 `cols` 存储了行和列的字符串表示。
 
 ## 代码
 
@@ -118,24 +118,24 @@ the same order (i.e., an equal array).
 var equalPairs = function (grid) {
 	const n = grid.length;
 	// 存储行的字符串表示
-	let map = new Map();
+	let rows = new Map();
 	// 存储列的字符串表示
-	let arr = new Array(n).fill('');
+	let cols = new Array(n).fill('');
 
 	// 构建并统计行字符串和列字符串
 	for (let i = 0; i < n; i++) {
-		let str = '';
+		let rowStr = '';
 		for (let j = 0; j < n; j++) {
-			str += grid[i][j] + ',';
-			arr[j] += grid[i][j] + ',';
+			rowStr += grid[i][j] + ',';
+			cols[j] += grid[i][j] + ',';
 		}
-		map.set(str, (map.get(str) || 0) + 1);
+		rows.set(rowStr, (rows.get(rowStr) || 0) + 1);
 	}
 
 	let res = 0;
 	// 统计满足条件的行列对数量
-	for (let str of arr) {
-		res += map.get(str) || 0;
+	for (let colStr of cols) {
+		res += rows.get(colStr) || 0;
 	}
 	return res;
 };