力扣idea插件更新

.gitignore

@@ -4,3 +4,4 @@
 /target/
 /src/main/java/leetcode/editor/cn/*.txt
 /src/main/java/leetcode/editor/cn/doc/solution/
+/src/main/java/leetcode/editor/cn/doc/submission/

src/main/java/com/code/leet/entiy/Node.java

@@ -25,6 +25,11 @@ public class Node {
         this.random = random;
     }
 
+    public Node(int val, List<Node> children) {
+        this.val = val;
+        this.children = children;
+    }
+
     public Node(int val, Node prev, Node next, Node child) {
         this.val = val;
         this.prev = prev;

src/main/java/leetcode/editor/cn/AllPathsFromSourceToTarget.java

@@ -0,0 +1,122 @@
+//给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序） 
+//
+// 二维数组的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些节点，空就是没有下一个结点了。 
+//
+// 译者注：有向图是有方向的，即规定了 a→b 你就不能从 b→a 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//
+// 
+//输入：graph = [[1,2],[3],[3],[]]
+//输出：[[0,1,3],[0,2,3]]
+//解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3
+// 
+//
+// 示例 2： 
+//
+// 
+//
+// 
+//输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]
+//输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：graph = [[1],[]]
+//输出：[[0,1]]
+// 
+//
+// 示例 4： 
+//
+// 
+//输入：graph = [[1,2,3],[2],[3],[]]
+//输出：[[0,1,2,3],[0,2,3],[0,3]]
+// 
+//
+// 示例 5： 
+//
+// 
+//输入：graph = [[1,3],[2],[3],[]]
+//输出：[[0,1,2,3],[0,3]]
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == graph.length 
+// 2 <= n <= 15 
+// 0 <= graph[i][j] < n 
+// graph[i][j] != i（即，不存在自环） 
+// graph[i] 中的所有元素 互不相同 
+// 保证输入为 有向无环图（DAG） 
+// 
+// Related Topics 深度优先搜索 广度优先搜索 图 回溯 👍 143 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.ArrayList;
+import java.util.List;
+
+//797:所有可能的路径
+class AllPathsFromSourceToTarget {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new AllPathsFromSourceToTarget().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        //        List<List<Integer>> result = new ArrayList<>();
+//
+//        public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+//            path(graph, 0, new ArrayList<>());
+//            return result;
+//        }
+//
+//        public void path(int[][] graph, int index, List<Integer> list) {
+//            list.add(index);
+//            if (index == graph.length) {
+//                result.add(new ArrayList<>(list));
+//                list.remove(list.size() - 1);
+//                return;
+//            }
+//            for (int i = 0; i < graph[index].length; i++) {
+//                path(graph, graph[index][i], list);
+//            }
+//            list.remove(list.size() - 1);
+//        }
+        public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+            return solve(graph, 0);
+        }
+
+        public List<List<Integer>> solve(int[][] graph, int node) {
+            int N = graph.length;
+            List<List<Integer>> ans = new ArrayList();
+            if (node == N - 1) {
+                List<Integer> path = new ArrayList();
+                path.add(N - 1);
+                ans.add(path);
+                return ans;
+            }
+
+            for (int nei : graph[node]) {
+                for (List<Integer> path : solve(graph, nei)) {
+                    path.add(0, node);
+                    ans.add(path);
+                }
+            }
+            return ans;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/BuildArrayFromPermutation.java

@@ -0,0 +1,62 @@
+//给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，对于每个 i（0 <= i < nums.
+//length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。 
+//
+// 从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。
+// 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：nums = [0,2,1,5,3,4]
+//输出：[0,1,2,4,5,3]
+//解释：数组 ans 构建如下：
+//ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4
+//]], nums[nums[5]]]
+//    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+//    = [0,1,2,4,5,3] 
+//
+// 示例 2： 
+//
+// 输入：nums = [5,0,1,2,3,4]
+//输出：[4,5,0,1,2,3]
+//解释：数组 ans 构建如下：
+//ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4
+//]], nums[nums[5]]]
+//    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+//    = [4,5,0,1,2,3] 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= nums.length <= 1000 
+// 0 <= nums[i] < nums.length 
+// nums 中的元素 互不相同 
+// 
+// Related Topics 数组 模拟 👍 2 👎 0
+
+package leetcode.editor.cn;
+//1920:基于排列构建数组
+class BuildArrayFromPermutation{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new BuildArrayFromPermutation().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[] buildArray(int[] nums) {
+        int size = nums.length;
+        int[] arr = new int[size];
+        for (int i = 0; i < size; i++) {
+            arr[i] = nums[nums[i]];
+        }
+        return arr;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/CheckIfAllCharactersHaveEqualNumberOfOccurrences.java

@@ -0,0 +1,59 @@
+//给你一个字符串 s ，如果 s 是一个 好 字符串，请你返回 true ，否则请返回 false 。 
+//
+// 如果 s 中出现过的 所有 字符的出现次数 相同 ，那么我们称字符串 s 是 好 字符串。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：s = "abacbc"
+//输出：true
+//解释：s 中出现过的字符为 'a'，'b' 和 'c' 。s 中所有字符均出现 2 次。
+// 
+//
+// 示例 2： 
+//
+// 输入：s = "aaabb"
+//输出：false
+//解释：s 中出现过的字符为 'a' 和 'b' 。
+//'a' 出现了 3 次，'b' 出现了 2 次，两者出现次数不同。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= s.length <= 1000 
+// s 只包含小写英文字母。 
+// 
+// Related Topics 哈希表 字符串 计数 👍 0 👎 0
+
+package leetcode.editor.cn;
+//1941:检查是否所有字符出现次数相同
+class CheckIfAllCharactersHaveEqualNumberOfOccurrences{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new CheckIfAllCharactersHaveEqualNumberOfOccurrences().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public boolean areOccurrencesEqual(String s) {
+        int[] arr = new int[26];
+        for (char ch : s.toCharArray()) {
+            arr[ch - 'a']++;
+        }
+        int num = arr[s.charAt(0) - 'a'];
+        for (int j : arr) {
+            if (j > 0 && j != num) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/CloneGraph.java

@@ -0,0 +1,131 @@
+//给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。 
+//
+// 图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。 
+//
+// class Node {
+//    public int val;
+//    public List<Node> neighbors;
+//} 
+//
+// 
+//
+// 测试用例格式： 
+//
+// 简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻
+//接列表表示。 
+//
+// 邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。 
+//
+// 给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//
+// 输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
+//输出：[[2,4],[1,3],[2,4],[1,3]]
+//解释：
+//图中有 4 个节点。
+//节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
+//节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
+//节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
+//节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
+// 
+//
+// 示例 2： 
+//
+// 
+//
+// 输入：adjList = [[]]
+//输出：[[]]
+//解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
+// 
+//
+// 示例 3： 
+//
+// 输入：adjList = []
+//输出：[]
+//解释：这个图是空的，它不含任何节点。
+// 
+//
+// 示例 4： 
+//
+// 
+//
+// 输入：adjList = [[2],[1]]
+//输出：[[2],[1]] 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 节点数不超过 100 。 
+// 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。 
+// 无向图是一个简单图，这意味着图中没有重复的边，也没有自环。 
+// 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。 
+// 图是连通图，你可以从给定节点访问到所有节点。 
+// 
+// Related Topics 深度优先搜索 广度优先搜索 图 哈希表 👍 393 👎 0
+
+package leetcode.editor.cn;
+
+import com.code.leet.entiy.Node;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+//133:克隆图
+class CloneGraph{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new CloneGraph().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    private HashMap<Node, Node> use = new HashMap<>();
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return node;
+        }
+
+        if (use.containsKey(node)) {
+            return use.get(node);
+        }
+
+        Node cloneNode = new Node(node.val, new ArrayList());
+        use.put(node, cloneNode);
+
+        for (Node neighbor: node.children) {
+            cloneNode.children.add(cloneGraph(neighbor));
+        }
+        return cloneNode;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/CongWeiDaoTouDaYinLianBiaoLcof.java

@@ -0,0 +1,58 @@
+//输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：head = [1,3,2]
+//输出：[2,3,1] 
+//
+// 
+//
+// 限制： 
+//
+// 0 <= 链表长度 <= 10000 
+// Related Topics 栈 递归 链表 双指针 👍 173 👎 0
+
+package leetcode.editor.cn;
+
+import com.code.leet.entiy.ListNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+//剑指 Offer 06:从尾到头打印链表
+class CongWeiDaoTouDaYinLianBiaoLcof{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new CongWeiDaoTouDaYinLianBiaoLcof().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int[] reversePrint(ListNode head) {
+        List<Integer> list = new ArrayList<>();
+        while (head != null) {
+            list.add(head.val);
+            head = head.next;
+        }
+        int size = list.size();
+        int[] arr = new int[size];
+        for (int i = size - 1; i >= 0; i--) {
+            arr[i] = list.get(size - 1 - i);
+        }
+        return arr;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/CountSquareSumTriples.java

@@ -0,0 +1,58 @@
+//一个 平方和三元组 (a,b,c) 指的是满足 a² + b² = c² 的 整数 三元组 a，b 和 c 。 
+//
+// 给你一个整数 n ，请你返回满足 1 <= a, b, c <= n 的 平方和三元组 的数目。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：n = 5
+//输出：2
+//解释：平方和三元组为 (3,4,5) 和 (4,3,5) 。
+// 
+//
+// 示例 2： 
+//
+// 输入：n = 10
+//输出：4
+//解释：平方和三元组为 (3,4,5)，(4,3,5)，(6,8,10) 和 (8,6,10) 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= n <= 250 
+// 
+// Related Topics 数学 枚举 👍 5 👎 0
+
+package leetcode.editor.cn;
+//1925:统计平方和三元组的数目
+class CountSquareSumTriples{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new CountSquareSumTriples().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int countTriples(int n) {
+        int count = 0;
+        for (int i = n; i > 0; i--) {
+            for (int j = i - 1; j > 0; j--) {
+                int sum = i * i - j * j;
+                int num = (int) Math.sqrt(sum);
+                if (sum == num * num) {
+                    count++;
+
+                }
+            }
+        }
+        return count;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/DesignHashmap.java

@@ -0,0 +1,106 @@
+//不使用任何内建的哈希表库设计一个哈希映射（HashMap）。 
+//
+// 实现 MyHashMap 类： 
+//
+// 
+// MyHashMap() 用空映射初始化对象 
+// void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，
+//则更新其对应的值 value 。 
+// int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。 
+// void remove(key) 如果映射中存在 key 的映射，则移除 key 和它所对应的 value 。 
+// 
+//
+// 
+//
+// 示例： 
+//
+// 
+//输入：
+//["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
+//[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
+//输出：
+//[null, null, null, 1, -1, null, 1, null, -1]
+//
+//解释：
+//MyHashMap myHashMap = new MyHashMap();
+//myHashMap.put(1, 1); // myHashMap 现在为 [[1,1]]
+//myHashMap.put(2, 2); // myHashMap 现在为 [[1,1], [2,2]]
+//myHashMap.get(1);    // 返回 1 ，myHashMap 现在为 [[1,1], [2,2]]
+//myHashMap.get(3);    // 返回 -1（未找到），myHashMap 现在为 [[1,1], [2,2]]
+//myHashMap.put(2, 1); // myHashMap 现在为 [[1,1], [2,1]]（更新已有的值）
+//myHashMap.get(2);    // 返回 1 ，myHashMap 现在为 [[1,1], [2,1]]
+//myHashMap.remove(2); // 删除键为 2 的数据，myHashMap 现在为 [[1,1]]
+//myHashMap.get(2);    // 返回 -1（未找到），myHashMap 现在为 [[1,1]]
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 0 <= key, value <= 10⁶ 
+// 最多调用 10⁴ 次 put、get 和 remove 方法 
+// 
+//
+// 
+//
+// 进阶：你能否不使用内置的 HashMap 库解决此问题？ 
+// Related Topics 设计 数组 哈希表 链表 哈希函数 👍 218 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+
+//706:设计哈希映射
+class DesignHashmap {
+    public static void main(String[] args) {
+        //测试代码
+//        Solution solution = new DesignHashmap().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class MyHashMap {
+
+        int[] arr;
+
+        /**
+         * Initialize your data structure here.
+         */
+        public MyHashMap() {
+            arr = new int[1000001];
+            Arrays.fill(arr, -1);
+        }
+
+        /**
+         * value will always be non-negative.
+         */
+        public void put(int key, int value) {
+            arr[key] = value;
+        }
+
+        /**
+         * Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key
+         */
+        public int get(int key) {
+            return arr[key];
+        }
+
+        /**
+         * Removes the mapping of the specified value key if this map contains a mapping for the key
+         */
+        public void remove(int key) {
+            arr[key] = -1;
+        }
+    }
+
+/**
+ * Your MyHashMap object will be instantiated and called as such:
+ * MyHashMap obj = new MyHashMap();
+ * obj.put(key,value);
+ * int param_2 = obj.get(key);
+ * obj.remove(key);
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/EliminateMaximumNumberOfMonsters.java

@@ -0,0 +1,104 @@
+//你正在玩一款电子游戏，在游戏中你需要保护城市免受怪物侵袭。给你一个 下标从 0 开始 且长度为 n 的整数数组 dist ，其中 dist[i] 是第 i 
+//个怪物与城市的 初始距离（单位：米）。 
+//
+// 怪物以 恒定 的速度走向城市。给你一个长度为 n 的整数数组 speed 表示每个怪物的速度，其中 speed[i] 是第 i 个怪物的速度（单位：米/分
+//）。 
+//
+// 怪物从 第 0 分钟 时开始移动。你有一把武器，并可以 选择 在每一分钟的开始时使用，包括第 0 分钟。但是你无法在一分钟的中间使用武器。这种武器威力惊人
+//，一次可以消灭任一还活着的怪物。 
+//
+// 一旦任一怪物到达城市，你就输掉了这场游戏。如果某个怪物 恰 在某一分钟开始时到达城市，这会被视为 输掉 游戏，在你可以使用武器之前，游戏就会结束。 
+//
+// 返回在你输掉游戏前可以消灭的怪物的 最大 数量。如果你可以在所有怪物到达城市前将它们全部消灭，返回 n 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：dist = [1,3,4], speed = [1,1,1]
+//输出：3
+//解释：
+//第 0 分钟开始时，怪物的距离是 [1,3,4]，你消灭了第一个怪物。
+//第 1 分钟开始时，怪物的距离是 [X,2,3]，你没有消灭任何怪物。
+//第 2 分钟开始时，怪物的距离是 [X,1,2]，你消灭了第二个怪物。
+//第 3 分钟开始时，怪物的距离是 [X,X,1]，你消灭了第三个怪物。
+//所有 3 个怪物都可以被消灭。 
+//
+// 示例 2： 
+//
+// 
+//输入：dist = [1,1,2,3], speed = [1,1,1,1]
+//输出：1
+//解释：
+//第 0 分钟开始时，怪物的距离是 [1,1,2,3]，你消灭了第一个怪物。
+//第 1 分钟开始时，怪物的距离是 [X,0,1,2]，你输掉了游戏。
+//你只能消灭 1 个怪物。
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：dist = [3,2,4], speed = [5,3,2]
+//输出：1
+//解释：
+//第 0 分钟开始时，怪物的距离是 [3,2,4]，你消灭了第一个怪物。
+//第 1 分钟开始时，怪物的距离是 [X,0,2]，你输掉了游戏。 
+//你只能消灭 1 个怪物。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == dist.length == speed.length 
+// 1 <= n <= 10⁵ 
+// 1 <= dist[i], speed[i] <= 10⁵ 
+// 
+// Related Topics 贪心 数组 排序 👍 13 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+//1921:消灭怪物的最大数量
+class EliminateMaximumNumberOfMonsters{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new EliminateMaximumNumberOfMonsters().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int eliminateMaximum(int[] dist, int[] speed) {
+        int size = dist.length;
+        int[] times = new int[size];
+        for (int i = 0; i < size; i++) {
+            int time = dist[i] / speed[i];
+            times[i] = dist[i] % speed[i] == 0 ? time - 1 : time;
+        }
+        Arrays.sort(times);
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < size; i++) {
+            map.put(times[i], map.getOrDefault(times[i], 0) + 1);
+        }
+        int index = 1;
+        for (int i = 0; i < size; i++) {
+            if(map.containsKey(i)){
+                if(map.get(i)>index){
+                    return i+1;
+                }
+                index-=map.get(i);
+            }
+            index++;
+        }
+        return size;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/FindGreatestCommonDivisorOfArray.java

@@ -0,0 +1,75 @@
+//给你一个整数数组 nums ，返回数组中最大数和最小数的 最大公约数 。 
+//
+// 两个数的 最大公约数 是能够被两个数整除的最大正整数。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：nums = [2,5,6,9,10]
+//输出：2
+//解释：
+//nums 中最小的数是 2
+//nums 中最大的数是 10
+//2 和 10 的最大公约数是 2
+// 
+//
+// 示例 2： 
+//
+// 输入：nums = [7,5,6,8,3]
+//输出：1
+//解释：
+//nums 中最小的数是 3
+//nums 中最大的数是 8
+//3 和 8 的最大公约数是 1
+// 
+//
+// 示例 3： 
+//
+// 输入：nums = [3,3]
+//输出：3
+//解释：
+//nums 中最小的数是 3
+//nums 中最大的数是 3
+//3 和 3 的最大公约数是 3
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 2 <= nums.length <= 1000 
+// 1 <= nums[i] <= 1000 
+// 
+// 👍 2 👎 0
+
+package leetcode.editor.cn;
+//1979:找出数组的最大公约数
+class FindGreatestCommonDivisorOfArray{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new FindGreatestCommonDivisorOfArray().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int findGCD(int[] nums) {
+        int max = Integer.MIN_VALUE;
+        int min = Integer.MAX_VALUE;
+        for (int num : nums) {
+            max = Math.max(max, num);
+            min = Math.min(min, num);
+        }
+        for (int i = min; i >= 1; i--) {
+            if (max % i == 0 && min % i == 0) {
+                return i;
+            }
+        }
+        return 1;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/FindTheStudentThatWillReplaceTheChalk.java

@@ -0,0 +1,94 @@
+//一个班级里有 n 个学生，编号为 0 到 n - 1 。每个学生会依次回答问题，编号为 0 的学生先回答，然后是编号为 1 的学生，以此类推，直到编号为 
+//n - 1 的学生，然后老师会重复这个过程，重新从编号为 0 的学生开始回答问题。 
+//
+// 给你一个长度为 n 且下标从 0 开始的整数数组 chalk 和一个整数 k 。一开始粉笔盒里总共有 k 支粉笔。当编号为 i 的学生回答问题时，他会消耗
+// chalk[i] 支粉笔。如果剩余粉笔数量 严格小于 chalk[i] ，那么学生 i 需要 补充 粉笔。 
+//
+// 请你返回需要 补充 粉笔的学生 编号 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：chalk = [5,1,5], k = 22
+//输出：0
+//解释：学生消耗粉笔情况如下：
+//- 编号为 0 的学生使用 5 支粉笔，然后 k = 17 。
+//- 编号为 1 的学生使用 1 支粉笔，然后 k = 16 。
+//- 编号为 2 的学生使用 5 支粉笔，然后 k = 11 。
+//- 编号为 0 的学生使用 5 支粉笔，然后 k = 6 。
+//- 编号为 1 的学生使用 1 支粉笔，然后 k = 5 。
+//- 编号为 2 的学生使用 5 支粉笔，然后 k = 0 。
+//编号为 0 的学生没有足够的粉笔，所以他需要补充粉笔。 
+//
+// 示例 2： 
+//
+// 输入：chalk = [3,4,1,2], k = 25
+//输出：1
+//解释：学生消耗粉笔情况如下：
+//- 编号为 0 的学生使用 3 支粉笔，然后 k = 22 。
+//- 编号为 1 的学生使用 4 支粉笔，然后 k = 18 。
+//- 编号为 2 的学生使用 1 支粉笔，然后 k = 17 。
+//- 编号为 3 的学生使用 2 支粉笔，然后 k = 15 。
+//- 编号为 0 的学生使用 3 支粉笔，然后 k = 12 。
+//- 编号为 1 的学生使用 4 支粉笔，然后 k = 8 。
+//- 编号为 2 的学生使用 1 支粉笔，然后 k = 7 。
+//- 编号为 3 的学生使用 2 支粉笔，然后 k = 5 。
+//- 编号为 0 的学生使用 3 支粉笔，然后 k = 2 。
+//编号为 1 的学生没有足够的粉笔，所以他需要补充粉笔。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// chalk.length == n 
+// 1 <= n <= 10⁵ 
+// 1 <= chalk[i] <= 10⁵ 
+// 1 <= k <= 10⁹ 
+// 
+// Related Topics 数组 二分查找 前缀和 模拟 👍 4 👎 0
+
+package leetcode.editor.cn;
+//1894:找到需要补充粉笔的学生编号
+class FindTheStudentThatWillReplaceTheChalk{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new FindTheStudentThatWillReplaceTheChalk().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int chalkReplacer(int[] chalk, int k) {
+        int temp = k;
+        int length = chalk.length;
+        int[] free = new int[length];
+        for (int i = 0; i < length; i++) {
+            if (i == 0) {
+                free[i] = chalk[i];
+            } else {
+                free[i] += chalk[i] + free[i - 1];
+            }
+            temp -= chalk[i];
+            if (temp < 0) {
+                return i;
+            }
+        }
+        temp %= free[length - 1];
+        if (temp == 0) {
+            return 0;
+        }
+        for (int i = 0; i < length; i++) {
+            temp -= chalk[i];
+            if (temp < 0) {
+                return i;
+            }
+        }
+        return 0;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/FindUniqueBinaryString.java

@@ -0,0 +1,74 @@
+//给你一个字符串数组 nums ，该数组由 n 个 互不相同 的二进制字符串组成，且每个字符串长度都是 n 。请你找出并返回一个长度为 n 且 没有出现 在 
+//nums 中的二进制字符串。如果存在多种答案，只需返回 任意一个 即可。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：nums = ["01","10"]
+//输出："11"
+//解释："11" 没有出现在 nums 中。"00" 也是正确答案。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：nums = ["00","01"]
+//输出："11"
+//解释："11" 没有出现在 nums 中。"10" 也是正确答案。
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：nums = ["111","011","001"]
+//输出："101"
+//解释："101" 没有出现在 nums 中。"000"、"010"、"100"、"110" 也是正确答案。 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == nums.length 
+// 1 <= n <= 16 
+// nums[i].length == n 
+// nums[i] 为 '0' 或 '1' 
+// 
+// 👍 2 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.List;
+
+//1980:找出不同的二进制字符串
+class FindUniqueBinaryString{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new FindUniqueBinaryString().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public String findDifferentBinaryString(String[] nums) {
+        int n = nums.length;
+        List<String> list = Arrays.asList(nums);
+        int max = (int) Math.pow(2, n);
+        for (int i = max - 1; i >= 0; i--) {
+            if (!list.contains(Integer.toBinaryString(i))) {
+                String temp = Integer.toBinaryString(i);
+                while (temp.length() < n) {
+                    temp = "0" + temp;
+                }
+                return temp;
+            }
+        }
+        return null;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/IntersectionOfTwoArrays.java

@@ -0,0 +1,60 @@
+//给定两个数组，编写一个函数来计算它们的交集。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：nums1 = [1,2,2,1], nums2 = [2,2]
+//输出：[2]
+// 
+//
+// 示例 2： 
+//
+// 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+//输出：[9,4] 
+//
+// 
+//
+// 说明： 
+//
+// 
+// 输出结果中的每个元素一定是唯一的。 
+// 我们可以不考虑输出结果的顺序。 
+// 
+// Related Topics 数组 哈希表 双指针 二分查找 排序 👍 406 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+//349:两个数组的交集
+class IntersectionOfTwoArrays {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new IntersectionOfTwoArrays().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int[] intersection(int[] nums1, int[] nums2) {
+            Set<Integer> set = new HashSet<>();
+            for (int num : nums1) {
+                set.add(num);
+            }
+            int index = 0;
+            for (int num : nums2) {
+                if (set.contains(num)) {
+                    set.remove(num);
+                    nums1[index] = num;
+                    index++;
+                }
+            }
+            return Arrays.copyOf(nums1, index);
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/LargestNumberAfterMutatingSubstring.java

@@ -0,0 +1,86 @@
+//给你一个字符串 num ，该字符串表示一个大整数。另给你一个长度为 10 且 下标从 0 开始 的整数数组 change ，该数组将 0-9 中的每个数字映
+//射到另一个数字。更规范的说法是，数字 d 映射为数字 change[d] 。 
+//
+// 你可以选择 突变 num 的任一子字符串。突变 子字符串意味着将每位数字 num[i] 替换为该数字在 change 中的映射（也就是说，将 num[i]
+// 替换为 change[num[i]]）。 
+//
+// 请你找出在对 num 的任一子字符串执行突变操作（也可以不执行）后，可能得到的 最大整数 ，并用字符串表示返回。 
+//
+// 子字符串 是字符串中的一个连续序列。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：num = "132", change = [9,8,5,0,3,6,4,2,6,8]
+//输出："832"
+//解释：替换子字符串 "1"：
+//- 1 映射为 change[1] = 8 。
+//因此 "132" 变为 "832" 。
+//"832" 是可以构造的最大整数，所以返回它的字符串表示。
+// 
+//
+// 示例 2： 
+//
+// 输入：num = "021", change = [9,4,3,5,7,2,1,9,0,6]
+//输出："934"
+//解释：替换子字符串 "021"：
+//- 0 映射为 change[0] = 9 。
+//- 2 映射为 change[2] = 3 。
+//- 1 映射为 change[1] = 4 。
+//因此，"021" 变为 "934" 。
+//"934" 是可以构造的最大整数，所以返回它的字符串表示。 
+// 
+//
+// 示例 3： 
+//
+// 输入：num = "5", change = [1,4,7,5,3,2,5,6,9,4]
+//输出："5"
+//解释："5" 已经是可以构造的最大整数，所以返回它的字符串表示。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= num.length <= 10⁵ 
+// num 仅由数字 0-9 组成 
+// change.length == 10 
+// 0 <= change[d] <= 9 
+// 
+// Related Topics 贪心 数组 字符串 👍 5 👎 0
+
+package leetcode.editor.cn;
+//1946:子字符串突变后可能得到的最大整数
+class LargestNumberAfterMutatingSubstring{
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new LargestNumberAfterMutatingSubstring().new Solution();
+    }
+    
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public String maximumNumber(String num, int[] change) {
+        StringBuilder str = new StringBuilder();
+        int flag = 0;
+        int i = 0;
+        for (; i < num.length(); i++) {
+            int n = num.charAt(i) - '0';
+            if (n > change[n] && flag == 1) {
+                break;
+            }
+            if (n < change[n]) {
+                str.append(change[n]);
+                flag = 1;
+            }else{
+                str.append(n);
+            }
+        }
+        return str + num.substring(i);
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MaximumCompatibilityScoreSum.java

@@ -0,0 +1,99 @@
+//有一份由 n 个问题组成的调查问卷，每个问题的答案要么是 0（no，否），要么是 1（yes，是）。 
+//
+// 这份调查问卷被分发给 m 名学生和 m 名导师，学生和导师的编号都是从 0 到 m - 1 。学生的答案用一个二维整数数组 students 表示，其中 
+//students[i] 是一个整数数组，包含第 i 名学生对调查问卷给出的答案（下标从 0 开始）。导师的答案用一个二维整数数组 mentors 表示，其中 
+//mentors[j] 是一个整数数组，包含第 j 名导师对调查问卷给出的答案（下标从 0 开始）。 
+//
+// 每个学生都会被分配给 一名 导师，而每位导师也会分配到 一名 学生。配对的学生与导师之间的兼容性评分等于学生和导师答案相同的次数。 
+//
+// 
+// 例如，学生答案为[1, 0, 1] 而导师答案为 [0, 0, 1] ，那么他们的兼容性评分为 2 ，因为只有第二个和第三个答案相同。 
+// 
+//
+// 请你找出最优的学生与导师的配对方案，以 最大程度上 提高 兼容性评分和 。 
+//
+// 给你 students 和 mentors ，返回可以得到的 最大兼容性评分和 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：students = [[1,1,0],[1,0,1],[0,0,1]], mentors = [[1,0,0],[0,0,1],[1,1,0]]
+//输出：8
+//解释：按下述方式分配学生和导师：
+//- 学生 0 分配给导师 2 ，兼容性评分为 3 。
+//- 学生 1 分配给导师 0 ，兼容性评分为 2 。
+//- 学生 2 分配给导师 1 ，兼容性评分为 3 。
+//最大兼容性评分和为 3 + 2 + 3 = 8 。 
+//
+// 示例 2： 
+//
+// 输入：students = [[0,0],[0,0],[0,0]], mentors = [[1,1],[1,1],[1,1]]
+//输出：0
+//解释：任意学生与导师配对的兼容性评分都是 0 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// m == students.length == mentors.length 
+// n == students[i].length == mentors[j].length 
+// 1 <= m, n <= 8 
+// students[i][k] 为 0 或 1 
+// mentors[j][k] 为 0 或 1 
+// 
+// Related Topics 位运算 数组 动态规划 回溯 状态压缩 👍 12 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.ArrayList;
+import java.util.List;
+
+//1947:最大兼容性评分和
+class MaximumCompatibilityScoreSum {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MaximumCompatibilityScoreSum().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+
+        private int max = 0;
+
+        public int maxCompatibilitySum(int[][] students, int[][] mentors) {
+            dfs(0, students, mentors, new ArrayList<>(), 0);
+            return max;
+        }
+
+        private void dfs(int index, int[][] students, int[][] mentors, List<Integer> use, int sum) {
+            if (index == students.length) {
+                max = Math.max(max, sum);
+                return;
+            }
+            int[] student = students[index];
+            for (int i = 0; i < mentors.length; i++) {
+                if (use.contains(i)) {
+                    continue;
+                }
+                int[] mentor = mentors[i];
+                int count = 0;
+                for (int j = 0; j < student.length; j++) {
+                    if (student[j] == mentor[j]) {
+                        count++;
+                    }
+                }
+                use.add(i);
+                sum += count;
+                dfs(index + 1, students, mentors, use, sum);
+                use.remove(use.size() - 1);
+                sum -= count;
+            }
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MaximumMatrixSum.java

@@ -0,0 +1,74 @@
+//给你一个 n x n 的整数方阵 matrix 。你可以执行以下操作 任意次 ： 
+//
+// 
+// 选择 matrix 中 相邻 两个元素，并将它们都 乘以 -1 。 
+// 
+//
+// 如果两个元素有 公共边 ，那么它们就是 相邻 的。 
+//
+// 你的目的是 最大化 方阵元素的和。请你在执行以上操作之后，返回方阵的 最大 和。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：matrix = [[1,-1],[-1,1]]
+//输出：4
+//解释：我们可以执行以下操作使和等于 4 ：
+//- 将第一行的 2 个元素乘以 -1 。
+//- 将第一列的 2 个元素乘以 -1 。
+// 
+//
+// 示例 2： 
+//
+// 输入：matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]
+//输出：16
+//解释：我们可以执行以下操作使和等于 16 ：
+//- 将第二行的最后 2 个元素乘以 -1 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == matrix.length == matrix[i].length 
+// 2 <= n <= 250 
+// -10⁵ <= matrix[i][j] <= 10⁵ 
+// 
+// 👍 0 👎 0
+
+package leetcode.editor.cn;
+
+//1975:最大方阵和
+class MaximumMatrixSum {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MaximumMatrixSum().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public long maxMatrixSum(int[][] matrix) {
+            int min = Integer.MAX_VALUE;
+            long sum = 0;
+            long mul = 1;
+            int count = 0;
+            for (int[] ints : matrix) {
+                for (int j = 0; j < matrix[0].length; j++) {
+                    sum += Math.abs(ints[j]);
+                    if (ints[j] != 0) {
+                        mul = mul * ints[j] > 0 ? 1 : -1;
+                        min = Math.min(min, Math.abs(ints[j]));
+                    } else {
+                        count++;
+                    }
+                }
+            }
+            return mul < 0 && count == 0 ? sum - 2L * min : sum;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MaximumNumberOfWeeksForWhichYouCanWork.java

@@ -0,0 +1,85 @@
+//给你 n 个项目，编号从 0 到 n - 1 。同时给你一个整数数组 milestones ，其中每个 milestones[i] 表示第 i 个项目中的阶
+//段任务数量。 
+//
+// 你可以按下面两个规则参与项目中的工作： 
+//
+// 
+// 每周，你将会完成 某一个 项目中的 恰好一个 阶段任务。你每周都 必须 工作。 
+// 在 连续的 两周中，你 不能 参与并完成同一个项目中的两个阶段任务。 
+// 
+//
+// 一旦所有项目中的全部阶段任务都完成，或者仅剩余一个阶段任务都会导致你违反上面的规则，那么你将 停止工作 。注意，由于这些条件的限制，你可能无法完成所有阶段
+//任务。 
+//
+// 返回在不违反上面规则的情况下你 最多 能工作多少周。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：milestones = [1,2,3]
+//输出：6
+//解释：一种可能的情形是：
+//​​​​- 第 1 周，你参与并完成项目 0 中的一个阶段任务。
+//- 第 2 周，你参与并完成项目 2 中的一个阶段任务。
+//- 第 3 周，你参与并完成项目 1 中的一个阶段任务。
+//- 第 4 周，你参与并完成项目 2 中的一个阶段任务。
+//- 第 5 周，你参与并完成项目 1 中的一个阶段任务。
+//- 第 6 周，你参与并完成项目 2 中的一个阶段任务。
+//总周数是 6 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：milestones = [5,2,1]
+//输出：7
+//解释：一种可能的情形是：
+//- 第 1 周，你参与并完成项目 0 中的一个阶段任务。
+//- 第 2 周，你参与并完成项目 1 中的一个阶段任务。
+//- 第 3 周，你参与并完成项目 0 中的一个阶段任务。
+//- 第 4 周，你参与并完成项目 1 中的一个阶段任务。
+//- 第 5 周，你参与并完成项目 0 中的一个阶段任务。
+//- 第 6 周，你参与并完成项目 2 中的一个阶段任务。
+//- 第 7 周，你参与并完成项目 0 中的一个阶段任务。
+//总周数是 7 。
+//注意，你不能在第 8 周参与完成项目 0 中的最后一个阶段任务，因为这会违反规则。
+//因此，项目 0 中会有一个阶段任务维持未完成状态。 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == milestones.length 
+// 1 <= n <= 10⁵ 
+// 1 <= milestones[i] <= 10⁹ 
+// 
+// Related Topics 贪心 数组 👍 19 👎 0
+
+package leetcode.editor.cn;
+
+//1953:你可以工作的最大周数
+class MaximumNumberOfWeeksForWhichYouCanWork {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MaximumNumberOfWeeksForWhichYouCanWork().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public long numberOfWeeks(int[] milestones) {
+            long max = 0;
+            long sum = 0;
+            for (int milestone : milestones) {
+                sum += milestone;
+                max = Math.max(max, milestone);
+            }
+            return sum / max >= 2 ? sum : (sum - max) * 2 + 1;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MaximumProductDifferenceBetweenTwoPairs.java

@@ -0,0 +1,62 @@
+//两个数对 (a, b) 和 (c, d) 之间的 乘积差 定义为 (a * b) - (c * d) 。 
+//
+// 
+// 例如，(5, 6) 和 (2, 7) 之间的乘积差是 (5 * 6) - (2 * 7) = 16 。 
+// 
+//
+// 给你一个整数数组 nums ，选出四个 不同的 下标 w、x、y 和 z ，使数对 (nums[w], nums[x]) 和 (nums[y], 
+//nums[z]) 之间的 乘积差 取到 最大值 。 
+//
+// 返回以这种方式取得的乘积差中的 最大值 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：nums = [5,6,2,7,4]
+//输出：34
+//解释：可以选出下标为 1 和 3 的元素构成第一个数对 (6, 7) 以及下标 2 和 4 构成第二个数对 (2, 4)
+//乘积差是 (6 * 7) - (2 * 4) = 34
+// 
+//
+// 示例 2： 
+//
+// 输入：nums = [4,2,5,9,7,4,8]
+//输出：64
+//解释：可以选出下标为 3 和 6 的元素构成第一个数对 (9, 8) 以及下标 1 和 5 构成第二个数对 (2, 4)
+//乘积差是 (9 * 8) - (2 * 4) = 64
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 4 <= nums.length <= 10⁴ 
+// 1 <= nums[i] <= 10⁴ 
+// 
+// Related Topics 数组 排序 👍 8 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+
+//1913:两个数对之间的最大乘积差
+class MaximumProductDifferenceBetweenTwoPairs {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MaximumProductDifferenceBetweenTwoPairs().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int maxProductDifference(int[] nums) {
+            Arrays.sort(nums);
+            int size = nums.length;
+            return nums[size - 1] * nums[size - 2] - nums[0] * nums[1];
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MinimumGardenPerimeterToCollectEnoughApples.java

@@ -0,0 +1,81 @@
+//给你一个用无限二维网格表示的花园，每一个 整数坐标处都有一棵苹果树。整数坐标 (i, j) 处的苹果树有 |i| + |j| 个苹果。 
+//
+// 你将会买下正中心坐标是 (0, 0) 的一块 正方形土地 ，且每条边都与两条坐标轴之一平行。 
+//
+// 给你一个整数 neededApples ，请你返回土地的 最小周长 ，使得 至少 有 neededApples 个苹果在土地 里面或者边缘上。 
+//
+// |x| 的值定义为： 
+//
+// 
+// 如果 x >= 0 ，那么值为 x 
+// 如果 x < 0 ，那么值为 -x 
+// 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：neededApples = 1
+//输出：8
+//解释：边长长度为 1 的正方形不包含任何苹果。
+//但是边长为 2 的正方形包含 12 个苹果（如上图所示）。
+//周长为 2 * 4 = 8 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：neededApples = 13
+//输出：16
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：neededApples = 1000000000
+//输出：5040
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= neededApples <= 10¹⁵ 
+// 
+// Related Topics 数学 二分查找 👍 11 👎 0
+
+package leetcode.editor.cn;
+
+//1954:收集足够苹果的最小花园周长
+class MinimumGardenPerimeterToCollectEnoughApples {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MinimumGardenPerimeterToCollectEnoughApples().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public long minimumPerimeter(long neededApples) {
+            if (neededApples == 0) {
+                return 0;
+            }
+            if (neededApples < 12) {
+                return 8;
+            }
+            long n = 2;
+            long cur = 12;
+            long sum = 12;
+            while (sum < neededApples) {
+                cur = cur + 12 * (n + 1);
+                sum += cur;
+                n += 2;
+            }
+            return 4 * n;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MinimumTimeToTypeWordUsingSpecialTypewriter.java

@@ -0,0 +1,97 @@
+//有一个特殊打字机，它由一个 圆盘 和一个 指针 组成， 圆盘上标有小写英文字母 'a' 到 'z'。只有 当指针指向某个字母时，它才能被键入。指针 初始时 
+//指向字符 'a' 。 
+//
+// 每一秒钟，你可以执行以下操作之一： 
+//
+// 
+// 将指针 顺时针 或者 逆时针 移动一个字符。 
+// 键入指针 当前 指向的字符。 
+// 
+//
+// 给你一个字符串 word ，请你返回键入 word 所表示单词的 最少 秒数 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：word = "abc"
+//输出：5
+//解释：
+//单词按如下操作键入：
+//- 花 1 秒键入字符 'a' in 1 ，因为指针初始指向 'a' ，故不需移动指针。
+//- 花 1 秒将指针顺时针移到 'b' 。
+//- 花 1 秒键入字符 'b' 。
+//- 花 1 秒将指针顺时针移到 'c' 。
+//- 花 1 秒键入字符 'c' 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：word = "bza"
+//输出：7
+//解释：
+//单词按如下操作键入：
+//- 花 1 秒将指针顺时针移到 'b' 。
+//- 花 1 秒键入字符 'b' 。
+//- 花 2 秒将指针逆时针移到 'z' 。
+//- 花 1 秒键入字符 'z' 。
+//- 花 1 秒将指针顺时针移到 'a' 。
+//- 花 1 秒键入字符 'a' 。
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：word = "zjpc"
+//输出：34
+//解释：
+//单词按如下操作键入：
+//- 花 1 秒将指针逆时针移到 'z' 。
+//- 花 1 秒键入字符 'z' 。
+//- 花 10 秒将指针顺时针移到 'j' 。
+//- 花 1 秒键入字符 'j' 。
+//- 花 6 秒将指针顺时针移到 'p' 。
+//- 花 1 秒键入字符 'p' 。
+//- 花 13 秒将指针逆时针移到 'c' 。
+//- 花 1 秒键入字符 'c' 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= word.length <= 100 
+// word 只包含小写英文字母。 
+// 
+// 👍 2 👎 0
+
+package leetcode.editor.cn;
+
+//1974:使用特殊打字机键入单词的最少时间
+class MinimumTimeToTypeWordUsingSpecialTypewriter {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new MinimumTimeToTypeWordUsingSpecialTypewriter().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int minTimeToType(String word) {
+            int time = 0;
+            char[] chs = word.toCharArray();
+            time += chs.length;
+            time += Math.min(26 - Math.abs(chs[0] - 'a'), Math.abs(chs[0] - 'a'));
+            for (int i = 1; i < chs.length; i++) {
+                int abs = Math.abs(chs[i] - chs[i - 1]);
+                time += Math.min(26 - abs, abs);
+            }
+            return time;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/MovingAverageFromDataStream.java

@@ -0,0 +1,89 @@
+//给定一个整数数据流和一个窗口大小，根据该滑动窗口的大小，计算其所有整数的移动平均值。 
+//
+// 实现 MovingAverage 类： 
+//
+// 
+// MovingAverage(int size) 用窗口大小 size 初始化对象。 
+// double next(int val) 计算并返回数据流中最后 size 个值的移动平均值。 
+// 
+//
+// 
+//
+// 示例： 
+//
+// 
+//输入：
+//["MovingAverage", "next", "next", "next", "next"]
+//[[3], [1], [10], [3], [5]]
+//输出：
+//[null, 1.0, 5.5, 4.66667, 6.0]
+//
+//解释：
+//MovingAverage movingAverage = new MovingAverage(3);
+//movingAverage.next(1); // 返回 1.0 = 1 / 1
+//movingAverage.next(10); // 返回 5.5 = (1 + 10) / 2
+//movingAverage.next(3); // 返回 4.66667 = (1 + 10 + 3) / 3
+//movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= size <= 1000 
+// -10⁵ <= val <= 10⁵ 
+// 最多调用 next 方法 10⁴ 次 
+// 
+// Related Topics 设计 队列 数组 数据流 👍 66 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+//346:数据流中的移动平均值
+class MovingAverageFromDataStream {
+    public static void main(String[] args) {
+        //测试代码
+//        Solution solution = new MovingAverageFromDataStream().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class MovingAverage {
+        Queue<Integer> queue;
+        int size;
+        double sum = 0.0;
+
+        /**
+         * Initialize your data structure here.
+         */
+        public MovingAverage(int size) {
+            queue = new LinkedList<>();
+            this.size = size;
+        }
+
+        public double next(int val) {
+            if (queue.size() >= size) {
+                sum += 1.0 * (val - queue.poll()) / size;
+            } else {
+                if (queue.isEmpty()) {
+                    sum += val;
+                } else {
+                    sum = (sum * queue.size() + val) / (queue.size() + 1);
+                }
+            }
+            queue.offer(val);
+            return sum;
+        }
+    }
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * MovingAverage obj = new MovingAverage(size);
+ * double param_1 = obj.next(val);
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/PowxN.java

@@ -0,0 +1,36 @@
+//实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x⁴
+//
+// Related Topics 递归 数学 👍 718 👎 0
+
+package leetcode.editor.cn;
+
+//50:Pow(x, n)
+class PowxN {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new PowxN().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public double myPow(double x, int n) {
+            double ans = 1;
+            if (n < 0) {
+                x = 1 / x;
+            }
+            long exp = n;
+            exp = Math.abs(exp);
+            while (exp > 0) {
+                if (exp % 2 == 1) {
+                    ans = ans * x;
+                }
+                x *= x;
+                exp /= 2;
+            }
+            return ans;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/RedistributeCharactersToMakeAllStringsEqual.java

@@ -0,0 +1,67 @@
+//给你一个字符串数组 words（下标 从 0 开始 计数）。 
+//
+// 在一步操作中，需先选出两个 不同 下标 i 和 j，其中 words[i] 是一个非空字符串，接着将 words[i] 中的 任一 字符移动到 
+//words[j] 中的 任一 位置上。 
+//
+// 如果执行任意步操作可以使 words 中的每个字符串都相等，返回 true ；否则，返回 false 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：words = ["abc","aabc","bc"]
+//输出：true
+//解释：将 words[1] 中的第一个 'a' 移动到 words[2] 的最前面。
+//使 words[1] = "abc" 且 words[2] = "abc" 。
+//所有字符串都等于 "abc" ，所以返回 true 。
+// 
+//
+// 示例 2： 
+//
+// 输入：words = ["ab","a"]
+//输出：false
+//解释：执行操作无法使所有字符串都相等。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= words.length <= 100 
+// 1 <= words[i].length <= 100 
+// words[i] 由小写英文字母组成 
+// 
+// Related Topics 哈希表 字符串 计数 👍 4 👎 0
+
+package leetcode.editor.cn;
+
+//1897:重新分配字符使所有字符串都相等
+class RedistributeCharactersToMakeAllStringsEqual {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new RedistributeCharactersToMakeAllStringsEqual().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public boolean makeEqual(String[] words) {
+            int[] count = new int[26];
+            int size = words.length;
+            for (String word : words) {
+                for (char ch : word.toCharArray()) {
+                    count[ch - 'a']++;
+                }
+            }
+            for (int i = 0; i < 26; i++) {
+                if (count[i] % size > 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/SumOfDigitsOfStringAfterConvert.java

@@ -0,0 +1,94 @@
+//给你一个由小写字母组成的字符串 s ，以及一个整数 k 。 
+//
+// 首先，用字母在字母表中的位置替换该字母，将 s 转化 为一个整数（也就是，'a' 用 1 替换，'b' 用 2 替换，... 'z' 用 26 替换）。接
+//着，将整数 转换 为其 各位数字之和 。共重复 转换 操作 k 次 。 
+//
+// 例如，如果 s = "zbax" 且 k = 2 ，那么执行下述步骤后得到的结果是整数 8 ： 
+//
+// 
+// 转化："zbax" ➝ "(26)(2)(1)(24)" ➝ "262124" ➝ 262124 
+// 转换 #1：262124 ➝ 2 + 6 + 2 + 1 + 2 + 4 ➝ 17 
+// 转换 #2：17 ➝ 1 + 7 ➝ 8 
+// 
+//
+// 返回执行上述操作后得到的结果整数。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：s = "iiii", k = 1
+//输出：36
+//解释：操作如下：
+//- 转化："iiii" ➝ "(9)(9)(9)(9)" ➝ "9999" ➝ 9999
+//- 转换 #1：9999 ➝ 9 + 9 + 9 + 9 ➝ 36
+//因此，结果整数为 36 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：s = "leetcode", k = 2
+//输出：6
+//解释：操作如下：
+//- 转化："leetcode" ➝ "(12)(5)(5)(20)(3)(15)(4)(5)" ➝ "12552031545" ➝ 12552031545
+//- 转换 #1：12552031545 ➝ 1 + 2 + 5 + 5 + 2 + 0 + 3 + 1 + 5 + 4 + 5 ➝ 33
+//- 转换 #2：33 ➝ 3 + 3 ➝ 6
+//因此，结果整数为 6 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= s.length <= 100 
+// 1 <= k <= 10 
+// s 由小写英文字母组成 
+// 
+// Related Topics 字符串 模拟 👍 4 👎 0
+
+package leetcode.editor.cn;
+
+//1945:字符串转化后的各位数字之和
+class SumOfDigitsOfStringAfterConvert {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new SumOfDigitsOfStringAfterConvert().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int getLucky(String s, int k) {
+            int sum = 0;
+            int count = 0;
+            for (char ch : s.toCharArray()) {
+                int num = ch - 'a' + 1;
+                if (num > 9) {
+                    sum += num / 10 + num % 10;
+                } else {
+                    sum += num;
+                }
+            }
+            if (sum < 10 || k == 1) {
+                return sum;
+            }
+            for (int i = 1; i < k; i++) {
+                int result = 0;
+                while (sum > 9) {
+                    result += sum % 10;
+                    sum /= 10;
+                }
+                sum += result;
+                if (sum < 10) {
+                    break;
+                }
+            }
+            return sum;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/TheKWeakestRowsInAMatrix.java

@@ -0,0 +1,103 @@
+//给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。 
+//
+// 请你返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。 
+//
+// 如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。 
+//
+// 军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：mat = 
+//[[1,1,0,0,0],
+// [1,1,1,1,0],
+// [1,0,0,0,0],
+// [1,1,0,0,0],
+// [1,1,1,1,1]], 
+//k = 3
+//输出：[2,0,3]
+//解释：
+//每行中的军人数目：
+//行 0 -> 2 
+//行 1 -> 4 
+//行 2 -> 1 
+//行 3 -> 2 
+//行 4 -> 5 
+//从最弱到最强对这些行排序后得到 [2,0,3,1,4]
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：mat = 
+//[[1,0,0,0],
+// [1,1,1,1],
+// [1,0,0,0],
+// [1,0,0,0]], 
+//k = 2
+//输出：[0,2]
+//解释： 
+//每行中的军人数目：
+//行 0 -> 1 
+//行 1 -> 4 
+//行 2 -> 1 
+//行 3 -> 1 
+//从最弱到最强对这些行排序后得到 [0,2,3,1]
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// m == mat.length 
+// n == mat[i].length 
+// 2 <= n, m <= 100 
+// 1 <= k <= m 
+// matrix[i][j] 不是 0 就是 1 
+// 
+// Related Topics 数组 二分查找 矩阵 排序 堆（优先队列） 👍 120 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.Arrays;
+
+//1337:矩阵中战斗力最弱的 K 行
+class TheKWeakestRowsInAMatrix {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new TheKWeakestRowsInAMatrix().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int[] kWeakestRows(int[][] mat, int k) {
+            int m = mat.length, n = mat[0].length;
+            int[][] all = new int[m][2];
+            for (int i = 0; i < m; i++) {
+                int cur = 0;
+                for (int j = 0; j < n; j++) {
+                    cur += mat[i][j];
+                }
+                all[i] = new int[]{cur, i};
+            }
+            Arrays.sort(all, (a, b) -> {
+                if (a[0] != b[0]) {
+                    return a[0] - b[0];
+                }
+                return a[1] - b[1];
+            });
+            int[] ans = new int[k];
+            for (int i = 0; i < k; i++) {
+                ans[i] = all[i][1];
+            }
+            return ans;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/TheNumberOfTheSmallestUnoccupiedChair.java

@@ -0,0 +1,113 @@
+//有 n 个朋友在举办一个派对，这些朋友从 0 到 n - 1 编号。派对里有 无数 张椅子，编号为 0 到 infinity 。当一个朋友到达派对时，他会占
+//据 编号最小 且未被占据的椅子。 
+//
+// 
+// 比方说，当一个朋友到达时，如果椅子 0 ，1 和 5 被占据了，那么他会占据 2 号椅子。 
+// 
+//
+// 当一个朋友离开派对时，他的椅子会立刻变成未占据状态。如果同一时刻有另一个朋友到达，可以立即占据这张椅子。 
+//
+// 给你一个下标从 0 开始的二维整数数组 times ，其中 times[i] = [arrivali, leavingi] 表示第 i 个朋友到达和离开的
+//时刻，同时给你一个整数 targetFriend 。所有到达时间 互不相同 。 
+//
+// 请你返回编号为 targetFriend 的朋友占据的 椅子编号 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：times = [[1,4],[2,3],[4,6]], targetFriend = 1
+//输出：1
+//解释：
+//- 朋友 0 时刻 1 到达，占据椅子 0 。
+//- 朋友 1 时刻 2 到达，占据椅子 1 。
+//- 朋友 1 时刻 3 离开，椅子 1 变成未占据。
+//- 朋友 0 时刻 4 离开，椅子 0 变成未占据。
+//- 朋友 2 时刻 4 到达，占据椅子 0 。
+//朋友 1 占据椅子 1 ，所以返回 1 。
+// 
+//
+// 示例 2： 
+//
+// 输入：times = [[3,10],[1,5],[2,6]], targetFriend = 0
+//输出：2
+//解释：
+//- 朋友 1 时刻 1 到达，占据椅子 0 。
+//- 朋友 2 时刻 2 到达，占据椅子 1 。
+//- 朋友 0 时刻 3 到达，占据椅子 2 。
+//- 朋友 1 时刻 5 离开，椅子 0 变成未占据。
+//- 朋友 2 时刻 6 离开，椅子 1 变成未占据。
+//- 朋友 0 时刻 10 离开，椅子 2 变成未占据。
+//朋友 0 占据椅子 2 ，所以返回 2 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == times.length 
+// 2 <= n <= 10⁴ 
+// times[i].length == 2 
+// 1 <= arrivali < leavingi <= 10⁵ 
+// 0 <= targetFriend <= n - 1 
+// 每个 arrivali 时刻 互不相同 。 
+// 
+// Related Topics 数组 有序集合 堆（优先队列） 👍 9 👎 0
+
+package leetcode.editor.cn;
+
+import java.util.*;
+
+//1942:最小未被占据椅子的编号
+class TheNumberOfTheSmallestUnoccupiedChair {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new TheNumberOfTheSmallestUnoccupiedChair().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int smallestChair(int[][] times, int targetFriend) {
+            int[] target = times[targetFriend];
+            Arrays.sort(times, (a, b) -> a[0] - b[0]);
+            int size = 0;
+            for (int i = 0; i < times.length; i++) {
+                if (times[i][0] == target[0]) {
+                    size = i;
+                    break;
+                }
+            }
+            int[] arr = new int[size + 1];
+            List<Integer> use = new ArrayList<>();
+            int index = 0;
+            int start = times[0][0];
+            for (int[] time : times) {
+                for (int i = 0; i < index; i++) {
+                    if (arr[i] > 0) {
+                        arr[i] -= time[0] - start;
+                        if (arr[i] <= 0) {
+                            use.add(i);
+                            Collections.sort(use);
+                        }
+                    }
+                }
+                start = time[0];
+                if (time[0] == target[0]) {
+                    return use.size() > 0 ? use.get(0) : index;
+                }
+                if (use.size() > 0) {
+                    arr[use.get(0)] = time[1] - time[0];
+                    use.remove(0);
+                } else {
+                    arr[index] = time[1] - time[0];
+                    index++;
+                }
+            }
+            return 0;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/ThreeDivisors.java

@@ -0,0 +1,60 @@
+//给你一个整数 n 。如果 n 恰好有三个正除数 ，返回 true ；否则，返回 false 。 
+//
+// 如果存在整数 k ，满足 n = k * m ，那么整数 m 就是 n 的一个 除数 。 
+//
+// 
+//
+// 示例 1： 
+//
+// 输入：n = 2
+//输出：false
+//解释：2 只有两个除数：1 和 2 。 
+//
+// 示例 2： 
+//
+// 输入：n = 4
+//输出：true
+//解释：4 有三个除数：1、2 和 4 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= n <= 10⁴ 
+// 
+// Related Topics 数学 👍 9 👎 0
+
+package leetcode.editor.cn;
+
+//1952:三除数
+class ThreeDivisors {
+    public static void main(String[] args) {
+        //测试代码
+        Solution solution = new ThreeDivisors().new Solution();
+    }
+
+    //力扣代码
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public boolean isThree(int n) {
+            int flag = 0;
+            if (n <= 2) {
+                return false;
+            }
+            int num = n / 2;
+            for (int i = 2; i <= num; i++) {
+                if (n % i == 0) {
+                    if (flag == 1) {
+                        return false;
+                    }
+                    flag = 1;
+                }
+            }
+            return flag == 1;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/doc/content/AddTwoNumbersIi.md

@@ -0,0 +1,43 @@
+<p>给你两个 <strong>非空 </strong>链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。</p>
+
+<p>你可以假设除了数字 0 之外，这两个数字都不会以零开头。</p>
+
+<p> </p>
+
+<p><strong>示例1：</strong></p>
+
+<p><img alt="" src="https://pic.leetcode-cn.com/1626420025-fZfzMX-image.png" style="width: 302px; " /></p>
+
+<pre>
+<strong>输入：</strong>l1 = [7,2,4,3], l2 = [5,6,4]
+<strong>输出：</strong>[7,8,0,7]
+</pre>
+
+<p><strong>示例2：</strong></p>
+
+<pre>
+<strong>输入：</strong>l1 = [2,4,3], l2 = [5,6,4]
+<strong>输出：</strong>[8,0,7]
+</pre>
+
+<p><strong>示例3：</strong></p>
+
+<pre>
+<strong>输入：</strong>l1 = [0], l2 = [0]
+<strong>输出：</strong>[0]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>链表的长度范围为<code> [1, 100]</code></li>
+	<li><code>0 <= node.val <= 9</code></li>
+	<li>输入数据保证链表代表的数字无前导 0</li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>如果输入链表不能修改该如何处理？换句话说，不能对列表中的节点进行翻转。</p>
+<div><div>Related Topics</div><div><li>栈</li><li>链表</li><li>数学</li></div></div><br><div><li>👍 414</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/AllPathsFromSourceToTarget.md

@@ -0,0 +1,61 @@
+<p>给你一个有&nbsp;<code>n</code>&nbsp;个节点的 <strong>有向无环图（DAG）</strong>，请你找出所有从节点 <code>0</code>&nbsp;到节点 <code>n-1</code>&nbsp;的路径并输出（<strong>不要求按特定顺序</strong>）</p>
+
+<p>二维数组的第 <code>i</code> 个数组中的单元都表示有向图中 <code>i</code> 号节点所能到达的下一些节点，空就是没有下一个结点了。</p>
+
+<p>译者注：有向图是有方向的，即规定了 a→b 你就不能从 b→a 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_1.jpg" style="height: 242px; width: 242px;" /></p>
+
+<pre>
+<strong>输入：</strong>graph = [[1,2],[3],[3],[]]
+<strong>输出：</strong>[[0,1,3],[0,2,3]]
+<strong>解释：</strong>有两条路径 0 -&gt; 1 -&gt; 3 和 0 -&gt; 2 -&gt; 3
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_2.jpg" style="height: 301px; width: 423px;" /></p>
+
+<pre>
+<strong>输入：</strong>graph = [[4,3,1],[3,2,4],[3],[4],[]]
+<strong>输出：</strong>[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>graph = [[1],[]]
+<strong>输出：</strong>[[0,1]]
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>graph = [[1,2,3],[2],[3],[]]
+<strong>输出：</strong>[[0,1,2,3],[0,2,3],[0,3]]
+</pre>
+
+<p><strong>示例 5：</strong></p>
+
+<pre>
+<strong>输入：</strong>graph = [[1,3],[2],[3],[]]
+<strong>输出：</strong>[[0,1,2,3],[0,3]]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == graph.length</code></li>
+	<li><code>2 &lt;= n &lt;= 15</code></li>
+	<li><code>0 &lt;= graph[i][j] &lt; n</code></li>
+	<li><code>graph[i][j] != i</code>（即，不存在自环）</li>
+	<li><code>graph[i]</code> 中的所有元素 <strong>互不相同</strong></li>
+	<li>保证输入为 <strong>有向无环图（DAG）</strong></li>
+</ul>
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>图</li><li>回溯</li></div></div><br><div><li>👍 143</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/AsteroidCollision.md

@@ -0,0 +1,46 @@
+<p>给定一个整数数组 <code>asteroids</code>，表示在同一行的行星。</p>
+
+<p>对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。</p>
+
+<p>找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>asteroids = [5,10,-5]
+<strong>输出：</strong>[5,10]
+<b>解释：</b>10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>asteroids = [8,-8]
+<strong>输出：</strong>[]
+<b>解释：</b>8 和 -8 碰撞后，两者都发生爆炸。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>asteroids = [10,2,-5]
+<strong>输出：</strong>[10]
+<b>解释：</b>2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>asteroids = [-2,-1,1,2]
+<strong>输出：</strong>[-2,-1,1,2]
+<b>解释</b><strong>：</strong>-2 和 -1 向左移动，而 1 和 2 向右移动。 由于移动方向相同的行星不会发生碰撞，所以最终没有行星发生碰撞。 </pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 <= asteroids.length <= 10<sup>4</sup></code></li>
+	<li><code>-1000 <= asteroids[i] <= 1000</code></li>
+	<li><code>asteroids[i] != 0</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>栈</li><li>数组</li></div></div><br><div><li>👍 163</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/BitwiseAndOfNumbersRange.md

@@ -0,0 +1,33 @@
+<p>给你两个整数 <code>left</code> 和 <code>right</code> ，表示区间 <code>[left, right]</code> ，返回此区间内所有数字 <strong>按位与</strong> 的结果（包含 <code>left</code> 、<code>right</code> 端点）。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>left = 5, right = 7
+<strong>输出：</strong>4
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>left = 0, right = 0
+<strong>输出：</strong>0
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>left = 1, right = 2147483647
+<strong>输出：</strong>0
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 <= left <= right <= 2<sup>31</sup> - 1</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>位运算</li></div></div><br><div><li>👍 309</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/BuildArrayFromPermutation.md

@@ -0,0 +1,34 @@
+<p>给你一个 <strong>从 0 开始的排列</strong> <code>nums</code>（<strong>下标也从 0 开始</strong>）。请你构建一个 <strong>同样长度</strong> 的数组 <code>ans</code> ，其中，对于每个 <code>i</code>（<code>0 &lt;= i &lt; nums.length</code>），都满足 <code>ans[i] = nums[nums[i]]</code> 。返回构建好的数组 <code>ans</code> 。</p>
+
+<p><strong>从 0 开始的排列</strong> <code>nums</code> 是一个由 <code>0</code> 到 <code>nums.length - 1</code>（<code>0</code> 和 <code>nums.length - 1</code> 也包含在内）的不同整数组成的数组。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>nums = [0,2,1,5,3,4]
+<strong>输出：</strong>[0,1,2,4,5,3]<strong>
+解释：</strong>数组 ans 构建如下：
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+    = [0,1,2,4,5,3]</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>nums = [5,0,1,2,3,4]
+<strong>输出：</strong>[4,5,0,1,2,3]
+<strong>解释：</strong>数组 ans 构建如下：
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+    = [4,5,0,1,2,3]</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
+	<li><code>nums</code> 中的元素 <strong>互不相同</strong></li>
+</ul>
+<div><div>Related Topics</div><div><li>数组</li><li>模拟</li></div></div><br><div><li>👍 2</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/CheckIfAllCharactersHaveEqualNumberOfOccurrences.md

@@ -0,0 +1,30 @@
+<p>给你一个字符串 <code>s</code> ，如果 <code>s</code> 是一个 <strong>好</strong> 字符串，请你返回 <code>true</code> ，否则请返回 <code>false</code> 。</p>
+
+<p>如果 <code>s</code> 中出现过的 <strong>所有</strong> 字符的出现次数 <strong>相同</strong> ，那么我们称字符串 <code>s</code> 是 <strong>好</strong> 字符串。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><b>输入：</b>s = "abacbc"
+<b>输出：</b>true
+<b>解释：</b>s 中出现过的字符为 'a'，'b' 和 'c' 。s 中所有字符均出现 2 次。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><b>输入：</b>s = "aaabb"
+<b>输出：</b>false
+<b>解释：</b>s 中出现过的字符为 'a' 和 'b' 。
+'a' 出现了 3 次，'b' 出现了 2 次，两者出现次数不同。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>s</code> 只包含小写英文字母。</li>
+</ul>
+<div><div>Related Topics</div><div><li>哈希表</li><li>字符串</li><li>计数</li></div></div><br><div><li>👍 0</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/CloneGraph.md

@@ -0,0 +1,70 @@
+<p>给你无向&nbsp;<strong><a href="https://baike.baidu.com/item/连通图/6460995?fr=aladdin" target="_blank">连通</a>&nbsp;</strong>图中一个节点的引用，请你返回该图的&nbsp;<a href="https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin" target="_blank"><strong>深拷贝</strong></a>（克隆）。</p>
+
+<p>图中的每个节点都包含它的值 <code>val</code>（<code>int</code>） 和其邻居的列表（<code>list[Node]</code>）。</p>
+
+<pre>class Node {
+    public int val;
+    public List&lt;Node&gt; neighbors;
+}</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>测试用例格式：</strong></p>
+
+<p>简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（<code>val = 1</code>），第二个节点值为 2（<code>val = 2</code>），以此类推。该图在测试用例中使用邻接列表表示。</p>
+
+<p><strong>邻接列表</strong> 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。</p>
+
+<p>给定节点将始终是图中的第一个节点（值为 1）。你必须将&nbsp;<strong>给定节点的拷贝&nbsp;</strong>作为对克隆图的引用返回。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/133_clone_graph_question.png" style="height: 500px; width: 500px;"></p>
+
+<pre><strong>输入：</strong>adjList = [[2,4],[1,3],[2,4],[1,3]]
+<strong>输出：</strong>[[2,4],[1,3],[2,4],[1,3]]
+<strong>解释：
+</strong>图中有 4 个节点。
+节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
+节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
+节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
+节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph.png" style="height: 148px; width: 163px;"></p>
+
+<pre><strong>输入：</strong>adjList = [[]]
+<strong>输出：</strong>[[]]
+<strong>解释：</strong>输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>adjList = []
+<strong>输出：</strong>[]
+<strong>解释：</strong>这个图是空的，它不含任何节点。
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph-1.png" style="height: 133px; width: 272px;"></p>
+
+<pre><strong>输入：</strong>adjList = [[2],[1]]
+<strong>输出：</strong>[[2],[1]]</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li>节点数不超过 100 。</li>
+	<li>每个节点值&nbsp;<code>Node.val</code> 都是唯一的，<code>1 &lt;= Node.val &lt;= 100</code>。</li>
+	<li>无向图是一个<a href="https://baike.baidu.com/item/简单图/1680528?fr=aladdin" target="_blank">简单图</a>，这意味着图中没有重复的边，也没有自环。</li>
+	<li>由于图是无向的，如果节点 <em>p</em> 是节点 <em>q</em> 的邻居，那么节点 <em>q</em> 也必须是节点 <em>p</em>&nbsp;的邻居。</li>
+	<li>图是连通图，你可以从给定节点访问到所有节点。</li>
+</ol>
+<div><div>Related Topics</div><div><li>深度优先搜索</li><li>广度优先搜索</li><li>图</li><li>哈希表</li></div></div><br><div><li>👍 393</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/CombinationSumIi.md

@@ -0,0 +1,40 @@
+<p>给定一个数组 <code>candidates</code> 和一个目标数 <code>target</code> ，找出 <code>candidates</code> 中所有可以使数字和为 <code>target</code> 的组合。</p>
+
+<p><code>candidates</code> 中的每个数字在每个组合中只能使用一次。</p>
+
+<p><strong>注意：</strong>解集不能包含重复的组合。 </p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> candidates = <code>[10,1,2,7,6,1,5]</code>, target = <code>8</code>,
+<strong>输出:</strong>
+[
+[1,1,6],
+[1,2,5],
+[1,7],
+[2,6]
+]</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> candidates = [2,5,2,1,2], target = 5,
+<strong>输出:</strong>
+[
+[1,2,2],
+[5]
+]</pre>
+
+<p> </p>
+
+<p><strong>提示:</strong></p>
+
+<ul>
+	<li><code>1 <= candidates.length <= 100</code></li>
+	<li><code>1 <= candidates[i] <= 50</code></li>
+	<li><code>1 <= target <= 30</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>数组</li><li>回溯</li></div></div><br><div><li>👍 668</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/CongWeiDaoTouDaYinLianBiaoLcof.md

@@ -0,0 +1,15 @@
+<p>输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>head = [1,3,2]
+<strong>输出：</strong>[2,3,1]</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>限制：</strong></p>
+
+<p><code>0 &lt;= 链表长度 &lt;= 10000</code></p>
+<div><div>Related Topics</div><div><li>栈</li><li>递归</li><li>链表</li><li>双指针</li></div></div><br><div><li>👍 173</li><li>👎 0</li></div>

src/main/java/leetcode/editor/cn/doc/content/CountSquareSumTriples.md

@@ -0,0 +1,28 @@
+<p>一个 <strong>平方和三元组</strong> <code>(a,b,c)</code> 指的是满足 <code>a<sup>2</sup> + b<sup>2</sup> = c<sup>2</sup></code> 的 <strong>整数 </strong>三元组 <code>a</code>，<code>b</code> 和 <code>c</code> 。</p>
+
+<p>给你一个整数 <code>n</code> ，请你返回满足<em> </em><code>1 &lt;= a, b, c &lt;= n</code> 的 <strong>平方和三元组</strong> 的数目。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><b>输入：</b>n = 5
+<b>输出：</b>2
+<b>解释：</b>平方和三元组为 (3,4,5) 和 (4,3,5) 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><b>输入：</b>n = 10
+<b>输出：</b>4
+<b>解释：</b>平方和三元组为 (3,4,5)，(4,3,5)，(6,8,10) 和 (8,6,10) 。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 250</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>数学</li><li>枚举</li></div></div><br><div><li>👍 5</li><li>👎 0</li></div>