update: 62.不同路径

Author: suukii

README.md

@@ -162,13 +162,22 @@
 
 ### 高频面试题
 
+**二叉树遍历系列**
+
 -   [x] [【day-34】二叉树遍历系列](./medium/hot/34.traversal-of-binary-tree.md)
--   [x] [【day-34】581.最短无序连续子数组](./medium/day-34.md)
--   [x] [【day-35】78.子集](./medium/day-35.md)
--   [x] [【day-36】62.不同路径](./medium/day-36.md)
+
+**位运算系列**
+
+-   [ ] [【day-36】78.子集](./medium/hot/36.subsets.md)
+
+**动态规划系列**
+
+-   [x] [【day-37】62.不同路径](./medium/hot/37.unique-paths.md)
+
 -   [x] [【day-37】有效括号系列](./medium/day-37.md)
 -   [x] [【day-38】反转链表系列](./medium/day-38.md)
 -   [x] [【day-39】前缀和系列](./medium/day-39.md)
+-   [x] [581.最短无序连续子数组](./medium/day-34.md)
 
 ### 前缀树
 

basic/array-stack-queue/02.shortest-distance-to-a-character.md

@@ -12,7 +12,7 @@ https://leetcode-cn.com/problems/shortest-distance-to-a-character
     - [思路](#思路-1)
     - [复杂度分析](#复杂度分析-1)
     - [代码](#代码-1)
-  - [解法 3：水波法](#解法-3水波法)
+  - [解法 3：贪心](#解法-3贪心)
     - [思路](#思路-2)
     - [复杂度分析](#复杂度分析-2)
     - [代码](#代码-2)
@@ -45,9 +45,13 @@ S 和 C 中的所有字母均为小写字母。
 
 ### 思路
 
-直觉想法，就是对每个字符进行分别处理：从当前下标出发，分别向左、右两个方向去寻找目标字符 `C`。
+这是最符合直觉的思路，对每个字符分别进行如下处理：
 
-![](https://cdn.jsdelivr.net/gh/suukii/91-days-algorithm/assets/821_0.png)
+-   从当前下标出发，分别向左、右两个方向去寻找目标字符 `C`。
+-   只在一个方向找到的话，直接计算字符距离。
+-   两个方向都找到的话，取两个距离的最小值。
+
+![](https://pic.leetcode-cn.com/1606962060-CnDiHj-file_1606962060610)
 
 ### 复杂度分析
 
@@ -103,9 +107,11 @@ var shortestToChar = function (S, C) {
 
 ### 思路
 
-因为目标字符 `C` 在 `S` 中的位置是不变的，所以我们可以将 `C` 的所有下标记录在一个数组 `cIndices` 中。
+空间换时间是编程中很常见的一种 trade-off (反过来，时间换空间也是)。
+
+因为目标字符 `C` 在 `S` 中的位置是不变的，所以我们可以提前将 `C` 的所有下标记录在一个数组 `cIndices` 中。
 
-然后对于字符串 `S` 中的每个字符，在 `cIndices` 中找到距离当前位置最近的下标，记录到结果数组中。
+然后遍历字符串 `S` 中的每个字符，到 `cIndices` 中找到距离当前位置最近的下标，计算距离。
 
 ### 复杂度分析
 
@@ -154,28 +160,28 @@ var shortestToChar = function (S, C) {
 };
 ```
 
-## 解法 3：水波法
+## 解法 3：贪心
 
 ### 思路
 
-其实对于每个字符来说，它只关心离它最近的那个 `C` 字符，所以我们可以用类似前缀和的思想：
+其实对于每个字符来说，它只关心离它最近的那个 `C` 字符，其他的它都不管。所以这里还可以用贪心的思路：
 
 1. 先 `从左往右` 遍历字符串 `S`，用一个数组 left 记录每个字符 `左侧` 出现的最后一个 `C` 字符的下标；
-2. 在 `从右往左` 遍历字符串 `S`，用一个数组 right 记录每个字符 `右侧` 出现的最后一个 `C` 字符的下标；
-3. 然后同时遍历这两个数组，计算距离最小值放进结果数组中。
+2. 再 `从右往左` 遍历字符串 `S`，用一个数组 right 记录每个字符 `右侧` 出现的最后一个 `C` 字符的下标；
+3. 然后同时遍历这两个数组，计算距离最小值。
 
 **优化 1**
 
-再多想一步，其实第二个数组也并不需要。因为对于左右两侧的 `C` 字符，我们也只关心距离最近的那一个，所以第二次遍历的时候可以看情况覆盖掉 left 数组的值：
+再多想一步，其实第二个数组并不需要。因为对于左右两侧的 `C` 字符，我们也只关心其中距离更近的那一个，所以第二次遍历的时候可以看情况覆盖掉第一个数组的值：
 
 1. 字符左侧没有出现过 `C` 字符
 2. `i - left` > `right - i` (i 为当前字符下标，left 为字符左侧最近的 `C` 下标，right 为字符右侧最近的 `C` 下标)
 
-如果出现以上两种情况，就可以用原本 right 数组中的值覆盖掉 left 数组中的值。最后我们再遍历一次数组计算距离。
+如果出现以上两种情况，就可以进行覆盖，最后再遍历一次数组计算距离。
 
 **优化 2**
 
-如果我们是直接记录距离，而不是记录 `C` 的下标，还可以省掉最后一次遍历计算距离的过程。
+如果我们是直接记录 `C` 与当前字符的距离，而不是记录 `C` 的下标，还可以省掉最后一次遍历计算距离的过程。
 
 ### 复杂度分析
 
@@ -252,9 +258,9 @@ var shortestToChar = function (S, C) {
 
 ### 思路
 
-用 `C` 将 `S` 划分成一个个窗口，对于窗口中的每个字符，分别计算它们到窗口左右两边的距离，取最小值即可。
+把 `C` 看成分界线，将 `S` 划分成一个个窗口。然后对每个窗口进行遍历，分别计算每个字符到窗口边界的距离最小值。
 
-![](https://cdn.jsdelivr.net/gh/suukii/91-days-algorithm/assets/821_1.png)
+![](https://pic.leetcode-cn.com/1606962060-WhqxbZ-file_1606962060746)
 
 ### 复杂度分析
 

medium/day-35.md

@@ -0,0 +1,77 @@
+# 78.子集
+
+https://leetcode-cn.com/problems/subsets
+
+## 题目描述
+
+```
+给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
+
+说明：解集不能包含重复的子集。
+
+示例:
+
+输入: nums = [1,2,3]
+输出:
+[
+[3],
+  [1],
+  [2],
+  [1,2,3],
+  [1,3],
+  [2,3],
+  [1,2],
+  []
+]
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/subsets
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+```
+
+## 方法 1：回溯
+
+### 思路
+
+如果我们要生成**一个**子集，那步骤大概是：
+
+-   初始化一个数组用来表示这个子集；
+-   遍历数组，对每个元素做出选择：
+    -   把它放进子集中；
+    -   不把它放进子集中；
+-   遍历结束后就得到了一个子集；
+
+那如果要生成所有的子集的话：
+
+-   当我们对当前元素做出选择后，可以递归地去对数组剩余的其他元素做选择；
+-   等递归到数组的最后一个元素，也就是说，我们已经遍历完一轮数组，对每个元素都做出了选择，那我们就得到了一个子集，把这个子集存到一个全局数组变量中；
+-   等到 DFS 结束后返回这个全局变量就行；
+
+### 复杂度分析
+
+-   时间复杂度：由排列组合原理可知，一共有 $2^N$ 种组合，因此时间复杂度为 $O(2^N)$，其中 $N$ 为数字的个数。
+-   空间复杂度：由于调用栈深度最多为 $N$，且临时数组长度不会超过 $N$，因此空间复杂度为 $O(N)$，其中 $N$ 为数字的个数。
+
+### 代码
+
+TypeScript Code
+
+```ts
+function subsets(nums: number[]): number[][] {
+    const res: number[][] = [];
+
+    const dfs = (nums: number[], cur: number, sub: number[]): void => {
+        if (cur === nums.length) {
+            res.push(sub);
+            return;
+        }
+        // exclude the current element
+        dfs(nums, cur + 1, sub);
+        // include the current element
+        dfs(nums, cur + 1, [...sub, nums[cur]]);
+    };
+
+    dfs(nums, 0, []);
+    return res;
+}
+```