init

Author: CompetitiveLin

.github/workflows/action.yml

@@ -0,0 +1,58 @@
+name: 'GitHub LeetCode Bot'
+
+on:
+  # 执行git push操作将会触发此脚本
+  push:
+
+  # 每隔12小时将会触发此脚本
+  schedule:
+    - cron: '0 */12 * * *'
+  workflow_dispatch:
+
+jobs:
+  bot:
+    # 运行环境，Ubuntu
+    runs-on: ubuntu-latest
+    steps:
+      # 检测代码
+      - name: 'Checkout codes'
+        uses: actions/checkout@v2
+      
+      # 修改系统时区
+      - name: Setup the time zone to Asia/Shanghai
+        uses: zcong1993/setup-timezone@master
+        with:
+          timezone: Asia/Shanghai
+      
+      # 安装Python3.6
+      - name: Set up Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.6
+      
+      # 清除pip缓存   
+      - name: Configure pip cache
+        uses: actions/cache@v1
+        id: pip-cache
+        with:
+          path: venv
+          key: pip-1-${{ hashFiles('**/requirements.txt') }}
+          restore-keys: |
+            pip-
+
+      # 安装requirements.txt中的依赖包
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+        if: steps.pip-cache.outputs.cache-hit != 'true'
+
+      # 运行leetcode.py文件
+      # 将在程序当前生成目录下生成一个新的README.md文件
+      - name: Get LeetCode Data
+        run: python leetcode.py ${{ secrets.LEETCODE_EMAIL }} ${{ secrets.LEETCODE_PASSWORD }}
+
+      # 执行push操作，推送最新的README.md文件
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: Update changes

.gitignore

@@ -0,0 +1,13 @@
+# mac OSX
+
+# 忽略所有以.DS_Store结尾的文件
+*.DS_Store
+
+# 忽略venv文件夹下的所有文件
+/venv/
+
+# 忽略.idea文件夹下的所有文件
+/.idea/
+
+# 只忽略__pycache__目录，不忽略__pycache__文件
+__pycache__/

Breadth First Search/1926. 迷宫中离入口最近的出口.md

@@ -0,0 +1,96 @@
+#### 1926. 迷宫中离入口最近的出口
+
+难度：中等
+
+---
+
+给你一个 `m x n` 的迷宫矩阵 `maze` （ **下标从 0 开始** ），矩阵中有空格子（用 `'.'` 表示）和墙（用 `'+'` 表示）。同时给你迷宫的入口 `entrance` ，用 `entrance = [entrancerow, entrancecol]` 表示你一开始所在格子的行和列。
+
+每一步操作，你可以往  **上** ， **下** ， **左**  或者  **右**  移动一个格子。你不能进入墙所在的格子，你也不能离开迷宫。你的目标是找到离 `entrance`  **最近**  的出口。 **出口**  的含义是 `maze`  **边界**  上的  **空格子** 。`entrance` 格子  **不算**  出口。
+
+请你返回从 `entrance` 到最近出口的最短路径的  **步数**  ，如果不存在这样的路径，请你返回 `-1` 。
+
+ **示例 1：** 
+
+![](https://assets.leetcode.com/uploads/2021/06/04/nearest1-grid.jpg)
+```
+输入：maze = [["+","+",".","+"],[".",".",".","+"],["+","+","+","."]], entrance = [1,2]
+输出：1
+解释：总共有 3 个出口，分别位于 (1,0)，(0,2) 和 (2,3) 。
+一开始，你在入口格子 (1,2) 处。
+- 你可以往左移动 2 步到达 (1,0) 。
+- 你可以往上移动 1 步到达 (0,2) 。
+从入口处没法到达 (2,3) 。
+所以，最近的出口是 (0,2) ，距离为 1 步。
+```
+
+ **示例 2：** 
+
+![](https://assets.leetcode.com/uploads/2021/06/04/nearesr2-grid.jpg)
+```
+输入：maze = [["+","+","+"],[".",".","."],["+","+","+"]], entrance = [1,0]
+输出：2
+解释：迷宫中只有 1 个出口，在 (1,2) 处。
+(1,0) 不算出口，因为它是入口格子。
+初始时，你在入口与格子 (1,0) 处。
+- 你可以往右移动 2 步到达 (1,2) 处。
+所以，最近的出口为 (1,2) ，距离为 2 步。
+```
+
+ **示例 3：** 
+
+![](https://assets.leetcode.com/uploads/2021/06/04/nearest3-grid.jpg)
+```
+输入：maze = [[".","+"]], entrance = [0,0]
+输出：-1
+解释：这个迷宫中没有出口。
+```
+
+ **提示：** 
+
+*   `maze.length == m`
+*   `maze[i].length == n`
+*   `1 <= m, n <= 100`
+*   `maze[i][j]` 要么是 `'.'` ，要么是 `'+'` 。
+*   `entrance.length == 2`
+*   `0 <= entrancerow < m`
+*   `0 <= entrancecol < n`
+*   `entrance` 一定是空格子。
+
+---
+
+非递归的广度优先搜索，有以下几个技巧：
+
+1. 遍历后将当前点变为**墙**，便不会进行二次操作。
+
+2. 使用**辅助数组**保存四个方位的横坐标及纵坐标的**变化**。
+
+```java
+class Solution {
+    public int nearestExit(char[][] maze, int[] entrance) {
+        int[][] dir = new int[][]{{1, 0},{-1, 0},{0, 1},{0, -1}};
+        int ans = 0;
+        ArrayDeque<int[]> queue = new ArrayDeque<>();
+        queue.offer(entrance);
+        maze[entrance[0]][entrance[1]] = '+';
+        while(!queue.isEmpty()){
+            int n = queue.size();
+            for(int i = 0; i < n; i++){
+                int[] temp = queue.poll();
+                if((temp[0] == maze.length - 1 || temp[1] == maze[0].length - 1 || temp[0] == 0 || temp[1] == 0) && (temp[0] != entrance[0] || temp[1] != entrance[1])) return ans;
+                for(int[] array: dir){
+                    int x = temp[0] + array[0], y = temp[1] + array[1];
+                    if(x >= 0 && x < maze.length && y >= 0 && y < maze[0].length && maze[x][y] != '+'){
+                        queue.offer(new int[]{x, y});
+                        maze[x][y] = '+';
+                    }
+                }
+            }
+            ans += 1;
+        }
+        return -1;
+    }
+}
+```
+
+补充一点，**广度优先搜索**大部分使用**非递归**的方法，**深度优先搜索**大部分使用**递归**的方法。

Depth First Search/1339. 分裂二叉树的最大乘积.md

@@ -0,0 +1,145 @@
+#### 1339. 分裂二叉树的最大乘积
+
+难度：中等
+
+-------
+
+给你一棵二叉树，它的根为 `root` 。请你删除 1 条边，使二叉树分裂成两棵子树，且它们子树和的乘积尽可能大。
+
+由于答案可能会很大，请你将结果对 10^9 + 7 取模后再返回。
+
+ **示例 1：** 
+
+ **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/02/sample_1_1699.png)** 
+
+```
+输入：root = [1,2,3,4,5,6]
+输出：110
+解释：删除红色的边，得到 2 棵子树，和分别为 11 和 10 。它们的乘积是 110 （11*10）
+```
+
+ **示例 2：** 
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/02/sample_2_1699.png)
+
+```
+输入：root = [1,null,2,3,4,null,null,5,6]
+输出：90
+解释：移除红色的边，得到 2 棵子树，和分别是 15 和 6 。它们的乘积为 90 （15*6）
+```
+
+ **示例 3：** 
+
+```
+输入：root = [2,3,9,10,7,8,6,5,4,11,1]
+输出：1025
+```
+
+ **示例 4：** 
+
+```
+输入：root = [1,1]
+输出：1
+```
+
+ **提示：** 
+
+*   每棵树最多有 `50000` 个节点，且至少有 `2` 个节点。
+*   每个节点的值在 `[1, 10000]` 之间。
+
+---
+
+失败：
+
+1.  `MOD = (int) 1e9 + 7` !!!!
+
+2. 应该是 `return ans % MOD`，而不是在每一次取最大值的时候取余
+
+3. 需要用到 MOD 的时候最好使用 `long` 类型
+
+
+```java
+class Solution {
+    private static final int MOD = (int) 10e9 + 7;  // 低级错误！！！
+    private int ans = 0, sum;
+    public int maxProduct(TreeNode root) {
+        sum = dfs(root);
+        dfs2(root);
+        return ans;
+    }
+
+    private int dfs(TreeNode root){
+        if(root == null) return 0;
+        return dfs(root.left) + dfs(root.right) +  root.val;
+    }
+
+    private void dfs2(TreeNode root){
+        if(root == null) return;
+        int temp = dfs(root);
+        ans = Math.max(ans, ((sum - temp) * temp) % MOD);       // 不应该在此处取余
+        dfs2(root.left);
+        dfs2(root.right);
+    }
+}
+```
+
+失败：
+
+1. 在递归中调用了递归，**嵌套的双重递归是十分消耗资源**的，从[这里](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree/solution/shi-gai-xiang-zui-da-hua-chu-shi-gen-jie-3cpw/)发现问题的。
+
+
+```java
+class Solution {
+    private static final long MOD = (long) 1e9 + 7;
+    private long ans = 0, sum;
+    long test = 0;
+    public int maxProduct(TreeNode root) {
+        sum = dfs(root);
+        dfs2(root);
+        return (int) (ans % MOD);
+    }
+
+    private long dfs(TreeNode root){
+        if(root == null) return 0;
+        return dfs(root.left) + dfs(root.right) +  (long)root.val;
+    }
+
+    private void dfs2(TreeNode root){
+        if(root == null) return;
+        long temp = dfs(root);  // 双重递归，十分消耗资源！
+        if(((sum - temp) * temp) % MOD > ans) test =  temp ;
+        ans = Math.max(ans, ((sum - temp) * temp));
+        dfs2(root.left);
+        dfs2(root.right);
+    }
+}
+```
+
+成功：
+
+补充一点，嵌套的双重递归是自顶向下，每个递归的节点又自顶向下递归一遍，修改后的代码是自底向上的，每个结点只遍历一遍。
+
+```java
+class Solution {
+    private static final long MOD = (long) 1e9 + 7;
+    private long ans = 0, sum;
+    long test = 0;
+    public int maxProduct(TreeNode root) {
+        sum = dfs(root);
+        dfs2(root);
+        return (int) (ans % MOD);
+    }
+
+    private long dfs(TreeNode root){
+        if(root == null) return 0;
+        return dfs(root.left) + dfs(root.right) +  (long)root.val;
+    }
+
+    private long dfs2(TreeNode root){
+        if(root == null) return 0;
+        long temp = dfs2(root.left) + dfs2(root.right) + root.val;
+        ans = Math.max(ans, ((sum - temp) * temp));
+        return temp;
+    }
+}
+```