From 18953dee9757abf07487ae36691e4133fc61df17 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 20 Feb 2023 10:31:02 +0800 Subject: [PATCH 001/373] =?UTF-8?q?Create=201792.=20=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E5=B9=B3=E5=9D=87=E9=80=9A=E8=BF=87=E7=8E=87.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...07\351\200\232\350\277\207\347\216\207.md" | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 "Priority Queue/1792. \346\234\200\345\244\247\345\271\263\345\235\207\351\200\232\350\277\207\347\216\207.md" diff --git "a/Priority Queue/1792. \346\234\200\345\244\247\345\271\263\345\235\207\351\200\232\350\277\207\347\216\207.md" "b/Priority Queue/1792. \346\234\200\345\244\247\345\271\263\345\235\207\351\200\232\350\277\207\347\216\207.md" new file mode 100644 index 0000000..619df91 --- /dev/null +++ "b/Priority Queue/1792. \346\234\200\345\244\247\345\271\263\345\235\207\351\200\232\350\277\207\347\216\207.md" @@ -0,0 +1,75 @@ +#### 1792. 最大平均通过率 + +难度：中等 + +--- + +一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试。给你一个二维数组 `classes` ，其中 `classes[i] = [passi, totali]` ，表示你提前知道了第 `i` 个班级总共有 `totali` 个学生，其中只有 `passi` 个学生可以通过考试。 + +给你一个整数 `extraStudents` ，表示额外有 `extraStudents` 个聪明的学生，他们 **一定**  能通过任何班级的期末考。你需要给这 `extraStudents` 个学生每人都安排一个班级，使得 **所有**  班级的 **平均**  通过率 **最大**  。 + +一个班级的  **通过率**  等于这个班级通过考试的学生人数除以这个班级的总人数。 **平均通过率**  是所有班级的通过率之和除以班级数目。 + +请你返回在安排这 `extraStudents` 个学生去对应班级后的 **最大**  平均通过率。与标准答案误差范围在 `10^-5` 以内的结果都会视为正确结果。 + + **示例 1：** + +``` +输入：classes = [[1,2],[3,5],[2,2]], extraStudents = 2 +输出：0.78333 +解释：你可以将额外的两个学生都安排到第一个班级，平均通过率为 (3/4 + 3/5 + 2/2) / 3 = 0.78333 。 +``` + + **示例 2：** + +``` +输入：classes = [[2,4],[3,9],[4,5],[2,10]], extraStudents = 4 +输出：0.53485 +``` + + **提示：** + +* `1 <= classes.length <= 10^5` +* `classes[i].length == 2` +* `1 <= passi <= totali <= 10^5` +* `1 <= extraStudents <= 10^5` + +--- + +优先队列（增量大顶堆）： + +计算 `classes` 里每个班级考试通过率的**增量值**，存入优先队列中，每次取增量最大的一组通过率并安排一位聪明的学生，再重新计算考试通过率并存入优先队列中。直到聪明的学生都被分配完为止。 + +```java +class Solution { +    public double maxAverageRatio(int[][] classes, int extraStudents) { +        PriorityQueue pq = new PriorityQueue<>((a, b) ->{ +            double temp1 = (a[0] + 1) * 1.0 / (a[1] + 1) - a[0] * 1.0 / a[1]; +            double temp2 = (b[0] + 1) * 1.0 / (b[1] + 1) - b[0] * 1.0 / b[1]; +            return Double.compare(temp2, temp1); +        }); +        for(int[] temp: classes){ +            pq.offer(temp); +        } +        while(extraStudents-- != 0){ +            int[] temp = pq.poll(); +            temp[0]++; +            temp[1]++; +            pq.offer(temp); +        } +        double ans = 0.0; +        while(!pq.isEmpty()){ +            int[] temp = pq.poll(); +            ans += temp[0] * 1.0 / temp[1]; +        } +        return ans / classes.length; +    } +} +``` + +注意： + +- `public static int compare(double num1, double num2)`，用法：`Double.compare(d1, d2)` +- `public int compareTo(Double anotherDouble)`，用法：`D1.compareTo(D2)` + +使用方法2需要**手动装箱**。 \ No newline at end of file From dcf7c9a2ed03b9d36003154009533ac12f4d4a6d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 20 Feb 2023 10:36:33 +0800 Subject: [PATCH 002/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index eb64064..0563882 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | | 2023-02-12 09:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | | 2023-02-09 17:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | | 2023-02-08 14:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | From e2deffb28dcbff8866c2fe8a1e8a2f5252afc7bf Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 27 Feb 2023 19:40:34 +0800 Subject: [PATCH 003/373] =?UTF-8?q?Create=201144.=20=E9=80=92=E5=87=8F?= =?UTF-8?q?=E5=85=83=E7=B4=A0=E4=BD=BF=E6=95=B0=E7=BB=84=E5=91=88=E9=94=AF?= =?UTF-8?q?=E9=BD=BF=E7=8A=B6.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...10\351\224\257\351\275\277\347\212\266.md" | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 "Simulation/1144. \351\200\222\345\207\217\345\205\203\347\264\240\344\275\277\346\225\260\347\273\204\345\221\210\351\224\257\351\275\277\347\212\266.md" diff --git "a/Simulation/1144. \351\200\222\345\207\217\345\205\203\347\264\240\344\275\277\346\225\260\347\273\204\345\221\210\351\224\257\351\275\277\347\212\266.md" "b/Simulation/1144. \351\200\222\345\207\217\345\205\203\347\264\240\344\275\277\346\225\260\347\273\204\345\221\210\351\224\257\351\275\277\347\212\266.md" new file mode 100644 index 0000000..e9df5f6 --- /dev/null +++ "b/Simulation/1144. \351\200\222\345\207\217\345\205\203\347\264\240\344\275\277\346\225\260\347\273\204\345\221\210\351\224\257\351\275\277\347\212\266.md" @@ -0,0 +1,59 @@ +#### 1144. 递减元素使数组呈锯齿状 + +难度：中等 + +--- + +给你一个整数数组 `nums`，每次 **操作**  会从中选择一个元素并 **将该元素的值减少 1** 。 + +如果符合下列情况之一，则数组 `A` 就是 **锯齿数组** ： + +* 每个偶数索引对应的元素都大于相邻的元素，即 `A[0] > A[1] < A[2] > A[3] < A[4] > ...` +* 或者，每个奇数索引对应的元素都大于相邻的元素，即 `A[0] < A[1] > A[2] < A[3] > A[4] < ...` + +返回将数组 `nums` 转换为锯齿数组所需的最小操作次数。 + + **示例 1：** + +``` +输入：nums = [1,2,3] +输出：2 +解释：我们可以把 2 递减到 0，或把 3 递减到 1。 +``` + + **示例 2：** + +``` +输入：nums = [9,6,1,6,2] +输出：4 +``` + + **提示：** + +* `1 <= nums.length <= 1000` +* `1 <= nums[i] <= 1000` + +--- + +模拟： + +奇数和偶数两种情况分别讨论，其调用的方法都是同一个，用一个 `temp` 临时变量记录差值，取与前者和与后者的差值的最大值。 + +```java +class Solution { +    public int movesToMakeZigzag(int[] nums) { +        return Math.min(method(nums, true), method(nums, false)); +    } + +    private int method(int[] nums, boolean isOdd){ +        int start = isOdd == true ? 1 : 0, ans = 0; +        for(int i = start; i < nums.length; i += 2){ +            int temp = 0; +            if(i - 1 >= 0) temp = Math.max(temp, nums[i] - nums[i - 1] + 1); +            if(i + 1 < nums.length) temp = Math.max(temp, nums[i] - nums[i + 1] + 1); +            ans += temp;  +        } +        return ans; +    } +} +``` \ No newline at end of file From 7a634a33a1f9698e1b32d339d5e7da128e1b1566 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 27 Feb 2023 19:44:47 +0800 Subject: [PATCH 004/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0563882..b783861 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | | 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | | 2023-02-12 09:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | | 2023-02-09 17:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | From fd0c36361215751a9d0254627e6662fcda0e79c8 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Tue, 28 Feb 2023 21:50:31 +0800 Subject: [PATCH 005/373] =?UTF-8?q?Create=201801.=20=E7=A7=AF=E5=8E=8B?= =?UTF-8?q?=E8=AE=A2=E5=8D=95=E4=B8=AD=E7=9A=84=E8=AE=A2=E5=8D=95=E6=80=BB?= =?UTF-8?q?=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...42\345\215\225\346\200\273\346\225\260.md" | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 "Priority Queue/1801. \347\247\257\345\216\213\350\256\242\345\215\225\344\270\255\347\232\204\350\256\242\345\215\225\346\200\273\346\225\260.md" diff --git "a/Priority Queue/1801. \347\247\257\345\216\213\350\256\242\345\215\225\344\270\255\347\232\204\350\256\242\345\215\225\346\200\273\346\225\260.md" "b/Priority Queue/1801. \347\247\257\345\216\213\350\256\242\345\215\225\344\270\255\347\232\204\350\256\242\345\215\225\346\200\273\346\225\260.md" new file mode 100644 index 0000000..3e58370 --- /dev/null +++ "b/Priority Queue/1801. \347\247\257\345\216\213\350\256\242\345\215\225\344\270\255\347\232\204\350\256\242\345\215\225\346\200\273\346\225\260.md" @@ -0,0 +1,99 @@ +#### 1801. 积压订单中的订单总数 + +难度：中等 + +--- + +给你一个二维整数数组 `orders` ，其中每个 `orders[i] = [pricei, amounti, orderTypei]` 表示有 `amounti` 笔类型为 `orderTypei` 、价格为 `pricei` 的订单。 + +订单类型 `orderTypei` 可以分为两种： + +* `0` 表示这是一批采购订单 `buy` +* `1` 表示这是一批销售订单 `sell` + +注意，`orders[i]` 表示一批共计 `amounti` 笔的独立订单，这些订单的价格和类型相同。对于所有有效的 `i` ，由 `orders[i]` 表示的所有订单提交时间均早于 `orders[i+1]` 表示的所有订单。 + +存在由未执行订单组成的 **积压订单** 。积压订单最初是空的。提交订单时，会发生以下情况： + +* 如果该订单是一笔采购订单 `buy` ，则可以查看积压订单中价格 **最低** 的销售订单 `sell` 。如果该销售订单 `sell` 的价格 **低于或等于** 当前采购订单 `buy` 的价格，则匹配并执行这两笔订单，并将销售订单 `sell` 从积压订单中删除。否则，采购订单 `buy` 将会添加到积压订单中。 +* 反之亦然，如果该订单是一笔销售订单 `sell` ，则可以查看积压订单中价格 **最高** 的采购订单 `buy` 。如果该采购订单 `buy` 的价格 **高于或等于** 当前销售订单 `sell` 的价格，则匹配并执行这两笔订单，并将采购订单 `buy` 从积压订单中删除。否则，销售订单 `sell` 将会添加到积压订单中。 + +输入所有订单后，返回积压订单中的 **订单总数** 。由于数字可能很大，所以需要返回对 `10^9 + 7` 取余的结果。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/03/21/ex1.png) +``` +输入：orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]] +输出：6 +解释：输入订单后会发生下述情况： +- 提交 5 笔采购订单，价格为 10 。没有销售订单，所以这 5 笔订单添加到积压订单中。 +- 提交 2 笔销售订单，价格为 15 。没有采购订单的价格大于或等于 15 ，所以这 2 笔订单添加到积压订单中。 +- 提交 1 笔销售订单，价格为 25 。没有采购订单的价格大于或等于 25 ，所以这 1 笔订单添加到积压订单中。 +- 提交 4 笔采购订单，价格为 30 。前 2 笔采购订单与价格最低（价格为 15）的 2 笔销售订单匹配，从积压订单中删除这 2 笔销售订单。第 3 笔采购订单与价格最低的 1 笔销售订单匹配，销售订单价格为 25 ，从积压订单中删除这 1 笔销售订单。积压订单中不存在更多销售订单，所以第 4 笔采购订单需要添加到积压订单中。 +最终，积压订单中有 5 笔价格为 10 的采购订单，和 1 笔价格为 30 的采购订单。所以积压订单中的订单总数为 6 。 +``` + + **示例 2：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/03/21/ex2.png) +``` +输入：orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]] +输出：999999984 +解释：输入订单后会发生下述情况： +- 提交 109 笔销售订单，价格为 7 。没有采购订单，所以这 109 笔订单添加到积压订单中。 +- 提交 3 笔采购订单，价格为 15 。这些采购订单与价格最低（价格为 7 ）的 3 笔销售订单匹配，从积压订单中删除这 3 笔销售订单。 +- 提交 999999995 笔采购订单，价格为 5 。销售订单的最低价为 7 ，所以这 999999995 笔订单添加到积压订单中。 +- 提交 1 笔销售订单，价格为 5 。这笔销售订单与价格最高（价格为 5 ）的 1 笔采购订单匹配，从积压订单中删除这 1 笔采购订单。 +最终，积压订单中有 (1000000000-3) 笔价格为 7 的销售订单，和 (999999995-1) 笔价格为 5 的采购订单。所以积压订单中的订单总数为 1999999991 ，等于 999999984 % (109 + 7) 。 +``` + + **提示：** + +* `1 <= orders.length <= 10^5` +* `orders[i].length == 3` +* `1 <= pricei, amounti <= 10^9` +* `orderTypei` 为 `0` 或 `1` + +--- + +优先队列 + 模拟： + +需要以数组的方式存入优先队列中，而不是以整型，否则会内存溢出。主要的思路还是模拟。 + +买和卖的过程有些类似，优化在一个函数内，但并没有降低时间复杂度。 + +```Java +class Solution { + public int getNumberOfBacklogOrders(int[][] orders) { + PriorityQueue buy = new PriorityQueue<>((a, b) -> (b[0] - a[0])); + PriorityQueue sell = new PriorityQueue<>((a, b) -> (a[0] - b[0])); + for(int[] order: orders){ + if(order[2] == 0) solve(sell, buy, order); + else solve(buy, sell, order); + } + int ans = 0; + for(PriorityQueue pq: Arrays.asList(buy, sell)){ + while(!pq.isEmpty()){ + int[] temp = pq.poll(); + ans = (ans + temp[1]) % 1000000007; + } + } + return ans; + } + + private void solve(PriorityQueue pq1, PriorityQueue pq2, int[] order){ + int price = order[0], num = order[1], flag = order[2]; + while(num > 0 && !pq1.isEmpty() && (flag == 0 ? pq1.peek()[0] <= price : pq1.peek()[0] >= price)){ + int[] temp = pq1.poll(); + int amount = Math.min(num, temp[1]); + num -= amount; + temp[1] -= amount; + if(temp[1] > 0){ + pq1.offer(temp); + } + } + if(num > 0) pq2.offer(new int[]{price, num}); + } +} +``` \ No newline at end of file From 49f2e0bb0f7ac2ec378258ec24a3df422959a9b2 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 28 Feb 2023 21:55:28 +0800 Subject: [PATCH 006/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b783861..4307835 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | | 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | | 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | | 2023-02-12 09:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | From e8c2bcb4171832c714347c0d07c80eab5e0dffac Mon Sep 17 00:00:00 2001 From: NUC11 Date: Fri, 3 Mar 2023 19:38:53 +0800 Subject: [PATCH 007/373] =?UTF-8?q?Create=201487.=20=E4=BF=9D=E8=AF=81?= =?UTF-8?q?=E6=96=87=E4=BB=B6=E5=90=8D=E5=94=AF=E4=B8=80.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...66\345\220\215\345\224\257\344\270\200.md" | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 "Hash Table/1487. \344\277\235\350\257\201\346\226\207\344\273\266\345\220\215\345\224\257\344\270\200.md" diff --git "a/Hash Table/1487. \344\277\235\350\257\201\346\226\207\344\273\266\345\220\215\345\224\257\344\270\200.md" "b/Hash Table/1487. \344\277\235\350\257\201\346\226\207\344\273\266\345\220\215\345\224\257\344\270\200.md" new file mode 100644 index 0000000..e1ccd21 --- /dev/null +++ "b/Hash Table/1487. \344\277\235\350\257\201\346\226\207\344\273\266\345\220\215\345\224\257\344\270\200.md" @@ -0,0 +1,92 @@ +#### 1487. 保证文件名唯一 + +难度：中等 + +--- + +给你一个长度为 `n` 的字符串数组 `names` 。你将会在文件系统中创建 `n` 个文件夹：在第 `i` 分钟，新建名为 `names[i]` 的文件夹。 + +由于两个文件 **不能** 共享相同的文件名，因此如果新建文件夹使用的文件名已经被占用，系统会以 `(k)` 的形式为新文件夹的文件名添加后缀，其中 `k` 是能保证文件名唯一的 **最小正整数** 。 + +返回长度为 _`n`_ 的字符串数组，其中 `ans[i]` 是创建第 `i` 个文件夹时系统分配给该文件夹的实际名称。 + + **示例 1：** + +``` +输入：names = ["pes","fifa","gta","pes(2019)"] +输出：["pes","fifa","gta","pes(2019)"] +解释：文件系统将会这样创建文件名： +"pes" --> 之前未分配，仍为 "pes" +"fifa" --> 之前未分配，仍为 "fifa" +"gta" --> 之前未分配，仍为 "gta" +"pes(2019)" --> 之前未分配，仍为 "pes(2019)" +``` + + **示例 2：** + +``` +输入：names = ["gta","gta(1)","gta","avalon"] +输出：["gta","gta(1)","gta(2)","avalon"] +解释：文件系统将会这样创建文件名： +"gta" --> 之前未分配，仍为 "gta" +"gta(1)" --> 之前未分配，仍为 "gta(1)" +"gta" --> 文件名被占用，系统为该名称添加后缀 (k)，由于 "gta(1)" 也被占用，所以 k = 2 。实际创建的文件名为 "gta(2)" 。 +"avalon" --> 之前未分配，仍为 "avalon" +``` + + **示例 3：** + +``` +输入：names = ["onepiece","onepiece(1)","onepiece(2)","onepiece(3)","onepiece"] +输出：["onepiece","onepiece(1)","onepiece(2)","onepiece(3)","onepiece(4)"] +解释：当创建最后一个文件夹时，最小的正有效 k 为 4 ，文件名变为 "onepiece(4)"。 +``` + + **示例 4：** + +``` +输入：names = ["wano","wano","wano","wano"] +输出：["wano","wano(1)","wano(2)","wano(3)"] +解释：每次创建文件夹 "wano" 时，只需增加后缀中 k 的值即可。 +``` + + **示例 5：** + +``` +输入：names = ["kaido","kaido(1)","kaido","kaido(1)"] +输出：["kaido","kaido(1)","kaido(2)","kaido(1)(1)"] +解释：注意，如果含后缀文件名被占用，那么系统也会按规则在名称后添加新的后缀 (k) 。 +``` + + **提示：** + +* `1 <= names.length <= 5 * 10^4` +* `1 <= names[i].length <= 20` +* `names[i]` 由小写英文字母、数字和/或圆括号组成。 + +--- + +哈希表： + +比较繁琐。又有点像模拟题，重点在于**后缀名被占用后需要添加新的后缀**。 + +```Java +class Solution { + public String[] getFolderNames(String[] names) { + LinkedHashMap hashmap = new LinkedHashMap<>(); + for(String name: names){ + if(hashmap.containsKey(name)){ + int num = hashmap.get(name); + while(hashmap.containsKey(new StringBuilder(name).append("(").append(num + 1).append(")").toString())) num++; // 在哈希表中查找后缀k值 + hashmap.put(name, num + 1); + hashmap.put(new StringBuilder(name).append("(").append(num + 1).append(")").toString(), 0); + } + else{ + hashmap.put(name, 0); + } + } + Set set = hashmap.keySet(); + return set.toArray(new String[hashmap.size()]); + } +} +``` \ No newline at end of file From b623d608fad2765f47c6532ddffce8ca69ad7a57 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 3 Mar 2023 19:43:16 +0800 Subject: [PATCH 008/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 4307835..6cd8b59 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | | 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | | 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | | 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | From d91a9ef946707f5d9d85aabec34cd73ba8de20de Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Mon, 6 Mar 2023 22:09:45 +0800 Subject: [PATCH 009/373] =?UTF-8?q?Create=201653.=20=E4=BD=BF=E5=AD=97?= =?UTF-8?q?=E7=AC=A6=E4=B8=B2=E5=B9=B3=E8=A1=A1=E7=9A=84=E6=9C=80=E5=B0=91?= =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=AC=A1=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\351\231\244\346\254\241\346\225\260.md" | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 "Methodology/1653. \344\275\277\345\255\227\347\254\246\344\270\262\345\271\263\350\241\241\347\232\204\346\234\200\345\260\221\345\210\240\351\231\244\346\254\241\346\225\260.md" diff --git "a/Methodology/1653. \344\275\277\345\255\227\347\254\246\344\270\262\345\271\263\350\241\241\347\232\204\346\234\200\345\260\221\345\210\240\351\231\244\346\254\241\346\225\260.md" "b/Methodology/1653. \344\275\277\345\255\227\347\254\246\344\270\262\345\271\263\350\241\241\347\232\204\346\234\200\345\260\221\345\210\240\351\231\244\346\254\241\346\225\260.md" new file mode 100644 index 0000000..b6df251 --- /dev/null +++ "b/Methodology/1653. \344\275\277\345\255\227\347\254\246\344\270\262\345\271\263\350\241\241\347\232\204\346\234\200\345\260\221\345\210\240\351\231\244\346\254\241\346\225\260.md" @@ -0,0 +1,60 @@ +#### 1653. 使字符串平衡的最少删除次数 + +难度：中等 + +--- + +给你一个字符串 `s` ，它仅包含字符 `'a'` 和 `'b'`​​​​ 。 + +你可以删除 `s` 中任意数目的字符，使得 `s` **平衡**  。当不存在下标对 `(i,j)` 满足 `i < j` ，且 `s[i] = 'b'` 的同时 `s[j]= 'a'` ，此时认为 `s` 是 **平衡** 的。 + +请你返回使 `s`  **平衡**  的 **最少**  删除次数。 + + **示例 1：** + +``` +输入：s = "aababbab" +输出：2 +解释：你可以选择以下任意一种方案： +下标从 0 开始，删除第 2 和第 6 个字符（"aababbab" -> "aaabbb"）， +下标从 0 开始，删除第 3 和第 6 个字符（"aababbab" -> "aabbbb"）。 +``` + + **示例 2：** + +``` +输入：s = "bbaaaaabb" +输出：2 +解释：唯一的最优解是删除最前面两个字符。 +``` + + **提示：** + +* `1 <= s.length <= 10^5` +* `s[i]` 要么是 `'a'` 要么是 `'b'`​ 。​ + +--- + +两次遍历： + +第一次从左向右遍历记录所有 `A` 的数量（换言之，右侧 `A` 的数量），第二次从左向右遍历根据不同情况增加左侧 `B` 的数量（当前字符为 `B`）或减少右侧 `A` 的数量（当前字符为 `A`），遍历过程中这两者数量和的最小值即是最后的答案。 + +类似于前缀和，也类似是求最长非递减子序列长度 + +```Java +class Solution { + public int minimumDeletions(String s) { + int rightA = 0, leftB = 0; + for(int i = 0; i < s.length(); i++){ + if(s.charAt(i) == 'a') rightA++; + } + int ans = rightA; + for(int i = 0; i < s.length(); i++){ + if(s.charAt(i) == 'a') rightA--; + else leftB++; + ans = Math.min(ans, leftB + rightA); + } + return ans; + } +} +``` \ No newline at end of file From b2b28bd1f604e10561e27194c6a6cb049aa00f49 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 6 Mar 2023 22:14:54 +0800 Subject: [PATCH 010/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6cd8b59..cad0bfd 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | | 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | | 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | | 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | From 2d25b3253cc47bad834fb690078f5091efd3bdbf Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 8 Mar 2023 21:56:18 +0800 Subject: [PATCH 011/373] =?UTF-8?q?Create=20=E5=89=91=E6=8C=87=20Offer=204?= =?UTF-8?q?7.=20=E7=A4=BC=E7=89=A9=E7=9A=84=E6=9C=80=E5=A4=A7=E4=BB=B7?= =?UTF-8?q?=E5=80=BC.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\244\247\344\273\267\345\200\274.md" | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 "Dynamic Programming/\345\211\221\346\214\207 Offer 47. \347\244\274\347\211\251\347\232\204\346\234\200\345\244\247\344\273\267\345\200\274.md" diff --git "a/Dynamic Programming/\345\211\221\346\214\207 Offer 47. \347\244\274\347\211\251\347\232\204\346\234\200\345\244\247\344\273\267\345\200\274.md" "b/Dynamic Programming/\345\211\221\346\214\207 Offer 47. \347\244\274\347\211\251\347\232\204\346\234\200\345\244\247\344\273\267\345\200\274.md" new file mode 100644 index 0000000..60d1e87 --- /dev/null +++ "b/Dynamic Programming/\345\211\221\346\214\207 Offer 47. \347\244\274\347\211\251\347\232\204\346\234\200\345\244\247\344\273\267\345\200\274.md" @@ -0,0 +1,55 @@ +#### 剑指 Offer 47. 礼物的最大价值 + +难度：中等 + +--- + +在一个 m\*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？ + + **示例 1:** + +``` +输入: +[ +  [1,3,1], +  [1,5,1], +  [4,2,1] +] +输出: 12 +解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物 +``` + +提示： + +* `0 < grid.length <= 200` +* `0 < grid[0].length <= 200` + +--- + +动态规划： + +二维数组初始化：`i = 0` 或 `j = 0` 时的数组 `dp[i][j]` 为对应的 `grid[i][j]` 的值； + +状态转移方程也比较简单：`f(i, j) = max{f(i - 1, j), f(i, j - 1)} + grid[i][j]`。 + +```Java +class Solution { + public int maxValue(int[][] grid) { + int m = grid.length, n = grid[0].length; + int[][] dp = new int[m][n]; + dp[0][0] = grid[0][0]; + for(int i = 1; i < m; i++){ + dp[i][0] = dp[i - 1][0] + grid[i][0]; + } + for(int j = 1; j < n; j++){ + dp[0][j] = dp[0][j - 1] + grid[0][j]; + } + for(int i = 1; i < m; i++){ + for(int j = 1; j < n; j++){ + dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]; + } + } + return dp[m - 1][n - 1]; + } +} +``` \ No newline at end of file From 3fd0f6e550a031000c6db2400524c43117bf7557 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 8 Mar 2023 22:01:27 +0800 Subject: [PATCH 012/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index cad0bfd..c2c6a70 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-08 21:52 | [#剑指 Offer 47 礼物的最大价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | | 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | | 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | | 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | From b8c08000a6c716d3fef39b32c40f14c034c31ed5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 13 Mar 2023 20:18:31 +0800 Subject: [PATCH 013/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c2c6a70..2e739d3 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | | 2023-03-08 21:52 | [#剑指 Offer 47 礼物的最大价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | | 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | | 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | From 7e66705693a0194f13693e18dd350e8352d36c35 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 13 Mar 2023 20:50:53 +0800 Subject: [PATCH 014/373] =?UTF-8?q?Create=20289.=20=E7=94=9F=E5=91=BD?= =?UTF-8?q?=E6=B8=B8=E6=88=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...37\345\221\275\346\270\270\346\210\217.md" | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 "Simulation/289. \347\224\237\345\221\275\346\270\270\346\210\217.md" diff --git "a/Simulation/289. \347\224\237\345\221\275\346\270\270\346\210\217.md" "b/Simulation/289. \347\224\237\345\221\275\346\270\270\346\210\217.md" new file mode 100644 index 0000000..864e6c9 --- /dev/null +++ "b/Simulation/289. \347\224\237\345\221\275\346\270\270\346\210\217.md" @@ -0,0 +1,88 @@ +#### 289. 生命游戏 + +难度：中等 + +--- + +根据 [百度百科](https://baike.baidu.com/item/%E7%94%9F%E5%91%BD%E6%B8%B8%E6%88%8F/2926434?fr=aladdin) ，  **生命游戏**  ，简称为 **生命** ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。 + +给定一个包含 `m × n` 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： `1` 即为 **活细胞** （live），或 `0` 即为 **死细胞** （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律： + +1. 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡； +2. 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活； +3. 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡； +4. 如果死细胞周围正好有三个活细胞，则该位置死细胞复活； + +下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 `m x n` 网格面板 `board` 的当前状态，返回下一个状态。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2020/12/26/grid1.jpg) +``` +输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]] +输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]] +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2020/12/26/grid2.jpg) +``` +输入：board = [[1,1],[1,0]] +输出：[[1,1],[1,1]] +``` + + **提示：** + +* `m == board.length` +* `n == board[i].length` +* `1 <= m, n <= 25` +* `board[i][j]` 为 `0` 或 `1` + + **进阶：** + +* 你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。 +* 本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？ + +--- + +模拟： + +原地变换。 + +- 如果原来是活细胞，后来是死细胞，则赋值为 `2`。 + +- 如果原来是死细胞，后来是活细胞，则赋值为 `-1`。 + +遍历时只要其值大于零，原来就是活细胞。 + +```Java +class Solution { + public void gameOfLife(int[][] board) { + int m = board.length, n = board[0].length; + int[] bias = {-1, 0, 1}; + for(int i = 0; i < m; i++){ + for(int j = 0; j < n; j++){ + int alive = 0; + for(int x = 0; x < 3; x++){ + for(int y = 0; y < 3; y++){ + if(bias[x] != 0 || bias[y] != 0){ + int cur_i = i + bias[x], cur_j = j + bias[y]; + if((cur_i >= 0 && cur_i < m) && (cur_j >= 0 && cur_j < n) && board[cur_i][cur_j] > 0){ + alive++; + } + } + } + } + if(board[i][j] == 0 && alive == 3) board[i][j] = -1; + if(board[i][j] == 1 && (alive < 2 || alive > 3)) board[i][j] = 2; + } + } + for(int i = 0; i < m; i++){ + for(int j = 0; j < n; j++){ + if(board[i][j] == 2) board[i][j] = 0; + else if(board[i][j] == -1) board[i][j] = 1; + } + } + } +} +``` \ No newline at end of file From de6e1280e6b2ca553107e9ba5bed46a7452d6c41 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Tue, 14 Mar 2023 19:17:14 +0800 Subject: [PATCH 015/373] =?UTF-8?q?Create=201605.=20=E7=BB=99=E5=AE=9A?= =?UTF-8?q?=E8=A1=8C=E5=92=8C=E5=88=97=E7=9A=84=E5=92=8C=E6=B1=82=E5=8F=AF?= =?UTF-8?q?=E8=A1=8C=E7=9F=A9=E9=98=B5.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...57\350\241\214\347\237\251\351\230\265.md" | 89 +++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 "Greedy/1605. \347\273\231\345\256\232\350\241\214\345\222\214\345\210\227\347\232\204\345\222\214\346\261\202\345\217\257\350\241\214\347\237\251\351\230\265.md" diff --git "a/Greedy/1605. \347\273\231\345\256\232\350\241\214\345\222\214\345\210\227\347\232\204\345\222\214\346\261\202\345\217\257\350\241\214\347\237\251\351\230\265.md" "b/Greedy/1605. \347\273\231\345\256\232\350\241\214\345\222\214\345\210\227\347\232\204\345\222\214\346\261\202\345\217\257\350\241\214\347\237\251\351\230\265.md" new file mode 100644 index 0000000..6b5a1ff --- /dev/null +++ "b/Greedy/1605. \347\273\231\345\256\232\350\241\214\345\222\214\345\210\227\347\232\204\345\222\214\346\261\202\345\217\257\350\241\214\347\237\251\351\230\265.md" @@ -0,0 +1,89 @@ +#### 1605. 给定行和列的和求可行矩阵 + +难度：中等 + +--- + +给你两个非负整数数组 `rowSum` 和 `colSum` ，其中 `rowSum[i]` 是二维矩阵中第 `i` 行元素的和， `colSum[j]` 是第 `j` 列元素的和。换言之你不知道矩阵里的每个元素，但是你知道每一行和每一列的和。 + +请找到大小为 `rowSum.length x colSum.length` 的任意 **非负整数**  矩阵，且该矩阵满足 `rowSum` 和 `colSum` 的要求。 + +请你返回任意一个满足题目要求的二维矩阵，题目保证存在 **至少一个**  可行矩阵。 + + **示例 1：** + +``` +输入：rowSum = [3,8], colSum = [4,7] +输出：[[3,0], + [1,7]] +解释： +第 0 行：3 + 0 = 3 == rowSum[0] +第 1 行：1 + 7 = 8 == rowSum[1] +第 0 列：3 + 1 = 4 == colSum[0] +第 1 列：0 + 7 = 7 == colSum[1] +行和列的和都满足题目要求，且所有矩阵元素都是非负的。 +另一个可行的矩阵为：[[1,2], + [3,5]] +``` + + **示例 2：** + +``` +输入：rowSum = [5,7,10], colSum = [8,6,8] +输出：[[0,5,0], + [6,1,0], + [2,0,8]] +``` + + **示例 3：** + +``` +输入：rowSum = [14,9], colSum = [6,9,8] +输出：[[0,9,5], + [6,0,3]] +``` + + **示例 4：** + +``` +输入：rowSum = [1,0], colSum = [1] +输出：[[1], + [0]] +``` + + **示例 5：** + +``` +输入：rowSum = [0], colSum = [0] +输出：[[0]] +``` + + **提示：** + +* `1 <= rowSum.length, colSum.length <= 500` +* `0 <= rowSum[i], colSum[i] <= 10^8` +* `sum(rowSum) == sum(colSum)` + +--- + +贪心： + +运筹学中的运输问题。答案不唯一。有西北角法、最小元素法等，以下是西北角法的代码，即从**左上角**开始分配。 + +```Java +class Solution { + public int[][] restoreMatrix(int[] rowSum, int[] colSum) { + int i = 0, j = 0; + int[][] ans = new int[rowSum.length][colSum.length]; + while(i < rowSum.length && j < colSum.length){ + int temp = Math.min(rowSum[i], colSum[j]); + ans[i][j] = temp; + rowSum[i] -= temp; + colSum[j] -= temp; + if(rowSum[i] == 0) i++; + if(colSum[j] == 0) j++; + } + return ans; + } +} +``` \ No newline at end of file From e3db5c2ffe65a04b2d7528499dce7c2f2bafb778 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 14 Mar 2023 19:21:00 +0800 Subject: [PATCH 016/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2e739d3..538eef7 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | | 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | | 2023-03-08 21:52 | [#剑指 Offer 47 礼物的最大价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | | 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | From 060716d107905fa9253f9b7764d9882bd4bdd4e4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 15 Mar 2023 20:17:50 +0800 Subject: [PATCH 017/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 538eef7..3dbe313 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | | 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | | 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | | 2023-03-08 21:52 | [#剑指 Offer 47 礼物的最大价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | From adb12e3b21b06905a2531acc5bc0f94cb451f890 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 15 Mar 2023 22:01:15 +0800 Subject: [PATCH 018/373] =?UTF-8?q?Create=201615.=20=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E7=BD=91=E7=BB=9C=E7=A7=A9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...47\347\275\221\347\273\234\347\247\251.md" | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 "Graph/1615. \346\234\200\345\244\247\347\275\221\347\273\234\347\247\251.md" diff --git "a/Graph/1615. \346\234\200\345\244\247\347\275\221\347\273\234\347\247\251.md" "b/Graph/1615. \346\234\200\345\244\247\347\275\221\347\273\234\347\247\251.md" new file mode 100644 index 0000000..270208d --- /dev/null +++ "b/Graph/1615. \346\234\200\345\244\247\347\275\221\347\273\234\347\247\251.md" @@ -0,0 +1,81 @@ +#### 1615. 最大网络秩 + +难度：中等 + +--- + +`n` 座城市和一些连接这些城市的道路 `roads` 共同组成一个基础设施网络。每个 `roads[i] = [ai, bi]` 都表示在城市 `ai` 和 `bi` 之间有一条双向道路。 + +两座不同城市构成的 **城市对** 的 **网络秩** 定义为：与这两座城市 **直接** 相连的道路总数。如果存在一条道路直接连接这两座城市，则这条道路只计算 **一次** 。 + +整个基础设施网络的 **最大网络秩** 是所有不同城市对中的 **最大网络秩** 。 + +给你整数 `n` 和数组 `roads`，返回整个基础设施网络的 **最大网络秩** 。 + + **示例 1：** + + **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/11/ex1.png)** + +``` +输入：n = 4, roads = [[0,1],[0,3],[1,2],[1,3]] +输出：4 +解释：城市 0 和 1 的网络秩是 4，因为共有 4 条道路与城市 0 或 1 相连。位于 0 和 1 之间的道路只计算一次。 +``` + + **示例 2：** + + **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/11/ex2.png)** + +``` +输入：n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]] +输出：5 +解释：共有 5 条道路与城市 1 或 2 相连。 +``` + + **示例 3：** + +``` +输入：n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]] +输出：5 +解释：2 和 5 的网络秩为 5，注意并非所有的城市都需要连接起来。 +``` + + **提示：** + +* `2 <= n <= 100` +* `0 <= roads.length <= n * (n - 1) / 2` +* `roads[i].length == 2` +* `0 <= ai, bi <= n-1` +* `ai != bi` +* 每对城市之间 **最多只有一条**  道路相连 + +--- + +邻接表： + +构造邻接表再遍历所有点即可。 + +```Java +class Solution { + public int maximalNetworkRank(int n, int[][] roads) { + List[] arraylist = new List[n]; + for(int i = 0; i < n; i++){ + arraylist[i] = new ArrayList<>(); + } + for(int i = 0; i < roads.length; i++){ + int a = roads[i][0], b = roads[i][1]; + arraylist[a].add(b); + arraylist[b].add(a); + } + int ans = 0; + for(int i = 0; i < n - 1; i++){ + for(int j = i + 1; j < n; j++){ + int temp = arraylist[i].size() + arraylist[j].size(); + if(arraylist[i].contains(j)) temp--; + ans = Math.max(ans, temp); + } + } + return ans; + } +} +``` \ No newline at end of file From cf5c1ca016593c5262151ddf6c827843c4f184e4 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Fri, 17 Mar 2023 21:29:46 +0800 Subject: [PATCH 019/373] =?UTF-8?q?Create=2089.=20=E6=A0=BC=E9=9B=B7?= =?UTF-8?q?=E7=BC=96=E7=A0=81.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...74\351\233\267\347\274\226\347\240\201.md" | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 "Methodology/89. \346\240\274\351\233\267\347\274\226\347\240\201.md" diff --git "a/Methodology/89. \346\240\274\351\233\267\347\274\226\347\240\201.md" "b/Methodology/89. \346\240\274\351\233\267\347\274\226\347\240\201.md" new file mode 100644 index 0000000..3000860 --- /dev/null +++ "b/Methodology/89. \346\240\274\351\233\267\347\274\226\347\240\201.md" @@ -0,0 +1,80 @@ +#### 89. 格雷编码 + +难度：中等 + +--- + + **n 位格雷码序列** 是一个由 `2^n` 个整数组成的序列，其中： + +* 每个整数都在范围 `[0, 2^n - 1]` 内（含 `0` 和 `2^n - 1`） +* 第一个整数是 `0` +* 一个整数在序列中出现 **不超过一次** +* 每对 **相邻** 整数的二进制表示 **恰好一位不同** ，且 +* **第一个** 和 **最后一个** 整数的二进制表示 **恰好一位不同** + +给你一个整数 `n` ，返回任一有效的 **n 位格雷码序列** 。 + + **示例 1：** + +``` +输入：n = 2 +输出：[0,1,3,2] +解释： +[0,1,3,2] 的二进制表示是 [00,01,11,10] 。 +- 00 和 01 有一位不同 +- 01 和 11 有一位不同 +- 11 和 10 有一位不同 +- 10 和 00 有一位不同 +[0,2,3,1] 也是一个有效的格雷码序列，其二进制表示是 [00,10,11,01] 。 +- 00 和 10 有一位不同 +- 10 和 11 有一位不同 +- 11 和 01 有一位不同 +- 01 和 00 有一位不同 +``` + + **示例 2：** + +``` +输入：n = 1 +输出：[0,1] +``` + + **提示：** + +* `1 <= n <= 16` + +--- + +找规律： + +通过规律发现，根据前 `k` 位的格雷码通过**对称**的方式可以构造出 `k + 1` 位的格雷码。例如， + +``` +0 0 0 +0 0 1 +0 1 1 +0 1 0 +1 1 0 +1 1 1 +1 0 1 +1 0 0 +``` + +前两行的后一位（0，1）对称可得到第三四行的后一位（1，0），前四行的后两位（00，01，11，10）对称可得到第五至八行的后两位（10，11，01，00）。 + +```Java +class Solution { + public List grayCode(int n) { + List ans = new ArrayList<>(); + ans.add(0); + int head = 1; + for(int i = 0; i < n; i++){ + for(int j = ans.size() - 1; j >= 0; j--){ + ans.add(head + ans.get(j)); + } + head <<= 1; + } + return ans; + } +} +``` \ No newline at end of file From 00068a4cd0d08e89a1de4a7381a4a276bfa6923a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 17 Mar 2023 21:34:44 +0800 Subject: [PATCH 020/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3dbe313..70f0814 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | | 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | | 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | | 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | From f4ad8baff25c71cb81066d83ae9b734c58140997 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sat, 18 Mar 2023 12:07:48 +0800 Subject: [PATCH 021/373] =?UTF-8?q?Create=201616.=20=E5=88=86=E5=89=B2?= =?UTF-8?q?=E4=B8=A4=E4=B8=AA=E5=AD=97=E7=AC=A6=E4=B8=B2=E5=BE=97=E5=88=B0?= =?UTF-8?q?=E5=9B=9E=E6=96=87=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...60\345\233\236\346\226\207\344\270\262.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Two Pointers/1616. \345\210\206\345\211\262\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\345\276\227\345\210\260\345\233\236\346\226\207\344\270\262.md" diff --git "a/Two Pointers/1616. \345\210\206\345\211\262\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\345\276\227\345\210\260\345\233\236\346\226\207\344\270\262.md" "b/Two Pointers/1616. \345\210\206\345\211\262\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\345\276\227\345\210\260\345\233\236\346\226\207\344\270\262.md" new file mode 100644 index 0000000..9b3305c --- /dev/null +++ "b/Two Pointers/1616. \345\210\206\345\211\262\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\345\276\227\345\210\260\345\233\236\346\226\207\344\270\262.md" @@ -0,0 +1,82 @@ +#### 1616. 分割两个字符串得到回文串 + +难度：中等 + +--- + +给你两个字符串 `a` 和 `b` ，它们长度相同。请你选择一个下标，将两个字符串都在  **相同的下标** 分割开。由 `a` 可以得到两个字符串： `aprefix` 和 `asuffix` ，满足 `a = aprefix + asuffix` ，同理，由 `b` 可以得到两个字符串 `bprefix` 和 `bsuffix` ，满足 `b = bprefix + bsuffix` 。请你判断 `aprefix + bsuffix` 或者 `bprefix + asuffix` 能否构成回文串。 + +当你将一个字符串 `s` 分割成 `sprefix` 和 `ssuffix` 时， `ssuffix` 或者 `sprefix` 可以为空。比方说， `s = "abc"` 那么 `"" + "abc"` ， `"a" + "bc"` ， `"ab" + "c"` 和 `"abc" + ""` 都是合法分割。 + +如果 **能构成回文字符串** ，那么请返回 `true`，否则返回 `false` 。 + + **注意** ， `x + y` 表示连接字符串 `x` 和 `y` 。 + + **示例 1：** + +``` +输入：a = "x", b = "y" +输出：true +解释：如果 a 或者 b 是回文串，那么答案一定为 true ，因为你可以如下分割： +aprefix = "", asuffix = "x" +bprefix = "", bsuffix = "y" +那么 aprefix + bsuffix = "" + "y" = "y" 是回文串。 +``` + + **示例 2：** + +``` +输入：a = "abdef", b = "fecab" +输出：true +``` + + **示例 3：** + +``` +输入：a = "ulacfd", b = "jizalu" +输出：true +解释：在下标为 3 处分割： +aprefix = "ula", asuffix = "cfd" +bprefix = "jiz", bsuffix = "alu" +那么 aprefix + bsuffix = "ula" + "alu" = "ulaalu" 是回文串。 +``` + + **提示：** + +* `1 <= a.length, b.length <= 10^5` +* `a.length == b.length` +* `a` 和 `b` 都只包含小写英文字母 + +--- + +双指针： + +1. 用两个指针分别表示字符串A的前缀与字符串B的后缀在哪个下标位置不构成回文字符串（另一种情况是A的后缀和B的前缀，因此用逻辑运算符**或**连接这两种情况的返回值）。对于下列字符串，当A的下标为4和B的下标为17时（字符串A下标在0-3与字符串B下标在18-21时可组成回文字符串）。 +2. 接着判断字符串A和B在这两个下标之间是否构成回文字符串，任意一个字符串满足条件则返回true，否则返回false。对于下列字符串，字符串B在下标4-17之间是回文，因此返回true。 + + + +![](https://raw.githubusercontent.com/CompetitiveLin/ImageHostingService/picgo/imgs/202303181157470.png) + +```Java +class Solution { + public boolean checkPalindromeFormation(String a, String b) { + return checkConcatenation(a, b) || checkConcatenation(b, a); + } + private boolean checkConcatenation(String a, String b){ + int n = a.length(), left = 0, right = n - 1; + while(left < right && a.charAt(left) == b.charAt(right)){ + left++; + right--; + } + if(left >= right) return true; + return checkSelfPalindrome(a, left, right) || checkSelfPalindrome(b, left, right); + } + private boolean checkSelfPalindrome(String s, int left, int right){ + while(left < right){ + if(s.charAt(left++) != s.charAt(right--)) return false; + } + return true; + } +} +``` \ No newline at end of file From 2d9ff8c7f8eafb3bda8ef61891d507a4de32e1c9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 18 Mar 2023 12:11:30 +0800 Subject: [PATCH 022/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 70f0814..806ab77 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | | 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | | 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | | 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | From 6383bec3a02c171345855a44c091ff41efd19776 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 20 Mar 2023 20:18:24 +0800 Subject: [PATCH 023/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 806ab77..9b0aaa5 100644 --- a/README.md +++ b/README.md @@ -65,7 +65,7 @@ | 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | | 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | | 2022-12-15 20:42 | [#剑指 Offer 25 合并两个排序的链表](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | -| 2022-12-15 20:23 | [#23 合并K个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | +| 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | | 2022-12-15 13:46 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 10 | **4** | | 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | | 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | From 299c256d0450bc1bfee72d2068e763de0d21267c Mon Sep 17 00:00:00 2001 From: NUC11 Date: Tue, 21 Mar 2023 19:32:09 +0800 Subject: [PATCH 024/373] =?UTF-8?q?Create=2062.=20=E4=B8=8D=E5=90=8C?= =?UTF-8?q?=E8=B7=AF=E5=BE=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...15\345\220\214\350\267\257\345\276\204.md" | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 "Dynamic Programming/62. \344\270\215\345\220\214\350\267\257\345\276\204.md" diff --git "a/Dynamic Programming/62. \344\270\215\345\220\214\350\267\257\345\276\204.md" "b/Dynamic Programming/62. \344\270\215\345\220\214\350\267\257\345\276\204.md" new file mode 100644 index 0000000..29d8bc1 --- /dev/null +++ "b/Dynamic Programming/62. \344\270\215\345\220\214\350\267\257\345\276\204.md" @@ -0,0 +1,118 @@ +#### 62. 不同路径 + +难度：中等 + +--- + +一个机器人位于一个 `m x n` 网格的左上角 （起始点在下图中标记为 “Start” ）。 + +机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 + +问总共有多少条不同的路径？ + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png) +``` +输入：m = 3, n = 7 +输出：28 +``` + + **示例 2：** + +``` +输入：m = 3, n = 2 +输出：3 +解释： +从左上角开始，总共有 3 条路径可以到达右下角。 +1. 向右 -> 向下 -> 向下 +2. 向下 -> 向下 -> 向右 +3. 向下 -> 向右 -> 向下 +``` + + **示例 3：** + +``` +输入：m = 7, n = 3 +输出：28 +``` + + **示例 4：** + +``` +输入：m = 3, n = 3 +输出：6 +``` + + **提示：** + +* `1 <= m, n <= 100` +* 题目数据保证答案小于等于 `2 * 10^9` + +--- + +方法一，简单动态规划： + +当前格的路径数为上方格的路径数加上左侧格的路径数，空间复杂度$O(m*n)$，时间复杂度$O(m*n)$ + +```java +class Solution { + public int uniquePaths(int m, int n) { + int[][] dp = new int[m][n]; + for(int i = 0; i < m; i++){ + dp[i][0] = 1; + } + for(int j = 0; j < n; j++){ + dp[0][j] = 1; + } + for(int i = 1; i < m; i++){ + for(int j = 1; j < n; j++){ + dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; + } + } + return dp[m - 1][n - 1]; + } + +} +``` + + + +方法二，法一的优化方法，时间复杂度$O(m * n)$，空间复杂度$O(n)$。 + +```Java +class Solution { + public int uniquePaths(int m, int n) { + int[] dp = new int[n]; + for(int i = 0; i < n; i++){ + dp[i] = 1; + } + for(int i = 1; i < m; i++){ + for(int j = 1; j < n; j++){ + dp[j] += dp[j - 1]; + } + } + return dp[n - 1]; + } + +} +``` + + + +方法三，排列组合： + +从左上角移动到右下角一共需要移动 `m + n - 2` 次，其中 `m - 1` 次向下移动，`n - 1` 次向右移动。因此路径的总数是从 `m + n - 2` 次的移动中选择 `m - 1` 次的向下移动（或者 `n - 1` 的向右移动）。即 $C_{m+n-2}^{m - 1}$ （或 $C_{m+n-2}^{n - 1}$） $= \frac{(m+n-2)!}{(m-1)!(n-1)!}$。时间复杂度$O(m)$，空间复杂度$O(1)$。 + +```java +class Solution { + public int uniquePaths(int m, int n) { + long ans = 1; + for (int x = n, y = 1; y < m; ++x, ++y) { + ans = ans * x / y; + } + return (int) ans; + } +} +``` + From 0df72b644c5e6f69eaf78d0ad922e21d080d0fb0 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 21 Mar 2023 19:36:05 +0800 Subject: [PATCH 025/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9b0aaa5..9a90600 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | | 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | | 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | | 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | From 626f0ec31a9d2b7b74212cd8cbba39aeb3ecd8ba Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 22 Mar 2023 20:17:37 +0800 Subject: [PATCH 026/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9a90600..98a3007 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | | 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | | 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | | 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | From 66cee973c0f0ce78011b1c3d25e18b4fab526e8e Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 22 Mar 2023 20:33:46 +0800 Subject: [PATCH 027/373] =?UTF-8?q?Create=201626.=20=E6=97=A0=E7=9F=9B?= =?UTF-8?q?=E7=9B=BE=E7=9A=84=E6=9C=80=E4=BD=B3=E7=90=83=E9=98=9F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\275\263\347\220\203\351\230\237.md" | 84 +++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 "Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" diff --git "a/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" "b/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" new file mode 100644 index 0000000..0ce6af0 --- /dev/null +++ "b/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" @@ -0,0 +1,84 @@ +#### 1626. 无矛盾的最佳球队 + +难度：中等 + +--- + +假设你是球队的经理。对于即将到来的锦标赛，你想组合一支总体得分最高的球队。球队的得分是球队中所有球员的分数 **总和** 。 + +然而，球队中的矛盾会限制球员的发挥，所以必须选出一支 **没有矛盾** 的球队。如果一名年龄较小球员的分数 **严格大于** 一名年龄较大的球员，则存在矛盾。同龄球员之间不会发生矛盾。 + +给你两个列表 `scores` 和 `ages`，其中每组 `scores[i]` 和 `ages[i]` 表示第 `i` 名球员的分数和年龄。请你返回 **所有可能的无矛盾球队中得分最高那支的分数** 。 + + **示例 1：** + +``` +输入：scores = [1,3,5,10,15], ages = [1,2,3,4,5] +输出：34 +解释：你可以选中所有球员。 +``` + + **示例 2：** + +``` +输入：scores = [4,5,6,5], ages = [2,1,2,1] +输出：16 +解释：最佳的选择是后 3 名球员。注意，你可以选中多个同龄球员。 +``` + + **示例 3：** + +``` +输入：scores = [1,2,3,5], ages = [8,9,10,1] +输出：6 +解释：最佳的选择是前 3 名球员。 +``` + + **提示：** + +* `1 <= scores.length, ages.length <= 1000` +* `scores.length == ages.length` +* `1 <= scores[i] <= 10^6` +* `1 <= ages[i] <= 1000` + +--- + +排序 + 动态规划： + +`people[i][0], people[i][1]` 分别表示下标为 `i` 的人的分数和年龄。 + +将 `people` 数组按照**分数降序**进行排序，分数相同时，则按照**年龄降序**进行排序。 + +动态规划部分，`dp[i]` 表示最后一名球员的下标为 `i` 时能获得的最大分数，求解 `dp[i]` 需要向前遍历查找年龄满足条件（年龄大于等于当前下标为 `i` ）的最大值情况，遍历数组取最大即可。即[此处](https://github.com/CompetitiveLin/Leetcode/blob/master/Dynamic%20Programming/README.md)的**第一种**情况。 + +这里需要注意的是： + +1. 不能将年龄升序排序。因为是从后向前遍历查找，当分数相同时，如果按年龄升序排序，不满足条件的情况反而出现在数组前面（后遍历到）。 +2. “如果一名年龄较小球员的分数 **严格大于** 一名年龄较大的球员，则存在矛盾。”其反义是：A球员的年龄大于等于B球员的年龄，**且**A球员的分数大于等于B球员的分数，不存在矛盾。 + +```Java +class Solution { + public int bestTeamScore(int[] scores, int[] ages) { + int n = scores.length; + int[][] people = new int[n][2]; + for(int i = 0; i < n; i++){ + people[i][0] = scores[i]; + people[i][1] = ages[i]; + } + Arrays.sort(people, (a, b) -> (a[0] != b[0] ? b[0] - a[0] : b[1] - a[1])); + int[] dp = new int[n]; + dp[0] = people[0][0]; + int ans = dp[0]; + for(int i = 1; i < n; i++){ + for(int j = i - 1; j >= 0; j--){ + if(people[j][1] >= people[i][1]){ + dp[i] = Math.max(dp[i], dp[j]); + } + } + dp[i] += people[i][0]; + ans = Math.max(ans, dp[i]); + } + return ans; + } +} +``` \ No newline at end of file From 6c86254af9c670ba251301cc828d8947edb5c47a Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 22 Mar 2023 20:49:59 +0800 Subject: [PATCH 028/373] =?UTF-8?q?Update=201626.=20=E6=97=A0=E7=9F=9B?= =?UTF-8?q?=E7=9B=BE=E7=9A=84=E6=9C=80=E4=BD=B3=E7=90=83=E9=98=9F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" "b/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" index 0ce6af0..d9cf933 100644 --- "a/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" +++ "b/Dynamic Programming/1626. \346\227\240\347\237\233\347\233\276\347\232\204\346\234\200\344\275\263\347\220\203\351\230\237.md" @@ -54,7 +54,7 @@ 这里需要注意的是： 1. 不能将年龄升序排序。因为是从后向前遍历查找，当分数相同时，如果按年龄升序排序，不满足条件的情况反而出现在数组前面（后遍历到）。 -2. “如果一名年龄较小球员的分数 **严格大于** 一名年龄较大的球员，则存在矛盾。”其反义是：A球员的年龄大于等于B球员的年龄，**且**A球员的分数大于等于B球员的分数，不存在矛盾。 +2. “如果一名年龄较小球员的分数 **严格大于** 一名年龄较大的球员，则存在矛盾。”其反义是：年龄较大球员的分数大于等于另一位球员 **或者** 两球员年龄相同，不存在矛盾。 ```Java class Solution { From e90af70e5f0a9ac1a262873044c0f9bfb98743fc Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 22 Mar 2023 20:59:48 +0800 Subject: [PATCH 029/373] =?UTF-8?q?Create=20300.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E9=80=92=E5=A2=9E=E5=AD=90=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\345\255\220\345\272\217\345\210\227.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" diff --git "a/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" new file mode 100644 index 0000000..3b1813f --- /dev/null +++ "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" @@ -0,0 +1,69 @@ +#### 300. 最长递增子序列 + +难度：中等 + +--- + +给你一个整数数组 `nums` ，找到其中最长严格递增子序列的长度。 + + **子序列**  是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，`[3,6,2,7]` 是数组 `[0,3,1,6,2,2,7]` 的子序列。 + +  + + **示例 1：** + +``` +输入：nums = [10,9,2,5,3,7,101,18] +输出：4 +解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 +``` + + **示例 2：** + +``` +输入：nums = [0,1,0,3,2,3] +输出：4 +``` + + **示例 3：** + +``` +输入：nums = [7,7,7,7,7,7,7] +输出：1 +``` + + **提示：** + +* `1 <= nums.length <= 2500` +* `-10^4 <= nums[i] <= 10^4` + +**进阶：** + +* 你能将算法的时间复杂度降低到 `O(n log(n))` 吗? + +--- + +动态规划： + +与 [1626. 无矛盾的最佳球队 ](https://leetcode.cn/problems/best-team-with-no-conflicts/)类似。 + +```Java +class Solution { + public int lengthOfLIS(int[] nums) { + int n = nums.length; + int[] dp = new int[n]; + dp[0] = 1; + int ans = dp[0]; + for(int i = 1; i < n; i++){ + for(int j = i - 1; j >= 0; j--){ + if(nums[j] < nums[i]){ + dp[i] = Math.max(dp[i], dp[j]); + } + } + dp[i] += 1; + ans = Math.max(ans, dp[i]); + } + return ans; + } +} +``` \ No newline at end of file From 54df730529254d7aa705566e44c58afb6353025e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 22 Mar 2023 21:04:50 +0800 Subject: [PATCH 030/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 98a3007..b452bc7 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | | 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | | 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | From 0b068b70fd348fa7c3ed3adb47317eef15e8a8c3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 30 Mar 2023 08:41:50 +0800 Subject: [PATCH 031/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b452bc7..02aa6a6 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | | 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | | 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | From 20cbe19dc9e1050902b55f3f2308e9cd7f37dbad Mon Sep 17 00:00:00 2001 From: NUC11 Date: Thu, 30 Mar 2023 20:06:02 +0800 Subject: [PATCH 032/373] =?UTF-8?q?Create=201637.=20=E4=B8=A4=E7=82=B9?= =?UTF-8?q?=E4=B9=8B=E9=97=B4=E4=B8=8D=E5=8C=85=E5=90=AB=E4=BB=BB=E4=BD=95?= =?UTF-8?q?=E7=82=B9=E7=9A=84=E6=9C=80=E5=AE=BD=E5=9E=82=E7=9B=B4=E5=8C=BA?= =?UTF-8?q?=E5=9F=9F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...02\347\233\264\345\214\272\345\237\237.md" | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 "Sort/1637. \344\270\244\347\202\271\344\271\213\351\227\264\344\270\215\345\214\205\345\220\253\344\273\273\344\275\225\347\202\271\347\232\204\346\234\200\345\256\275\345\236\202\347\233\264\345\214\272\345\237\237.md" diff --git "a/Sort/1637. \344\270\244\347\202\271\344\271\213\351\227\264\344\270\215\345\214\205\345\220\253\344\273\273\344\275\225\347\202\271\347\232\204\346\234\200\345\256\275\345\236\202\347\233\264\345\214\272\345\237\237.md" "b/Sort/1637. \344\270\244\347\202\271\344\271\213\351\227\264\344\270\215\345\214\205\345\220\253\344\273\273\344\275\225\347\202\271\347\232\204\346\234\200\345\256\275\345\236\202\347\233\264\345\214\272\345\237\237.md" new file mode 100644 index 0000000..cf24822 --- /dev/null +++ "b/Sort/1637. \344\270\244\347\202\271\344\271\213\351\227\264\344\270\215\345\214\205\345\220\253\344\273\273\344\275\225\347\202\271\347\232\204\346\234\200\345\256\275\345\236\202\347\233\264\345\214\272\345\237\237.md" @@ -0,0 +1,53 @@ +#### 1637. 两点之间不包含任何点的最宽垂直区域 + +难度：中等 + +--- + +给你 `n` 个二维平面上的点 `points` ，其中 `points[i] = [xi, yi]` ，请你返回两点之间内部不包含任何点的  **最宽垂直区域** 的宽度。 + + **垂直区域** 的定义是固定宽度，而 y 轴上无限延伸的一块区域（也就是高度为无穷大）。 **最宽垂直区域** 为宽度最大的一个垂直区域。 + +请注意，垂直区域  **边上**  的点  **不在**  区域内。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/31/points3.png)​ +``` +输入：points = [[8,7],[9,9],[7,4],[9,7]] +输出：1 +解释：红色区域和蓝色区域都是最优区域。 +``` + + **示例 2：** + +``` +输入：points = [[3,1],[9,0],[1,0],[1,4],[5,3],[8,8]] +输出：3 +``` + + **提示：** + +* `n == points.length` +* `2 <= n <= 10^5` +* `points[i].length == 2` +* `0 <= xi, yi <= 10^9` + +--- + +自定义排序： + +无需考虑纵坐标，相邻两点横坐标差的最大值即是所要求的值。 + +```Java +class Solution { + public int maxWidthOfVerticalArea(int[][] points) { + Arrays.sort(points, (a, b) -> (a[0] - b[0])); + int ans = 0; + for(int i = 1; i < points.length; i++){ + ans = Math.max(points[i][0] - points[i - 1][0], ans); + } + return ans; + } +} +``` \ No newline at end of file From 064d6ef7d50cb362535b89837a5de18a5b033116 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 30 Mar 2023 20:11:18 +0800 Subject: [PATCH 033/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 02aa6a6..83dce83 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | | 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | From 1eda99346ef48d59613fa6c9159ddfaa78974e4c Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 3 Apr 2023 22:20:44 +0800 Subject: [PATCH 034/373] =?UTF-8?q?Create=201053.=20=E4=BA=A4=E6=8D=A2?= =?UTF-8?q?=E4=B8=80=E6=AC=A1=E7=9A=84=E5=85=88=E5=89=8D=E6=8E=92=E5=88=97?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...10\345\211\215\346\216\222\345\210\227.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Greedy/1053. \344\272\244\346\215\242\344\270\200\346\254\241\347\232\204\345\205\210\345\211\215\346\216\222\345\210\227.md" diff --git "a/Greedy/1053. \344\272\244\346\215\242\344\270\200\346\254\241\347\232\204\345\205\210\345\211\215\346\216\222\345\210\227.md" "b/Greedy/1053. \344\272\244\346\215\242\344\270\200\346\254\241\347\232\204\345\205\210\345\211\215\346\216\222\345\210\227.md" new file mode 100644 index 0000000..0502b84 --- /dev/null +++ "b/Greedy/1053. \344\272\244\346\215\242\344\270\200\346\254\241\347\232\204\345\205\210\345\211\215\346\216\222\345\210\227.md" @@ -0,0 +1,69 @@ +#### 1053. 交换一次的先前排列 + +难度：中等 + +--- + +给你一个正整数数组 `arr`（可能存在重复的元素），请你返回可在  **一次交换** （交换两数字 `arr[i]` 和 `arr[j]` 的位置）后得到的、按字典序排列小于 `arr` 的最大排列。 + +如果无法这么操作，就请返回原数组。 + + **示例 1：** + +``` +输入：arr = [3,2,1] +输出：[3,1,2] +解释：交换 2 和 1 +``` + + **示例 2：** + +``` +输入：arr = [1,1,5] +输出：[1,1,5] +解释：已经是最小排列 +``` + + **示例 3：** + +``` +输入：arr = [1,9,4,6,7] +输出：[1,7,4,6,9] +解释：交换 9 和 7 +``` + + **提示：** + +* `1 <= arr.length <= 10^4` +* `1 <= arr[i] <= 10^4` + +--- + +贪心： + +1. 首先，当前序列开始从后往前找，找到第一个降序的位置（`A[i]>A[i+1]`），则必存在能构造比当前小的序列。 + +2. 接着，在 `A[i]` 后面的数字中，找出小于 `A[i]` 且最接近 `A[i]` 的值的数字并和 `A[i]` 交换，经过第一步的倒序遍历后，`A[i]` 后面的数字一定是**非降序**的。 + +```Java +class Solution { + public int[] prevPermOpt1(int[] arr) { + int n = arr.length; + for(int i = n - 2; i >= 0; i--){ + if(arr[i] > arr[i + 1]){ + int j = n - 1; + while(arr[j] >= arr[i] || arr[j] == arr[j - 1]) j--; + swap(arr, i , j); + break; + } + } + return arr; + } + + private void swap(int[] arr, int i, int j){ + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } +} +``` \ No newline at end of file From 5de0fc017ee45111684303a7aba065dd2b814613 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 3 Apr 2023 22:26:49 +0800 Subject: [PATCH 035/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 83dce83..e639735 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | | 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | | 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | From a4d34a918aa7524e1264df61c0ecb283ca93c39c Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 9 Apr 2023 11:26:25 +0800 Subject: [PATCH 036/373] =?UTF-8?q?Create=20739.=20=E6=AF=8F=E6=97=A5?= =?UTF-8?q?=E6=B8=A9=E5=BA=A6.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...17\346\227\245\346\270\251\345\272\246.md" | 85 +++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 "Monotonic Stack/739. \346\257\217\346\227\245\346\270\251\345\272\246.md" diff --git "a/Monotonic Stack/739. \346\257\217\346\227\245\346\270\251\345\272\246.md" "b/Monotonic Stack/739. \346\257\217\346\227\245\346\270\251\345\272\246.md" new file mode 100644 index 0000000..ac13e1c --- /dev/null +++ "b/Monotonic Stack/739. \346\257\217\346\227\245\346\270\251\345\272\246.md" @@ -0,0 +1,85 @@ +#### 739. 每日温度 + +难度：中等 + +--- + +给定一个整数数组 `temperatures` ，表示每天的温度，返回一个数组 `answer` ，其中 `answer[i]` 是指对于第 `i` 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 `0` 来代替。 + + **示例 1:** + +``` +输入: temperatures = [73,74,75,71,69,72,76,73] +输出: [1,1,4,2,1,1,0,0] +``` + + **示例 2:** + +``` +输入: temperatures = [30,40,50,60] +输出: [1,1,1,0] +``` + + **示例 3:** + +``` +输入: temperatures = [30,60,90] +输出: [1,1,0] +``` + + **提示：** + +* `1 <= temperatures.length <= 10^5` +* `30 <= temperatures[i] <= 100` + +--- + +方法一，动态规划 + 双指针： + +从后向前遍历，在每个循环中会**跳过一定的区域**，思路类似于[这个](https://leetcode.cn/problems/daily-temperatures/solution/jie-ti-si-lu-by-pulsaryu/)。 + +时间复杂度$O(N)$，空间复杂度$O(N)$。 + +![](https://raw.githubusercontent.com/CompetitiveLin/ImageHostingService/picgo/imgs/202304091057244.png) + +```Java +class Solution { + public int[] dailyTemperatures(int[] temperatures) { + int n = temperatures.length; + int[] dp = new int[n]; + dp[n - 1] = 0; + for(int i = n - 2; i >= 0; i--){ + int index = i + 1, cnt = 1; + while(dp[index] != 0 && temperatures[index] <= temperatures[i]){ + cnt += dp[index]; + index += dp[index]; + } + if(temperatures[index] <= temperatures[i]) dp[i] = 0; + else dp[i] = cnt; + } + return dp; + } +} +``` + +方法二，单调栈： + +维护一个存储下标的单调栈，**从栈底到栈顶的下标对应的温度列表中的温度依次递减**。如果一个下标在单调栈里，则表示尚未找到下一次温度更高的下标。每次弹出栈中的元素（下标），都能得到该下标的答案（下一次温度更高的下标，为当前下标减去弹出元素的下标）。 + +```java +class Solution { + public int[] dailyTemperatures(int[] temperatures) { + int n = temperatures.length; + ArrayDeque stack = new ArrayDeque<>(); + int[] ans = new int[n]; + for(int i = 0; i < n; i++){ + while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){ + ans[stack.peek()] = i - stack.pop(); + } + stack.push(i); + } + return ans; + } +} +``` + From bf55c7537b9590c6e566c45a6f2a46ed5009946a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 9 Apr 2023 11:30:17 +0800 Subject: [PATCH 037/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index e639735..23d4396 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | | 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | | 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | From dc93b7b8068c7828eb3db205130260a60516dfac Mon Sep 17 00:00:00 2001 From: NUC11 Date: Fri, 14 Apr 2023 20:15:21 +0800 Subject: [PATCH 038/373] =?UTF-8?q?Create=201023.=20=E9=A9=BC=E5=B3=B0?= =?UTF-8?q?=E5=BC=8F=E5=8C=B9=E9=85=8D.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...60\345\274\217\345\214\271\351\205\215.md" | 108 ++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 "Two Pointers/1023. \351\251\274\345\263\260\345\274\217\345\214\271\351\205\215.md" diff --git "a/Two Pointers/1023. \351\251\274\345\263\260\345\274\217\345\214\271\351\205\215.md" "b/Two Pointers/1023. \351\251\274\345\263\260\345\274\217\345\214\271\351\205\215.md" new file mode 100644 index 0000000..945c891 --- /dev/null +++ "b/Two Pointers/1023. \351\251\274\345\263\260\345\274\217\345\214\271\351\205\215.md" @@ -0,0 +1,108 @@ +#### 1023. 驼峰式匹配 + +难度：中等 + +--- + +如果我们可以将 **小写字母** 插入模式串 `pattern` 得到待查询项 `query`，那么待查询项与给定模式串匹配。（我们可以在任何位置插入每个字符，也可以插入 0 个字符。） + +给定待查询列表 `queries`，和模式串 `pattern`，返回由布尔值组成的答案列表 `answer`。只有在待查项 `queries[i]` 与模式串 `pattern` 匹配时， `answer[i]` 才为 `true`，否则为 `false`。 + + **示例 1：** + +``` +输入：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FB" +输出：[true,false,true,true,false] +示例： +"FooBar" 可以这样生成："F" + "oo" + "B" + "ar"。 +"FootBall" 可以这样生成："F" + "oot" + "B" + "all". +"FrameBuffer" 可以这样生成："F" + "rame" + "B" + "uffer". +``` + + **示例 2：** + +``` +输入：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBa" +输出：[true,false,true,false,false] +解释： +"FooBar" 可以这样生成："Fo" + "o" + "Ba" + "r". +"FootBall" 可以这样生成："Fo" + "ot" + "Ba" + "ll". +``` + + **示例 3：** + +``` +输入：queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBaT" +输出：[false,true,false,false,false] +解释： +"FooBarTest" 可以这样生成："Fo" + "o" + "Ba" + "r" + "T" + "est". +``` + + **提示：** + +1. `1 <= queries.length <= 100` +2. `1 <= queries[i].length <= 100` +3. `1 <= pattern.length <= 100` +4. 所有字符串都仅由大写和小写英文字母组成。 + +--- + +双指针： + +第一个指针 `c1 = queries[i].charAt(first)`，另一个指针 `c2 = pattern.charAt(second)`， 分四种情况： + +1. `c1` 和 `c2` 均为大写； +2. `c1` 和 `c2` 均为小写； +3. `c1` 小写，`c2` 大写； +4. `c1` 大写，`c2` 小写； + +遍历结束后，如果第一个指针没有超出范围，则继续遍历第一个字符串，如果后续存在大写字母，则此次查询结果为 `false`。 + +如果第二个指针没有超出范围，意味着第一个字符串里有第二个字符串没有的字符，因此此次查询结果为 `false`。 + +```Java +class Solution { + public List camelMatch(String[] queries, String pattern) { + List ans = new ArrayList<>(); + for(int i = 0; i < queries.length; i++){ + boolean flag = true; + int first = 0, second = 0; + while(first < queries[i].length() && second < pattern.length()){ + char c1 = queries[i].charAt(first), c2 = pattern.charAt(second); + if(Character.isUpperCase(c1) && Character.isUpperCase(c2)){ + if(c1 == c2){ + first++; + second++; + } else { + flag = false; + break; + } + } + else if(Character.isLowerCase(c1) && Character.isLowerCase(c2)){ + first++; + if(c1 == c2) second++; + } + else if(Character.isLowerCase(c1) && Character.isUpperCase(c2)){ + first++; + } else { + flag = false; + break; + } + } + while(first < queries[i].length()){ + char c1 = queries[i].charAt(first); + if(Character.isUpperCase(c1)){ + flag = false; + break; + } + first++; + } + if(second < pattern.length()){ + flag = false; + } + ans.add(flag); + } + return ans; + } +} +``` \ No newline at end of file From 35e9e00c373972344d2756868188763f5ef5886e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 14 Apr 2023 20:19:26 +0800 Subject: [PATCH 039/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 23d4396..7a699c5 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | | 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | | 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | | 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | From f51b3ed549ec2787389785e1b48282da6279b103 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 30 Apr 2023 20:01:44 +0800 Subject: [PATCH 040/373] =?UTF-8?q?Create=201033.=20=E7=A7=BB=E5=8A=A8?= =?UTF-8?q?=E7=9F=B3=E5=AD=90=E7=9B=B4=E5=88=B0=E8=BF=9E=E7=BB=AD.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...64\345\210\260\350\277\236\347\273\255.md" | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 "Greedy/1033. \347\247\273\345\212\250\347\237\263\345\255\220\347\233\264\345\210\260\350\277\236\347\273\255.md" diff --git "a/Greedy/1033. \347\247\273\345\212\250\347\237\263\345\255\220\347\233\264\345\210\260\350\277\236\347\273\255.md" "b/Greedy/1033. \347\247\273\345\212\250\347\237\263\345\255\220\347\233\264\345\210\260\350\277\236\347\273\255.md" new file mode 100644 index 0000000..e88d14f --- /dev/null +++ "b/Greedy/1033. \347\247\273\345\212\250\347\237\263\345\255\220\347\233\264\345\210\260\350\277\236\347\273\255.md" @@ -0,0 +1,58 @@ +#### 1033. 移动石子直到连续 + +难度：中等 + +--- + +三枚石子放置在数轴上，位置分别为 `a`，`b`，`c`。 + +每一回合，你可以从两端之一拿起一枚石子（位置最大或最小），并将其放入两端之间的任一空闲位置。形式上，假设这三枚石子当前分别位于位置 `x, y, z` 且 `x < y < z`。那么就可以从位置 `x` 或者是位置 `z` 拿起一枚石子，并将该石子移动到某一整数位置 `k` 处，其中 `x < k < z` 且 `k != y`。 + +当你无法进行任何移动时，即，这些石子的位置连续时，游戏结束。 + +要使游戏结束，你可以执行的最小和最大移动次数分别是多少？ 以长度为 2 的数组形式返回答案：`answer = [minimum_moves, maximum_moves]` + + **示例 1：** + +``` +输入：a = 1, b = 2, c = 5 +输出：[1, 2] +解释：将石子从 5 移动到 4 再移动到 3，或者我们可以直接将石子移动到 3。 +``` + + **示例 2：** + +``` +输入：a = 4, b = 3, c = 2 +输出：[0, 0] +解释：我们无法进行任何移动。 +``` + + **提示：** + +1. `1 <= a <= 100` +2. `1 <= b <= 100` +3. `1 <= c <= 100` +4. `a != b, b != c, c != a` + +--- + +贪心： + +分类讨论，当三个数连续时，显然最小步骤为零；如果三个数中有两个数连续或者差为二，则最小步骤为一，因为将另一个数移动至另一边或中间；其他情况最小步骤为二。另外，不管什么情况下，最大步骤都是两边数相减再减二。 + +```Java +class Solution { + public int[] numMovesStones(int a, int b, int c) { + int maxn = Math.max(Math.max(a, b), c); + int minn = Math.min(Math.min(a, b), c); + int midd = a + b + c - maxn - minn; + int[] ans = new int[2]; + if(maxn - midd == 1 && midd - minn == 1) ans[0] = 0; + else if(maxn - midd <= 2 || midd - minn <= 2) ans[0] = 1; + else ans[0] = 2; + ans[1] = maxn - minn - 2; + return ans; + } +} +``` \ No newline at end of file From e0a96dbf2b823a52fc99d52f6cb6f69534aad2bf Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 30 Apr 2023 20:01:46 +0800 Subject: [PATCH 041/373] =?UTF-8?q?Create=2049.=20=E5=AD=97=E6=AF=8D?= =?UTF-8?q?=E5=BC=82=E4=BD=8D=E8=AF=8D=E5=88=86=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...15\350\257\215\345\210\206\347\273\204.md" | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 "Hash Table/49. \345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" diff --git "a/Hash Table/49. \345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" "b/Hash Table/49. \345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" new file mode 100644 index 0000000..ca85659 --- /dev/null +++ "b/Hash Table/49. \345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" @@ -0,0 +1,70 @@ +#### 49. 字母异位词分组 + +难度：中等 + +--- + +给你一个字符串数组，请你将 **字母异位词** 组合在一起。可以按任意顺序返回结果列表。 + + **字母异位词** 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。 + + **示例 1:** + +``` +输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"] +输出: [["bat"],["nat","tan"],["ate","eat","tea"]] +``` + + **示例 2:** + +``` +输入: strs = [""] +输出: [[""]] +``` + + **示例 3:** + +``` +输入: strs = ["a"] +输出: [["a"]] +``` + + **提示：** + +* `1 <= strs.length <= 10^4` +* `0 <= strs[i].length <= 100` +* `strs[i]` 仅包含小写字母 + +--- + +哈希： + +对于字符串数组中的每一个字符串，按其字典序排序（实现方式是用长度为26的数组记录），如果在哈希表中存在该排序后的字符串，则存入列表中。 + +```Java +class Solution { + public List> groupAnagrams(String[] strs) { + HashMap> hashmap = new HashMap<>(); + int n = strs.length; + for(int i = 0; i < n; i++){ + int[] alphabet = new int[26]; + for(int j = 0; j < strs[i].length(); j++){ + char c = strs[i].charAt(j); + alphabet[c - 'a'] ++; + } + StringBuilder sb = new StringBuilder(); + for(int j = 0; j < 26; j++){ + while(alphabet[j] != 0){ + sb.append(j + 'a'); + alphabet[j]--; + } + } + String key = sb.toString(); + List temp = hashmap.getOrDefault(key, new ArrayList()); + temp.add(strs[i]); + hashmap.put(key, temp); + } + return new ArrayList>(hashmap.values()); + } +} +``` \ No newline at end of file From 5a4372744a6da560391e01ce887189af41abf068 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 30 Apr 2023 20:05:36 +0800 Subject: [PATCH 042/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 7a699c5..8f51dd2 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | +| 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | | 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | | 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | | 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | From a318f4c71da002121a107440e66ae1292b4d25bd Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 1 May 2023 12:34:58 +0800 Subject: [PATCH 043/373] =?UTF-8?q?Create=201376.=20=E9=80=9A=E7=9F=A5?= =?UTF-8?q?=E6=89=80=E6=9C=89=E5=91=98=E5=B7=A5=E6=89=80=E9=9C=80=E7=9A=84?= =?UTF-8?q?=E6=97=B6=E9=97=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\347\232\204\346\227\266\351\227\264.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Breadth First Search/1376. \351\200\232\347\237\245\346\211\200\346\234\211\345\221\230\345\267\245\346\211\200\351\234\200\347\232\204\346\227\266\351\227\264.md" diff --git "a/Breadth First Search/1376. \351\200\232\347\237\245\346\211\200\346\234\211\345\221\230\345\267\245\346\211\200\351\234\200\347\232\204\346\227\266\351\227\264.md" "b/Breadth First Search/1376. \351\200\232\347\237\245\346\211\200\346\234\211\345\221\230\345\267\245\346\211\200\351\234\200\347\232\204\346\227\266\351\227\264.md" new file mode 100644 index 0000000..1f319f0 --- /dev/null +++ "b/Breadth First Search/1376. \351\200\232\347\237\245\346\211\200\346\234\211\345\221\230\345\267\245\346\211\200\351\234\200\347\232\204\346\227\266\351\227\264.md" @@ -0,0 +1,82 @@ +#### 1376. 通知所有员工所需的时间 + +难度：中等 + +--- + +公司里有 `n` 名员工，每个员工的 ID 都是独一无二的，编号从 `0` 到 `n - 1`。公司的总负责人通过 `headID` 进行标识。 + +在 `manager` 数组中，每个员工都有一个直属负责人，其中 `manager[i]` 是第 `i` 名员工的直属负责人。对于总负责人，`manager[headID] = -1`。题目保证从属关系可以用树结构显示。 + +公司总负责人想要向公司所有员工通告一条紧急消息。他将会首先通知他的直属下属们，然后由这些下属通知他们的下属，直到所有的员工都得知这条紧急消息。 + +第 `i` 名员工需要 `informTime[i]` 分钟来通知它的所有直属下属（也就是说在 `informTime[i]` 分钟后，他的所有直属下属都可以开始传播这一消息）。 + +返回通知所有员工这一紧急消息所需要的 **分钟数** 。 + + **示例 1：** + +``` +输入：n = 1, headID = 0, manager = [-1], informTime = [0] +输出：0 +解释：公司总负责人是该公司的唯一一名员工。 +``` + + **示例 2：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/03/08/graph.png) + +``` +输入：n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0] +输出：1 +解释：id = 2 的员工是公司的总负责人，也是其他所有员工的直属负责人，他需要 1 分钟来通知所有员工。 +上图显示了公司员工的树结构。 +``` + + **提示：** + +* `1 <= n <= 10^5` +* `0 <= headID < n` +* `manager.length == n` +* `0 <= manager[i] < n` +* `manager[headID] == -1` +* `informTime.length == n` +* `0 <= informTime[i] <= 1000` +* 如果员工 `i` 没有下属，`informTime[i] == 0` 。 +* 题目 **保证** 所有员工都可以收到通知。 + +--- + +广度优先搜索： + +由原 `manager` 数组构造一个邻接表，再构造一对 `` ，最后只需要取最大的 `time` 即可。 + +```Java +class Solution { + public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) { + int res = 0; + List[] adj = new List[n]; + for(int i = 0; i < n; i++){ + adj[i] = new ArrayList(); + } + for(int i = 0; i < n; i++){ + if(manager[i] != -1){ + adj[manager[i]].add(i); + } + } + ArrayDeque> queue = new ArrayDeque>(); + queue.add(new Pair<>(headID, 0)); + while(!queue.isEmpty()){ + int sz = queue.size(); + for(int i = 0; i < sz; i++){ + Pair temp = queue.poll(); + res = Math.max(res, temp.getValue()); + for(int j = 0; j < adj[temp.getKey()].size(); j++){ + queue.add(new Pair<>(adj[temp.getKey()].get(j), temp.getValue() + informTime[temp.getKey()])); + } + } + } + return res; + } +} +``` \ No newline at end of file From bf351b274688f8e5d831718b9e359e1f4020acf5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 1 May 2023 12:38:54 +0800 Subject: [PATCH 044/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8f51dd2..4e4e0fe 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | | 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | | 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | | 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | From c04210880b04a6f8eb0d1eb6b73071db8328422a Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Tue, 2 May 2023 11:11:18 +0800 Subject: [PATCH 045/373] =?UTF-8?q?Create=20970.=20=E5=BC=BA=E6=95=B4?= =?UTF-8?q?=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \345\274\272\346\225\264\346\225\260.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Enumerate/970. \345\274\272\346\225\264\346\225\260.md" diff --git "a/Enumerate/970. \345\274\272\346\225\264\346\225\260.md" "b/Enumerate/970. \345\274\272\346\225\264\346\225\260.md" new file mode 100644 index 0000000..8a4660f --- /dev/null +++ "b/Enumerate/970. \345\274\272\346\225\264\346\225\260.md" @@ -0,0 +1,61 @@ +#### 970. 强整数 + +难度：中等 + +--- + +给定三个整数 `x` 、 `y` 和 `bound` ，返回 _值小于或等于 `bound` 的所有  **强整数**  组成的列表_ 。 + +如果某一整数可以表示为 `x^i + y^j` ，其中整数 `i >= 0` 且 `j >= 0`，那么我们认为该整数是一个  **强整数**  。 + +你可以按 **任何顺序** 返回答案。在你的回答中，每个值 **最多** 出现一次。 + + **示例 1：** + +``` +输入：x = 2, y = 3, bound = 10 +输出：[2,3,4,5,7,9,10] +解释： +2 = 20 + 30 +3 = 21 + 30 +4 = 20 + 31 +5 = 21 + 31 +7 = 22 + 31 +9 = 23 + 30 +10 = 20 + 32 +``` + + **示例 2：** + +``` +输入：x = 3, y = 5, bound = 15 +输出：[2,4,6,8,10,14] +``` + + **提示：** + +* `1 <= x, y <= 100` +* `0 <= bound <= 10^6` + +--- + +枚举： + +控制循环的范围即可，并且需要用 `HashSet` 去除重复答案。 + +```Java +class Solution { + public List powerfulIntegers(int x, int y, int bound) { + Set set = new HashSet(); + for(int i = 1; i <= bound; i *= x){ + for(int j = 1; i + j <= bound; j *= y){ + set.add(i + j); + if(y == 1) break; + } + if(x == 1) break; + + } + return new ArrayList(set); + } +} +``` \ No newline at end of file From b8663b79914bd8f8ef058f3fc6ce232d611589e7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 2 May 2023 11:15:10 +0800 Subject: [PATCH 046/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 4e4e0fe..1de0405 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | | 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | | 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | | 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | From 50438461545fa993f1250977e5989a29db930a2d Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 3 May 2023 22:17:28 +0800 Subject: [PATCH 047/373] =?UTF-8?q?Create=201003.=20=E6=A3=80=E6=9F=A5?= =?UTF-8?q?=E6=9B=BF=E6=8D=A2=E5=90=8E=E7=9A=84=E8=AF=8D=E6=98=AF=E5=90=A6?= =?UTF-8?q?=E6=9C=89=E6=95=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...57\345\220\246\346\234\211\346\225\210.md" | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 "Stack/1003. \346\243\200\346\237\245\346\233\277\346\215\242\345\220\216\347\232\204\350\257\215\346\230\257\345\220\246\346\234\211\346\225\210.md" diff --git "a/Stack/1003. \346\243\200\346\237\245\346\233\277\346\215\242\345\220\216\347\232\204\350\257\215\346\230\257\345\220\246\346\234\211\346\225\210.md" "b/Stack/1003. \346\243\200\346\237\245\346\233\277\346\215\242\345\220\216\347\232\204\350\257\215\346\230\257\345\220\246\346\234\211\346\225\210.md" new file mode 100644 index 0000000..8b07599 --- /dev/null +++ "b/Stack/1003. \346\243\200\346\237\245\346\233\277\346\215\242\345\220\216\347\232\204\350\257\215\346\230\257\345\220\246\346\234\211\346\225\210.md" @@ -0,0 +1,75 @@ +#### 1003. 检查替换后的词是否有效 + +难度：中等 + +--- + +给你一个字符串 `s` ，请你判断它是否 **有效** 。 + +字符串 `s` **有效** 需要满足：假设开始有一个空字符串 `t = ""` ，你可以执行 **任意次** 下述操作将 `t` **转换为** `s` ： + +* 将字符串 `"abc"` 插入到 `t` 中的任意位置。形式上，`t` 变为 `tleft + "abc" + tright`，其中 `t == tleft + tright` 。注意，`tleft` 和 `tright` 可能为 **空** 。 + +如果字符串 `s` 有效，则返回 `true`；否则，返回 `false`。 + + **示例 1：** + +``` +输入：s = "aabcbc" +输出：true +解释： +"" -> "abc" -> "aabcbc" +因此，"aabcbc" 有效。 +``` + + **示例 2：** + +``` +输入：s = "abcabcababcc" +输出：true +解释： +"" -> "abc" -> "abcabc" -> "abcabcabc" -> "abcabcababcc" +因此，"abcabcababcc" 有效。 +``` + + **示例 3：** + +``` +输入：s = "abccba" +输出：false +解释：执行操作无法得到 "abccba" 。 +``` + + **提示：** + +* `1 <= s.length <= 2 * 10^4` +* `s` 由字母 `'a'`、`'b'` 和 `'c'` 组成 + +--- + +栈： + +遍历字符串，当**栈的长度大于等于三**时，检查栈的后三位（只能通过连续弹出后三位校验）是否是 `abc`，如果是，则同时弹出这三个字符，否则，重新入栈。 + +```Java +class Solution { + public boolean isValid(String s) { + ArrayDeque stack = new ArrayDeque<>(); + for(int i = 0; i < s.length(); i++){ + char c = s.charAt(i); + stack.push(c); + if(stack.size() >= 3){ + c = stack.pop(); + char temp1 = stack.pop(), temp2 = stack.pop(); + if(c != 'c' || temp1 != 'b' || temp2 != 'a'){ + stack.push(temp2); + stack.push(temp1); + stack.push(c); + } + } + } + if(stack.isEmpty()) return true; + return false; + } +} +``` \ No newline at end of file From fb7314147057f7da4d79d6786ed9cf64ce5b2755 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 May 2023 22:23:21 +0800 Subject: [PATCH 048/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 1de0405..8d1d92d 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | | 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | | 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | | 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | From 9bd471027fab4af7dc0c02fced531da9b3d7f324 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 4 May 2023 16:37:19 +0800 Subject: [PATCH 049/373] =?UTF-8?q?Create=20128.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E8=BF=9E=E7=BB=AD=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\347\273\255\345\272\217\345\210\227.md" | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 "Hash Table/128. \346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" diff --git "a/Hash Table/128. \346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" "b/Hash Table/128. \346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" new file mode 100644 index 0000000..e1ce15e --- /dev/null +++ "b/Hash Table/128. \346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" @@ -0,0 +1,58 @@ +#### 128. 最长连续序列 + +难度：中等 + +--- + +给定一个未排序的整数数组 `nums` ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 + +请你设计并实现时间复杂度为 `O(n)` 的算法解决此问题。 + + **示例 1：** + +``` +输入：nums = [100,4,200,1,3,2] +输出：4 +解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。 +``` + + **示例 2：** + +``` +输入：nums = [0,3,7,2,5,8,4,6,0,1] +输出：9 +``` + + **提示：** + +* `0 <= nums.length <= 10^5` +* `-10^9 <= nums[i] <= 10^9` + +--- + +哈希集合： + +遍历集合中的每个元素，如果是一串连续数字的第一个数字（例如，`3456` 中的 `3`），那么继续使用 `contains()` 方法在集合中查找后续数字，直到结束；否则跳过该元素。 + +```Java +class Solution { + public int longestConsecutive(int[] nums) { + int ans = 0, n = nums.length; + HashSet hashset = new HashSet<>(); + for(int i = 0; i < n; i++){ + hashset.add(nums[i]); + } + for(int num: hashset){ + if(!hashset.contains(num - 1)){ + int temp = 1; + while(hashset.contains(num + 1)){ + num++; + temp++; + } + ans = Math.max(ans, temp); + } + } + return ans; + } +} +``` \ No newline at end of file From f8533c116082eb1163cbc2c6d3af2833f46f314b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 4 May 2023 16:41:12 +0800 Subject: [PATCH 050/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8d1d92d..0278b39 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | | 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | | 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | | 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | From cf9073cb9d5e5b237ec963e066ca2de507bcd14c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 5 May 2023 20:16:16 +0800 Subject: [PATCH 051/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0278b39..1f941b5 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | | 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | | 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | | 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | From 6578a8af7c5d78dd8d0a5e7f92603fbc7b21b7a0 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sat, 6 May 2023 23:02:45 +0800 Subject: [PATCH 052/373] =?UTF-8?q?Create=201419.=20=E6=95=B0=E9=9D=92?= =?UTF-8?q?=E8=9B=99.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \346\225\260\351\235\222\350\233\231.md" | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 "Simulation/1419. \346\225\260\351\235\222\350\233\231.md" diff --git "a/Simulation/1419. \346\225\260\351\235\222\350\233\231.md" "b/Simulation/1419. \346\225\260\351\235\222\350\233\231.md" new file mode 100644 index 0000000..34f909f --- /dev/null +++ "b/Simulation/1419. \346\225\260\351\235\222\350\233\231.md" @@ -0,0 +1,76 @@ +#### 1419. 数青蛙 + +难度：中等 + +--- + +给你一个字符串 `croakOfFrogs`，它表示不同青蛙发出的蛙鸣声（字符串 `"croak"` ）的组合。由于同一时间可以有多只青蛙呱呱作响，所以 `croakOfFrogs` 中会混合多个 `“croak”` _。_ + +请你返回模拟字符串中所有蛙鸣所需不同青蛙的最少数目。 + +要想发出蛙鸣 "croak"，青蛙必须 **依序** 输出 `‘c’, ’r’, ’o’, ’a’, ’k’` 这 5 个字母。如果没有输出全部五个字母，那么它就不会发出声音。如果字符串 `croakOfFrogs` 不是由若干有效的 "croak" 字符混合而成，请返回 `-1` 。 + + **示例 1：** + +``` +输入：croakOfFrogs = "croakcroak" +输出：1 +解释：一只青蛙 “呱呱” 两次 +``` + + **示例 2：** + +``` +输入：croakOfFrogs = "crcoakroak" +输出：2 +解释：最少需要两只青蛙，“呱呱” 声用黑体标注 +第一只青蛙 "crcoakroak" +第二只青蛙 "crcoakroak" +``` + + **示例 3：** + +``` +输入：croakOfFrogs = "croakcrook" +输出：-1 +解释：给出的字符串不是 "croak" 的有效组合。 +``` + + **提示：** + +* `1 <= croakOfFrogs.length <= 10^5` +* 字符串中的字符只有 `'c'`, `'r'`, `'o'`, `'a'` 或者 `'k'` + +--- + +模拟： + +方法比较巧妙，遍历字符串，如果当前字符为 `c`，意味着当前青蛙数加一；如果为 `k`，则当前青蛙数减一；其他只需要考虑字符串不是由若干有效的 `croak` 字符混合而成的情况即可。 + +```Java +class Solution { + public int minNumberOfFrogs(String croakOfFrogs) { + int n = croakOfFrogs.length(); + if(n % 5 != 0) return -1; + int[] temp = new int[5]; + int ans = 0, cur_num = 0; + for(int i = 0; i < n; i++){ + char c = croakOfFrogs.charAt(i); + int index = 0; + if(c == 'r') index = 1; + else if(c == 'o') index = 2; + else if(c == 'a') index = 3; + else if(c == 'k') index = 4; + temp[index]++; + if(index == 0){ + cur_num++; + ans = Math.max(ans, cur_num); + } + else if(index == 4) cur_num--; + if(index != 0 && temp[index] > temp[index - 1]) return -1; + } + for(int i = 0; i < 5; i++) if(temp[i] != n / 5) return -1; + return ans; + } +} +``` \ No newline at end of file From 90e1233d0839f64d400129ae0e020b4adde6f96c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 6 May 2023 23:09:34 +0800 Subject: [PATCH 053/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 1f941b5..3685ebb 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | | 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | | 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | | 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | From a26eaaa6e7e1b018e94297c5bf0a9c4c4cf0f6f7 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 7 May 2023 12:29:06 +0800 Subject: [PATCH 054/373] =?UTF-8?q?Create=201010.=20=E6=80=BB=E6=8C=81?= =?UTF-8?q?=E7=BB=AD=E6=97=B6=E9=97=B4=E5=8F=AF=E8=A2=AB=2060=20=E6=95=B4?= =?UTF-8?q?=E9=99=A4=E7=9A=84=E6=AD=8C=E6=9B=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...44\347\232\204\346\255\214\346\233\262.md" | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 "Methodology/1010. \346\200\273\346\214\201\347\273\255\346\227\266\351\227\264\345\217\257\350\242\253 60 \346\225\264\351\231\244\347\232\204\346\255\214\346\233\262.md" diff --git "a/Methodology/1010. \346\200\273\346\214\201\347\273\255\346\227\266\351\227\264\345\217\257\350\242\253 60 \346\225\264\351\231\244\347\232\204\346\255\214\346\233\262.md" "b/Methodology/1010. \346\200\273\346\214\201\347\273\255\346\227\266\351\227\264\345\217\257\350\242\253 60 \346\225\264\351\231\244\347\232\204\346\255\214\346\233\262.md" new file mode 100644 index 0000000..0710609 --- /dev/null +++ "b/Methodology/1010. \346\200\273\346\214\201\347\273\255\346\227\266\351\227\264\345\217\257\350\242\253 60 \346\225\264\351\231\244\347\232\204\346\255\214\346\233\262.md" @@ -0,0 +1,59 @@ +#### 1010. 总持续时间可被 60 整除的歌曲 + +难度：中等 + +--- + +在歌曲列表中，第 `i` 首歌曲的持续时间为 `time[i]` 秒。 + +返回其总持续时间（以秒为单位）可被 `60` 整除的歌曲对的数量。形式上，我们希望下标数字 `i` 和 `j` 满足  `i < j` 且有 `(time[i] + time[j]) % 60 == 0`。 + + **示例 1：** + +``` +输入：time = [30,20,150,100,40] +输出：3 +解释：这三对的总持续时间可被 60 整除： +(time[0] = 30, time[2] = 150): 总持续时间 180 +(time[1] = 20, time[3] = 100): 总持续时间 120 +(time[1] = 20, time[4] = 40): 总持续时间 60 +``` + + **示例 2：** + +``` +输入：time = [60,60,60] +输出：3 +解释：所有三对的总持续时间都是 120，可以被 60 整除。 +``` + + **提示：** + +* `1 <= time.length <= 6 * 10^4` +* `1 <= time[i] <= 500` + +--- + +组合数学： + +先取余，后求歌曲对的数量，例如 `i` 与 `60-i` 成一对。 + +```Java +class Solution { + public int numPairsDivisibleBy60(int[] time) { + int[] temp = new int[60]; + for(int i = 0; i < time.length; i++){ + temp[time[i] % 60]++; + } + long ans = 0; + for(int i = 0; i <= 30; i++){ + if(i == 0 || i == 30){ + ans += (long) temp[i] * (temp[i] - 1) / 2; + } else { + ans += (long) temp[i] * temp[60 - i]; + } + } + return (int)ans; + } +} +``` \ No newline at end of file From bac0779faeba857de357e277a5f990c9fc059544 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 7 May 2023 12:33:08 +0800 Subject: [PATCH 055/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3685ebb..ef19a0c 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | | 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | | 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | | 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | From 91b1905c6b6d33a17747be92d1d08a2b0ca35ee5 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 11 May 2023 18:09:45 +0800 Subject: [PATCH 056/373] =?UTF-8?q?Create=20560.=20=E5=92=8C=E4=B8=BA=20K?= =?UTF-8?q?=20=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\255\220\346\225\260\347\273\204.md" | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 "Hash Table/560. \345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" diff --git "a/Hash Table/560. \345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" "b/Hash Table/560. \345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" new file mode 100644 index 0000000..2b7b53b --- /dev/null +++ "b/Hash Table/560. \345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -0,0 +1,51 @@ +#### 560. 和为 K 的子数组 + +难度：中等 + +--- + +给你一个整数数组 `nums` 和一个整数 `k` ，请你统计并返回 _该数组中和为 `k` 的连续子数组的个数_ 。 + + **示例 1：** + +``` +输入：nums = [1,1,1], k = 2 +输出：2 +``` + + **示例 2：** + +``` +输入：nums = [1,2,3], k = 3 +输出：2 +``` + + **提示：** + +* `1 <= nums.length <= 2 * 10^4` +* `-1000 <= nums[i] <= 1000` +* `-10^7 <= k <= 10^7` + +--- + +前缀和 + 哈希表： + +若用数组 `pre[n]` 记录 `[0,n]` 所有数的和，那么 `pre[i] = pre[i - 1] + nums[i]`，也就是数组 `pre[n]` 是一个记录前缀和的数组。若**连续子数组** `[j,...,i]` 的和为 `k`，那么可以得到 `pre[i] - pre[j - 1] = k`，即 `pre[j - 1] = pre[i] - k`。因此如果将数组替换成哈希表，即可在 `O(1)` 时间内查找到是否存在某个下标为 `j - 1`（当然，下标不重要），值为 `pre[i] - k` 的数。附上[参考链接](https://leetcode.cn/problems/subarray-sum-equals-k/solution/he-wei-kde-zi-shu-zu-by-leetcode-solution/)。 + +```Java +class Solution { + public int subarraySum(int[] nums, int k) { + int ans = 0, n = nums.length, sum = 0; + HashMap hashmap = new HashMap<>(); + hashmap.put(0, 1); + for(int i = 0; i < n; i++){ + sum += nums[i]; + if(hashmap.containsKey(sum - k)){ + ans += hashmap.get(sum - k); + } + hashmap.put(sum, hashmap.getOrDefault(sum, 0) + 1); + } + return ans; + } +} +``` \ No newline at end of file From 34abf505611534375e4c519747e42f38f314c619 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 11 May 2023 18:13:31 +0800 Subject: [PATCH 057/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index ef19a0c..3d3ba0c 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | +| 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | | 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | | 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | | 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | From d02ee0c89127b860010e4e2b14d08ca27d6e19b2 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 13 May 2023 08:38:26 +0800 Subject: [PATCH 058/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3d3ba0c..877f656 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | | 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | | 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | | 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | From 5d9af7181fbbc2e5ced69349105c2e7426cf7033 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 14 May 2023 18:20:58 +0800 Subject: [PATCH 059/373] =?UTF-8?q?Create=201054.=20=E8=B7=9D=E7=A6=BB?= =?UTF-8?q?=E7=9B=B8=E7=AD=89=E7=9A=84=E6=9D=A1=E5=BD=A2=E7=A0=81.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\346\235\241\345\275\242\347\240\201.md" | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 "Priority Queue/1054. \350\267\235\347\246\273\347\233\270\347\255\211\347\232\204\346\235\241\345\275\242\347\240\201.md" diff --git "a/Priority Queue/1054. \350\267\235\347\246\273\347\233\270\347\255\211\347\232\204\346\235\241\345\275\242\347\240\201.md" "b/Priority Queue/1054. \350\267\235\347\246\273\347\233\270\347\255\211\347\232\204\346\235\241\345\275\242\347\240\201.md" new file mode 100644 index 0000000..c9f94f6 --- /dev/null +++ "b/Priority Queue/1054. \350\267\235\347\246\273\347\233\270\347\255\211\347\232\204\346\235\241\345\275\242\347\240\201.md" @@ -0,0 +1,71 @@ +#### 1054. 距离相等的条形码 + +难度：中等 + +--- + +在一个仓库里，有一排条形码，其中第 `i` 个条形码为 `barcodes[i]`。 + +请你重新排列这些条形码，使其中任意两个相邻的条形码不能相等。 你可以返回任何满足该要求的答案，此题保证存在答案。 + + **示例 1：** + +``` +输入：barcodes = [1,1,1,2,2,2] +输出：[2,1,2,1,2,1] +``` + + **示例 2：** + +``` +输入：barcodes = [1,1,1,1,2,2,3,3] +输出：[1,3,1,3,2,1,2,1] +``` + + **提示：** + +* `1 <= barcodes.length <= 10000` +* `1 <= barcodes[i] <= 10000` + +--- + +哈希表 + 优先队列： + +最初的思路：找到剩余数量最多的元素并尽可能优先排列。 + +借助优先队列（最大堆），每次取优先队列（最大堆）中**剩余数量最多**和**第二多**的元素放入数组中，保证了相邻元素不重复。再考虑一下特殊情况，原数组的个数为奇数个时，意味着最后一个的元素直接放在数组的最后一个即可。 + +```Java +class Solution { + public int[] rearrangeBarcodes(int[] barcodes) { + int n = barcodes.length; + HashMap hashmap = new HashMap<>(); + for(int barcode: barcodes){ + hashmap.put(barcode, hashmap.getOrDefault(barcode, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>((a, b) -> (hashmap.get(b) - hashmap.get(a))); + for(Integer i: hashmap.keySet()){ + pq.add(i); + } + int[] ans = new int[n]; + for(int i = 0; i < n; i += 2){ + if(i == n - 1){ + ans[i] = pq.poll(); + } else { + int temp1 = pq.poll(), temp2 = pq.poll(); + ans[i] = temp1; + ans[i + 1] = temp2; + if(hashmap.get(temp1) > 1){ + hashmap.put(temp1, hashmap.get(temp1) - 1); + pq.add(temp1); + } + if(hashmap.get(temp2) > 1){ + hashmap.put(temp2, hashmap.get(temp2) - 1); + pq.add(temp2); + } + } + } + return ans; + } +} +``` \ No newline at end of file From ea0d2750578362f31fec748850a447333199a550 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 14 May 2023 18:24:51 +0800 Subject: [PATCH 060/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 877f656..7b604ae 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | | 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | | 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | | 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | From a371209538e9285e6949a620283f0bb2e8d3e83c Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 21 May 2023 14:34:22 +0800 Subject: [PATCH 061/373] =?UTF-8?q?Create=20435.=20=E6=97=A0=E9=87=8D?= =?UTF-8?q?=E5=8F=A0=E5=8C=BA=E9=97=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...15\345\217\240\345\214\272\351\227\264.md" | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 "Greedy/435. \346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md" diff --git "a/Greedy/435. \346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md" "b/Greedy/435. \346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md" new file mode 100644 index 0000000..e7a79ac --- /dev/null +++ "b/Greedy/435. \346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md" @@ -0,0 +1,59 @@ +#### 435. 无重叠区间 + +难度：中等 + +--- + +给定一个区间的集合 `intervals` ，其中 `intervals[i] = [starti, endi]` 。返回 _需要移除区间的最小数量，使剩余区间互不重叠_ 。 + + **示例 1:** + +``` +输入: intervals = [[1,2],[2,3],[3,4],[1,3]] +输出: 1 +解释: 移除 [1,3] 后，剩下的区间没有重叠。 +``` + + **示例 2:** + +``` +输入: intervals = [ [1,2], [1,2], [1,2] ] +输出: 2 +解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。 +``` + + **示例 3:** + +``` +输入: intervals = [ [1,2], [2,3] ] +输出: 0 +解释: 你不需要移除任何区间，因为它们已经是无重叠的了。 +``` + + **提示:** + +* `1 <= intervals.length <= 10^5` +* `intervals[i].length == 2` +* `-5 * 10^4 <= starti < endi <= 5 * 10^4` + +--- + +经典贪心算法： + +区间右端点排序！！！然后记录最大不重叠区间，最后用总数减去该不重叠区间数即可。 + +```Java +class Solution { + public int eraseOverlapIntervals(int[][] intervals) { + Arrays.sort(intervals, (a, b) -> (a[1] - b[1])); + int n = intervals.length, right = intervals[0][1], ans = 1; + for(int i = 1; i < n; i++){ + if(intervals[i][0] >= right){ + ans++; + right = intervals[i][1]; + } + } + return n - ans; + } +} +``` \ No newline at end of file From 3fc63f5acd72ab9271c5eb94a15e7e3dca288f52 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 21 May 2023 14:38:59 +0800 Subject: [PATCH 062/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 7b604ae..5939744 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | | 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | | 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | | 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | From 1525ce1486f513b3e299dd0fc31c0a84d643f8bf Mon Sep 17 00:00:00 2001 From: NUC11 Date: Thu, 25 May 2023 16:54:48 +0800 Subject: [PATCH 063/373] =?UTF-8?q?Create=20452.=20=E7=94=A8=E6=9C=80?= =?UTF-8?q?=E5=B0=91=E6=95=B0=E9=87=8F=E7=9A=84=E7=AE=AD=E5=BC=95=E7=88=86?= =?UTF-8?q?=E6=B0=94=E7=90=83.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...25\347\210\206\346\260\224\347\220\203.md" | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 "Greedy/452. \347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" diff --git "a/Greedy/452. \347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" "b/Greedy/452. \347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" new file mode 100644 index 0000000..fb69b77 --- /dev/null +++ "b/Greedy/452. \347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" @@ -0,0 +1,71 @@ +#### 452. 用最少数量的箭引爆气球 + +难度：中等 + +--- + +有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 `points` ，其中`points[i] = [xstart, xend]` 表示水平直径在 `xstart` 和 `xend`之间的气球。你不知道气球的确切 y 坐标。 + +一支弓箭可以沿着 x 轴从不同点 **完全垂直** 地射出。在坐标 `x` 处射出一支箭，若有一个气球的直径的开始和结束坐标为 `x``start`，`x``end`， 且满足  `xstart ≤ x ≤ x``end`，则该气球会被 **引爆**  。可以射出的弓箭的数量 **没有限制** 。 弓箭一旦被射出之后，可以无限地前进。 + +给你一个数组 `points` ，_返回引爆所有气球所必须射出的 **最小** 弓箭数_ 。 + +  + + **示例 1：** + +``` +输入：points = [[10,16],[2,8],[1,6],[7,12]] +输出：2 +解释：气球可以用2支箭来爆破: +-在x = 6处射出箭，击破气球[2,8]和[1,6]。 +-在x = 11处发射箭，击破气球[10,16]和[7,12]。 +``` + + **示例 2：** + +``` +输入：points = [[1,2],[3,4],[5,6],[7,8]] +输出：4 +解释：每个气球需要射出一支箭，总共需要4支箭。 +``` + + **示例 3：** + +``` +输入：points = [[1,2],[2,3],[3,4],[4,5]] +输出：2 +解释：气球可以用2支箭来爆破: +- 在x = 2处发射箭，击破气球[1,2]和[2,3]。 +- 在x = 4处射出箭，击破气球[3,4]和[4,5]。 +``` + + **提示:** + +* `1 <= points.length <= 10^5` +* `points[i].length == 2` +* `-2^31 <= xstart < xend <= 2^31 - 1` + +--- + +排序 + 贪心： + +将右端点以升序排序，每根弓箭都是取右端点值最小的点（贪心），同时不考虑左端点比该点小的气球（即弓箭能引爆该气球），直到取完所有点为止。 + +```Java +class Solution { + public int findMinArrowShots(int[][] points) { + Arrays.sort(points, (a, b) -> { + return Integer.compare(a[1], b[1]); + }); + int ans = 1, last = points[0][1]; + for(int[] temp: points){ + if(temp[0] > last){ + ans++; + last = temp[1]; + } + } + return ans; + } +} +``` \ No newline at end of file From 0ff9acd18ec8710ab272db6cfc0a0a7252ec6534 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 25 May 2023 16:58:52 +0800 Subject: [PATCH 064/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5939744..89e097e 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | | 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | | 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | | 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | From 194f4b190b4a99b74d786f3d286868d7be759397 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Mon, 29 May 2023 22:49:35 +0800 Subject: [PATCH 065/373] =?UTF-8?q?Create=202352.=20=E7=9B=B8=E7=AD=89?= =?UTF-8?q?=E8=A1=8C=E5=88=97=E5=AF=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...11\350\241\214\345\210\227\345\257\271.md" | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 "Hash Table/2352. \347\233\270\347\255\211\350\241\214\345\210\227\345\257\271.md" diff --git "a/Hash Table/2352. \347\233\270\347\255\211\350\241\214\345\210\227\345\257\271.md" "b/Hash Table/2352. \347\233\270\347\255\211\350\241\214\345\210\227\345\257\271.md" new file mode 100644 index 0000000..829719f --- /dev/null +++ "b/Hash Table/2352. \347\233\270\347\255\211\350\241\214\345\210\227\345\257\271.md" @@ -0,0 +1,71 @@ +#### 2352. 相等行列对 + +难度：中等 + +--- + +给你一个下标从 **0** 开始、大小为 `n x n` 的整数矩阵 `grid` ，返回满足 `Ri` 行和 `Cj` 列相等的行列对 `(Ri, Cj)` 的数目_。_ + +如果行和列以相同的顺序包含相同的元素（即相等的数组），则认为二者是相等的。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2022/06/01/ex1.jpg) + +``` +输入：grid = [[3,2,1],[1,7,6],[2,7,7]] +输出：1 +解释：存在一对相等行列对： +- (第 2 行，第 1 列)：[2,7,7] +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2022/06/01/ex2.jpg) + +``` +输入：grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]] +输出：3 +解释：存在三对相等行列对： +- (第 0 行，第 0 列)：[3,1,2,2] +- (第 2 行, 第 2 列)：[2,4,2,2] +- (第 3 行, 第 2 列)：[2,4,2,2] +``` + + **提示：** + +* `n == grid.length == grid[i].length` +* `1 <= n <= 200` +* `1 <= grid[i][j] <= 10^5` + +--- + +哈希表： + +将每行的元素以字符串的形式作为哈希表的key，值为key出现的次数；先将每行数据存储在哈希表中，再查看每列数据在哈希表中出现的次数，所有列出现的次数相加即可。 + +或者第二种方法，将矩阵转置后再进行对比。 + +```Java +class Solution { + public int equalPairs(int[][] grid) { + int ans = 0, n = grid.length; + HashMap hashmap = new HashMap<>(); + for(int i = 0; i < n; i++){ + StringBuilder sb = new StringBuilder(); + for(int j = 0; j < n; j++){ + sb.append(grid[i][j] + " "); + } + hashmap.put(sb.toString(), hashmap.getOrDefault(sb.toString(), 0) + 1); + } + for(int j = 0; j < n; j++){ + StringBuilder sb = new StringBuilder(); + for(int i = 0; i < n; i++){ + sb.append(grid[i][j] + " "); + } + ans += hashmap.getOrDefault(sb.toString(), 0); + } + return ans; + } +} +``` \ No newline at end of file From b2c3fc8563c440843a1a83194badcf564fc43010 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 29 May 2023 22:54:32 +0800 Subject: [PATCH 066/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 89e097e..3c9535e 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | | 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | | 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | | 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | From 3d0f3a7451bc5e9ed7d27714915a0d984aa4936d Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 31 May 2023 21:28:35 +0800 Subject: [PATCH 067/373] =?UTF-8?q?Create=202300.=20=E5=92=92=E8=AF=AD?= =?UTF-8?q?=E5=92=8C=E8=8D=AF=E6=B0=B4=E7=9A=84=E6=88=90=E5=8A=9F=E5=AF=B9?= =?UTF-8?q?=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...20\345\212\237\345\257\271\346\225\260.md" | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 "Dichotomy/2300. \345\222\222\350\257\255\345\222\214\350\215\257\346\260\264\347\232\204\346\210\220\345\212\237\345\257\271\346\225\260.md" diff --git "a/Dichotomy/2300. \345\222\222\350\257\255\345\222\214\350\215\257\346\260\264\347\232\204\346\210\220\345\212\237\345\257\271\346\225\260.md" "b/Dichotomy/2300. \345\222\222\350\257\255\345\222\214\350\215\257\346\260\264\347\232\204\346\210\220\345\212\237\345\257\271\346\225\260.md" new file mode 100644 index 0000000..e0cdc02 --- /dev/null +++ "b/Dichotomy/2300. \345\222\222\350\257\255\345\222\214\350\215\257\346\260\264\347\232\204\346\210\220\345\212\237\345\257\271\346\225\260.md" @@ -0,0 +1,77 @@ +#### 2300. 咒语和药水的成功对数 + +难度：中等 + +--- + +给你两个正整数数组 `spells` 和 `potions` ，长度分别为 `n` 和 `m` ，其中 `spells[i]` 表示第 `i` 个咒语的能量强度，`potions[j]` 表示第 `j` 瓶药水的能量强度。 + +同时给你一个整数 `success` 。一个咒语和药水的能量强度 **相乘** 如果  **大于等于**  `success` ，那么它们视为一对  **成功**  的组合。 + +请你返回一个长度为 `n` 的整数数组 `pairs`，其中 `pairs[i]` 是能跟第 `i` 个咒语成功组合的 **药水** 数目。 + + **示例 1：** + +``` +输入：spells = [5,1,3], potions = [1,2,3,4,5], success = 7 +输出：[4,0,3] +解释： +- 第 0 个咒语：5 * [1,2,3,4,5] = [5,10,15,20,25] 。总共 4 个成功组合。 +- 第 1 个咒语：1 * [1,2,3,4,5] = [1,2,3,4,5] 。总共 0 个成功组合。 +- 第 2 个咒语：3 * [1,2,3,4,5] = [3,6,9,12,15] 。总共 3 个成功组合。 +所以返回 [4,0,3] 。 +``` + + **示例 2：** + +``` +输入：spells = [3,1,2], potions = [8,5,8], success = 16 +输出：[2,0,2] +解释： +- 第 0 个咒语：3 * [8,5,8] = [24,15,24] 。总共 2 个成功组合。 +- 第 1 个咒语：1 * [8,5,8] = [8,5,8] 。总共 0 个成功组合。 +- 第 2 个咒语：2 * [8,5,8] = [16,10,16] 。总共 2 个成功组合。 +所以返回 [2,0,2] 。 +``` + + **提示：** + +* `n == spells.length` +* `m == potions.length` +* `1 <= n, m <= 10^5` +* `1 <= spells[i], potions[i] <= 10^5` +* `1 <= success <= 10^10` + +--- + +二分查找： + +先将 `potions` 数组进行排序，再通过二分搜索找到大于等于 `success` 的最小下标，即 `target = success` 的**左端点**。 + +```Java +class Solution { + public int[] successfulPairs(int[] spells, int[] potions, long success) { + int n = spells.length, m = potions.length; + int[] ans = new int[n]; + Arrays.sort(potions); + for(int i = 0; i < n; i++){ + ans[i] = dichotomy(potions, spells[i], success); + } + return ans; + } + + public int dichotomy(int[] array, int times, long target){ + int m = array.length, left = 0, right = m - 1; + while(left <= right){ + int mid = (left + right) / 2; + long temp = (long)array[mid] * (long)times; + if(temp >= target){ + right = mid - 1; + } else { + left = mid + 1; + } + } + return m - left; + } +} +``` \ No newline at end of file From 6887a86fb744ee01b04257e9a666751f55ab7b74 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 31 May 2023 21:33:08 +0800 Subject: [PATCH 068/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3c9535e..2713d15 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | | 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | | 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | | 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | From b4d615de374fe65f498ad2e086a35f5cf45d2223 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 1 Jun 2023 20:17:17 +0800 Subject: [PATCH 069/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2713d15..a3d5a40 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | | 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | | 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | | 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | From a75ad6faf654f38a64a49ce8b97c9881d080b6fb Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 1 Jun 2023 21:42:30 +0800 Subject: [PATCH 070/373] =?UTF-8?q?Create=202517.=20=E7=A4=BC=E7=9B=92?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E7=94=9C=E8=9C=9C=E5=BA=A6.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...47\347\224\234\350\234\234\345\272\246.md" | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 "Dichotomy/2517. \347\244\274\347\233\222\347\232\204\346\234\200\345\244\247\347\224\234\350\234\234\345\272\246.md" diff --git "a/Dichotomy/2517. \347\244\274\347\233\222\347\232\204\346\234\200\345\244\247\347\224\234\350\234\234\345\272\246.md" "b/Dichotomy/2517. \347\244\274\347\233\222\347\232\204\346\234\200\345\244\247\347\224\234\350\234\234\345\272\246.md" new file mode 100644 index 0000000..2142c88 --- /dev/null +++ "b/Dichotomy/2517. \347\244\274\347\233\222\347\232\204\346\234\200\345\244\247\347\224\234\350\234\234\345\272\246.md" @@ -0,0 +1,81 @@ +#### 2517. 礼盒的最大甜蜜度 + +难度：中等 + +--- + +给你一个正整数数组 `price` ，其中 `price[i]` 表示第 `i` 类糖果的价格，另给你一个正整数 `k` 。 + +商店组合 `k` 类 **不同** 糖果打包成礼盒出售。礼盒的 **甜蜜度** 是礼盒中任意两种糖果 **价格** 绝对差的最小值。 + +返回礼盒的 **最大** 甜蜜度_。_ + + **示例 1：** + +``` +输入：price = [13,5,1,8,21,2], k = 3 +输出：8 +解释：选出价格分别为 [13,5,21] 的三类糖果。 +礼盒的甜蜜度为 min(|13 - 5|, |13 - 21|, |5 - 21|) = min(8, 8, 16) = 8 。 +可以证明能够取得的最大甜蜜度就是 8 。 +``` + + **示例 2：** + +``` +输入：price = [1,3,1], k = 2 +输出：2 +解释：选出价格分别为 [1,3] 的两类糖果。 +礼盒的甜蜜度为 min(|1 - 3|) = min(2) = 2 。 +可以证明能够取得的最大甜蜜度就是 2 。 +``` + + **示例 3：** + +``` +输入：price = [7,7,7,7], k = 2 +输出：0 +解释：从现有的糖果中任选两类糖果，甜蜜度都会是 0 。 +``` + + **提示：** + +* `1 <= price.length <= 10^5` +* `1 <= price[i] <= 10^9` +* `2 <= k <= price.length` + +--- + +贪心 + 二分查找： + +将 `price` 数组排序，再以 `price[0]` 作为左端点，`price[n - 1] - price[0]` 作为右端点，不断寻找大于等于当前价格差的数组个数，若个数小于 `k`，意味着需要减少价格差，否则增加价格差。 + +```Java +class Solution { + public int maximumTastiness(int[] price, int k) { + int n = price.length; + Arrays.sort(price); + int left = 0, right = price[n - 1] - price[0]; + while(left <= right){ + int mid = (left + right) / 2; + if(exist(price, k, mid)){ + left = mid + 1; + } else { + right = mid - 1; + } + } + return left - 1; + } + + public boolean exist(int[] price, int k, int target){ + int count = 1, pre = price[0]; + for(int i = 1; i < price.length; i++){ + if(price[i] - pre >= target){ + count ++; + pre = price[i]; + } + } + return count >= k; + } +} +``` \ No newline at end of file From b133bbdc389891d284c293c5f9dc7fbf63d66b60 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Fri, 2 Jun 2023 13:21:26 +0800 Subject: [PATCH 071/373] =?UTF-8?q?Create=202559.=20=E7=BB=9F=E8=AE=A1?= =?UTF-8?q?=E8=8C=83=E5=9B=B4=E5=86=85=E7=9A=84=E5=85=83=E9=9F=B3=E5=AD=97?= =?UTF-8?q?=E7=AC=A6=E4=B8=B2=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...27\347\254\246\344\270\262\346\225\260.md" | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 "Prefix Sum/2559. \347\273\237\350\256\241\350\214\203\345\233\264\345\206\205\347\232\204\345\205\203\351\237\263\345\255\227\347\254\246\344\270\262\346\225\260.md" diff --git "a/Prefix Sum/2559. \347\273\237\350\256\241\350\214\203\345\233\264\345\206\205\347\232\204\345\205\203\351\237\263\345\255\227\347\254\246\344\270\262\346\225\260.md" "b/Prefix Sum/2559. \347\273\237\350\256\241\350\214\203\345\233\264\345\206\205\347\232\204\345\205\203\351\237\263\345\255\227\347\254\246\344\270\262\346\225\260.md" new file mode 100644 index 0000000..35f42b8 --- /dev/null +++ "b/Prefix Sum/2559. \347\273\237\350\256\241\350\214\203\345\233\264\345\206\205\347\232\204\345\205\203\351\237\263\345\255\227\347\254\246\344\270\262\346\225\260.md" @@ -0,0 +1,73 @@ +#### 2559. 统计范围内的元音字符串数 + +难度：中等 + +--- + +给你一个下标从 **0** 开始的字符串数组 `words` 以及一个二维整数数组 `queries` 。 + +每个查询 `queries[i] = [li, ri]` 会要求我们统计在 `words` 中下标在 `li` 到 `ri` 范围内（ **包含** 这两个值）并且以元音开头和结尾的字符串的数目。 + +返回一个整数数组，其中数组的第 `i` 个元素对应第 `i` 个查询的答案。 + + **注意：** 元音字母是 `'a'`、`'e'`、`'i'`、`'o'` 和 `'u'` 。 + + **示例 1：** + +``` +输入：words = ["aba","bcb","ece","aa","e"], queries = [[0,2],[1,4],[1,1]] +输出：[2,3,0] +解释：以元音开头和结尾的字符串是 "aba"、"ece"、"aa" 和 "e" 。 +查询 [0,2] 结果为 2（字符串 "aba" 和 "ece"）。 +查询 [1,4] 结果为 3（字符串 "ece"、"aa"、"e"）。 +查询 [1,1] 结果为 0 。 +返回结果 [2,3,0] 。 +``` + + **示例 2：** + +``` +输入：words = ["a","e","i"], queries = [[0,2],[0,1],[2,2]] +输出：[3,2,1] +解释：每个字符串都满足这一条件，所以返回 [3,2,1] 。 +``` + + **提示：** + +* `1 <= words.length <= 10^5` +* `1 <= words[i].length <= 40` +* `words[i]` 仅由小写英文字母组成 +* `sum(words[i].length) <= 3 * 10^5` +* `1 <= queries.length <= 10^5` +* `0 <= queries[j][0] <= queries[j][1] < words.length` + +--- + +前缀和： + +本题是区间查询，因此可以考虑前缀和实现区间查询。开辟一个长度为 `n + 1` 或 `n` 的一维数组即可。 + +```Java +class Solution { + public int[] vowelStrings(String[] words, int[][] queries) { + int n = words.length, m = queries.length; + int[] dp = new int[n + 1]; + for(int i = 1; i < n + 1; i++) dp[i] = dp[i - 1] + check(words[i - 1]); + int[] ans = new int[m]; + for(int i = 0; i < m; i++){ + ans[i] = dp[queries[i][1] + 1] - dp[queries[i][0]]; + } + return ans; + } + + public int check(String word){ + int n = word.length(); + if(word.charAt(0) == 'a' || word.charAt(0) == 'e' || word.charAt(0) == 'i' || word.charAt(0) == 'o' || word.charAt(0) == 'u'){ + if(word.charAt(n - 1) == 'a' || word.charAt(n - 1) == 'e' || word.charAt(n - 1) == 'i' || word.charAt(n - 1) == 'o' || word.charAt(n - 1) == 'u'){ + return 1; + } + } + return 0; + } +} +``` \ No newline at end of file From fccd249c0a1a00767c26ac4cb961bbe4b83c71fe Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 2 Jun 2023 13:25:25 +0800 Subject: [PATCH 072/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index a3d5a40..63d9e14 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | | 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | | 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | | 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | From e24b6a4d51b91cff715075e1310d84d615565233 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Mon, 5 Jun 2023 15:11:28 +0800 Subject: [PATCH 073/373] =?UTF-8?q?Update=20215.=20=E6=95=B0=E7=BB=84?= =?UTF-8?q?=E4=B8=AD=E7=9A=84=E7=AC=ACK=E4=B8=AA=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E5=85=83=E7=B4=A0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...70\252\346\234\200\345\244\247\345\205\203\347\264\240.md" | 4 ++++ 1 file changed, 4 insertions(+) diff --git "a/Priority Queue/215. \346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" "b/Priority Queue/215. \346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" index e247388..69ddbf1 100644 --- "a/Priority Queue/215. \346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" +++ "b/Priority Queue/215. \346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" @@ -39,6 +39,10 @@ - 当堆的容量等于 K 时，并且元素大/小于小/大顶堆的堆顶元素时，弹出堆顶元素，插入该元素。 +为什么不使用最大堆？ + +- 因为使用最小堆的空间复杂度只有 O(K)，而使用最大堆的话空间复杂度将是 O(N)! + ```java class Solution { public int findKthLargest(int[] nums, int k) { From 109c0f810a575f326a2425f9b45174f010067b5d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 7 Jun 2023 20:17:39 +0800 Subject: [PATCH 074/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 63d9e14..1214102 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | | 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | | 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | | 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | From ece341788cb1c7877f2105ba560fc20f2793581b Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 7 Jun 2023 20:23:04 +0800 Subject: [PATCH 075/373] =?UTF-8?q?Create=202611.=20=E8=80=81=E9=BC=A0?= =?UTF-8?q?=E5=92=8C=E5=A5=B6=E9=85=AA.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\345\222\214\345\245\266\351\205\252.md" | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 "Greedy/2611. \350\200\201\351\274\240\345\222\214\345\245\266\351\205\252.md" diff --git "a/Greedy/2611. \350\200\201\351\274\240\345\222\214\345\245\266\351\205\252.md" "b/Greedy/2611. \350\200\201\351\274\240\345\222\214\345\245\266\351\205\252.md" new file mode 100644 index 0000000..daf9a88 --- /dev/null +++ "b/Greedy/2611. \350\200\201\351\274\240\345\222\214\345\245\266\351\205\252.md" @@ -0,0 +1,92 @@ +#### 2611. 老鼠和奶酪 + +难度：中等 + +--- + +有两只老鼠和 `n` 块不同类型的奶酪，每块奶酪都只能被其中一只老鼠吃掉。 + +下标为 `i` 处的奶酪被吃掉的得分为： + +* 如果第一只老鼠吃掉，则得分为 `reward1[i]` 。 +* 如果第二只老鼠吃掉，则得分为 `reward2[i]` 。 + +给你一个正整数数组 `reward1` ，一个正整数数组 `reward2` ，和一个非负整数 `k` 。 + +请你返回第一只老鼠恰好吃掉 `k` 块奶酪的情况下， **最大**  得分为多少。 + + **示例 1：** + +``` +输入：reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2 +输出：15 +解释：这个例子中，第一只老鼠吃掉第 2 和 3 块奶酪（下标从 0 开始），第二只老鼠吃掉第 0 和 1 块奶酪。 +总得分为 4 + 4 + 3 + 4 = 15 。 +15 是最高得分。 +``` + + **示例 2：** + +``` +输入：reward1 = [1,1], reward2 = [1,1], k = 2 +输出：2 +解释：这个例子中，第一只老鼠吃掉第 0 和 1 块奶酪（下标从 0 开始），第二只老鼠不吃任何奶酪。 +总得分为 1 + 1 = 2 。 +2 是最高得分。 +``` + + **提示：** + +* `1 <= n == reward1.length == reward2.length <= 10^5` +* `1 <= reward1[i], reward2[i] <= 1000` +* `0 <= k <= n` + +--- + +方法一：排序 + 贪心： + +第一只老鼠吃掉 k 个奶酪，剩下的给第二只老鼠吃，意味着这 k 个奶酪一定是差值最大的奶酪。那么以第二只老鼠的得分为基准，那么再加上 k 个得分差即可。 + +```java +class Solution { + public int miceAndCheese(int[] reward1, int[] reward2, int k) { + int n = reward1.length, ans = 0; + int[] diff = new int[n]; + for(int i = 0; i < n; i++){ + diff[i] = reward1[i] - reward2[i]; + ans += reward2[i]; + } + Arrays.sort(diff); + for(int i = 0; i < k; i++){ + ans += diff[n - i - 1]; + } + return ans; + } +} +``` + + + +方法二：优先队列 + 贪心： + +本题类似于**选择 k 个最大值**，那么维护一个长度为 k 的**最小堆**（优先队列），那么堆中存放的元素即是整个数组中的 k 个最大值。 + +```Java +class Solution { + public int miceAndCheese(int[] reward1, int[] reward2, int k) { + int n = reward1.length, ans = 0; + PriorityQueue pq = new PriorityQueue<>(); + for(int i = 0; i < n; i++){ + ans += reward2[i]; + pq.offer(reward1[i] - reward2[i]); + if(pq.size() > k){ + pq.poll(); + } + } + while(!pq.isEmpty()){ + ans += pq.poll(); + } + return ans; + } +} +``` \ No newline at end of file From d7f93d3d1afc9ac176768844924dd0bdc7b493a7 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Thu, 8 Jun 2023 21:05:13 +0800 Subject: [PATCH 076/373] =?UTF-8?q?Create=202390.=20=E4=BB=8E=E5=AD=97?= =?UTF-8?q?=E7=AC=A6=E4=B8=B2=E4=B8=AD=E7=A7=BB=E9=99=A4=E6=98=9F=E5=8F=B7?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...73\351\231\244\346\230\237\345\217\267.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Stack/2390. \344\273\216\345\255\227\347\254\246\344\270\262\344\270\255\347\247\273\351\231\244\346\230\237\345\217\267.md" diff --git "a/Stack/2390. \344\273\216\345\255\227\347\254\246\344\270\262\344\270\255\347\247\273\351\231\244\346\230\237\345\217\267.md" "b/Stack/2390. \344\273\216\345\255\227\347\254\246\344\270\262\344\270\255\347\247\273\351\231\244\346\230\237\345\217\267.md" new file mode 100644 index 0000000..b77d47a --- /dev/null +++ "b/Stack/2390. \344\273\216\345\255\227\347\254\246\344\270\262\344\270\255\347\247\273\351\231\244\346\230\237\345\217\267.md" @@ -0,0 +1,69 @@ +#### 2390. 从字符串中移除星号 + +难度：中等 + +--- + +给你一个包含若干星号 `*` 的字符串 `s` 。 + +在一步操作中，你可以： + +* 选中 `s` 中的一个星号。 +* 移除星号 **左侧** 最近的那个 **非星号** 字符，并移除该星号自身。 + +返回移除 **所有** 星号之后的字符串 **。** + + **注意：** + +* 生成的输入保证总是可以执行题面中描述的操作。 +* 可以证明结果字符串是唯一的。 + + **示例 1：** + +``` +输入：s = "leet**cod*e" +输出："lecoe" +解释：从左到右执行移除操作： +- 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。 +- 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ，s 变为 "lecod*e" 。 +- 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ，s 变为 "lecoe" 。 +不存在其他星号，返回 "lecoe" 。 +``` + + **示例 2：** + +``` +输入：s = "erase*****" +输出："" +解释：整个字符串都会被移除，所以返回空字符串。 +``` + + **提示：** + +* `1 <= s.length <= 10^5` +* `s` 由小写英文字母和星号 `*` 组成 +* `s` 可以执行上述操作 + +--- + +栈： + +简单**栈模拟**，没有其他需要注意的点。 + +```Java +class Solution { + public String removeStars(String s) { + ArrayDeque stack = new ArrayDeque<>(); + for(int i = 0; i < s.length(); i++){ + char c = s.charAt(i); + if(c == '*' && !stack.isEmpty()) stack.pop(); + else if(c != '*') stack.push(c); + } + StringBuilder sb = new StringBuilder(); + while(!stack.isEmpty()){ + sb.append("" + stack.pollLast()); + } + return sb.toString(); + } +} +``` \ No newline at end of file From b3d523be99f03c9edd4718768ca39bf16de25445 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 8 Jun 2023 21:10:01 +0800 Subject: [PATCH 077/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 1214102..9c94319 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | | 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | | 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | | 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | From eb75ddec5764740e1d2cea017c99dcd294f1ed04 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 11 Jun 2023 19:51:10 +0800 Subject: [PATCH 078/373] =?UTF-8?q?Create=201171.=20=E4=BB=8E=E9=93=BE?= =?UTF-8?q?=E8=A1=A8=E4=B8=AD=E5=88=A0=E5=8E=BB=E6=80=BB=E5=92=8C=E5=80=BC?= =?UTF-8?q?=E4=B8=BA=E9=9B=B6=E7=9A=84=E8=BF=9E=E7=BB=AD=E8=8A=82=E7=82=B9?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\347\273\255\350\212\202\347\202\271.md" | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 "Prefix Sum/1171. \344\273\216\351\223\276\350\241\250\344\270\255\345\210\240\345\216\273\346\200\273\345\222\214\345\200\274\344\270\272\351\233\266\347\232\204\350\277\236\347\273\255\350\212\202\347\202\271.md" diff --git "a/Prefix Sum/1171. \344\273\216\351\223\276\350\241\250\344\270\255\345\210\240\345\216\273\346\200\273\345\222\214\345\200\274\344\270\272\351\233\266\347\232\204\350\277\236\347\273\255\350\212\202\347\202\271.md" "b/Prefix Sum/1171. \344\273\216\351\223\276\350\241\250\344\270\255\345\210\240\345\216\273\346\200\273\345\222\214\345\200\274\344\270\272\351\233\266\347\232\204\350\277\236\347\273\255\350\212\202\347\202\271.md" new file mode 100644 index 0000000..b384cfb --- /dev/null +++ "b/Prefix Sum/1171. \344\273\216\351\223\276\350\241\250\344\270\255\345\210\240\345\216\273\346\200\273\345\222\214\345\200\274\344\270\272\351\233\266\347\232\204\350\277\236\347\273\255\350\212\202\347\202\271.md" @@ -0,0 +1,81 @@ +#### 1171. 从链表中删去总和值为零的连续节点 + +难度：中等 + +--- + +给你一个链表的头节点 `head`，请你编写代码，反复删去链表中由 **总和**  值为 `0` 的连续节点组成的序列，直到不存在这样的序列为止。 + +删除完毕后，请你返回最终结果链表的头节点。 + +你可以返回任何满足题目要求的答案。 + +（注意，下面示例中的所有序列，都是对 `ListNode` 对象序列化的表示。） + + **示例 1：** + +``` +输入：head = [1,2,-3,3,1] +输出：[3,1] +提示：答案 [1,2,1] 也是正确的。 +``` + + **示例 2：** + +``` +输入：head = [1,2,3,-3,4] +输出：[1,2,4] +``` + + **示例 3：** + +``` +输入：head = [1,2,3,-3,-2] +输出：[1] +``` + + **提示：** + +* 给你的链表中可能有 `1` 到 `1000` 个节点。 +* 对于链表中的每个节点，节点的值：`-1000 <= node.val <= 1000`. + +--- + +哈希表 + 前缀和： + +删去**连续节点组成的序列**，应该要想到前缀和。 + +并且需要两次遍历：第一次遍历记录当前前缀和的最后节点以哈希表的数据结构存储；第二次遍历从哈希表中取出相应节点，当前节点的下一个节点是哈希表中的节点的下一个节点（同样适用于当前节点！）。 + +此外，需要一个 dummy 节点，其节点的下一个节点指向 `head` 节点，以解决 `[1, -1]` 的情况！ + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode removeZeroSumSublists(ListNode head) { + HashMap hashmap = new HashMap<>(); + ListNode dummy = new ListNode(0); + dummy.next = head; + int presum = 0; + for(ListNode temp = dummy; temp != null; temp = temp.next){ + presum += temp.val; + hashmap.put(presum, temp); + } + presum = 0; + for(ListNode temp = dummy; temp != null; temp = temp.next){ + presum += temp.val; + temp.next = hashmap.get(presum).next; + } + return dummy.next; + } +} +``` \ No newline at end of file From a6210d7b59d311a2636707998424de3081672c7d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 11 Jun 2023 19:55:22 +0800 Subject: [PATCH 079/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9c94319..f48d9cd 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | | 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | | 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | | 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | From 5d6bd7ffc4c7463cd5cb1814cf5235d4a1f9a6a5 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Tue, 20 Jun 2023 22:17:17 +0800 Subject: [PATCH 080/373] =?UTF-8?q?Update=20912.=20=E5=BD=92=E5=B9=B6?= =?UTF-8?q?=E6=8E=92=E5=BA=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...22\345\271\266\346\216\222\345\272\217.md" | 40 ++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git "a/Sort/912. \345\275\222\345\271\266\346\216\222\345\272\217.md" "b/Sort/912. \345\275\222\345\271\266\346\216\222\345\272\217.md" index 0f16388..bcba7f6 100644 --- "a/Sort/912. \345\275\222\345\271\266\346\216\222\345\272\217.md" +++ "b/Sort/912. \345\275\222\345\271\266\346\216\222\345\272\217.md" @@ -27,7 +27,45 @@ --- -该归并排序有以下两个优化点： +普通的归并排序： + +```java +class Solution { + public int[] sortArray(int[] nums) { + merge(nums, 0, nums.length - 1); + return nums; + } + + private void merge(int[] nums, int left, int right){ + if(left < right){ + int mid = (left + right) / 2; + merge(nums, left, mid); + merge(nums, mid + 1, right); + mergeSort(nums, left, mid, right); + } + } + + private void mergeSort(int[] nums, int left, int mid, int right){ + int i = left, j = mid + 1, index = 0; + int[] temp = new int[right - left + 1]; + while(i <= mid && j <= right){ + if(nums[i] <= nums[j]){ + temp[index++] = nums[i++]; + } + else { + temp[index++] = nums[j++]; + } + } + while(i <= mid) temp[index++] = nums[i++]; + while(j <= right) temp[index++] = nums[j++]; + System.arraycopy(temp, 0, nums, left, right - left + 1); + } +} +``` + + + +优化后的归并排序有以下两个优化点： 1. 区间范围小于 `INSERTION_SORT_THRESHOLD` 的数组使用插入排序 2. 左数组的最后一个数小于或等于右数组的第一个数，证明已经有序 From ce10172a2aed1bd44f3164d42f6e7d3b36b1c0b7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 20 Jun 2023 22:20:20 +0800 Subject: [PATCH 081/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f48d9cd..3d907da 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-20 22:15 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 11 | **5** | | 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | | 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | | 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | @@ -96,7 +97,6 @@ | 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | | 2022-12-15 20:42 | [#剑指 Offer 25 合并两个排序的链表](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | | 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | -| 2022-12-15 13:46 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 10 | **4** | | 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | | 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | | 2022-12-13 11:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | From 361d0e73808e7d957ca29e0bbe1c3a8092a234be Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Fri, 23 Jun 2023 13:40:29 +0800 Subject: [PATCH 082/373] =?UTF-8?q?Create=202095.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E9=93=BE=E8=A1=A8=E7=9A=84=E4=B8=AD=E9=97=B4=E8=8A=82=E7=82=B9?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...55\351\227\264\350\212\202\347\202\271.md" | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 "Linked List/2095. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\350\212\202\347\202\271.md" diff --git "a/Linked List/2095. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\350\212\202\347\202\271.md" "b/Linked List/2095. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\350\212\202\347\202\271.md" new file mode 100644 index 0000000..1d2ee31 --- /dev/null +++ "b/Linked List/2095. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\344\270\255\351\227\264\350\212\202\347\202\271.md" @@ -0,0 +1,86 @@ +#### 2095. 删除链表的中间节点 + +难度：中等 + +--- + +给你一个链表的头节点 `head` 。 **删除** 链表的 **中间节点** ，并返回修改后的链表的头节点 `head` 。 + +长度为 `n` 链表的中间节点是从头数起第 `⌊n / 2⌋` 个节点（下标从 **0** 开始），其中 `⌊x⌋` 表示小于或等于 `x` 的最大整数。 + +* 对于 `n` = `1`、`2`、`3`、`4` 和 `5` 的情况，中间节点的下标分别是 `0`、`1`、`1`、`2` 和 `2` 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/11/16/eg1drawio.png) + +``` +输入：head = [1,3,4,7,1,2,6] +输出：[1,3,4,1,2,6] +解释： +上图表示给出的链表。节点的下标分别标注在每个节点的下方。 +由于 n = 7 ，值为 7 的节点 3 是中间节点，用红色标注。 +返回结果为移除节点后的新链表。 +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2021/11/16/eg2drawio.png) + +``` +输入：head = [1,2,3,4] +输出：[1,2,4] +解释： +上图表示给出的链表。 +对于 n = 4 ，值为 3 的节点 2 是中间节点，用红色标注。 +``` + + **示例 3：** + +![](https://assets.leetcode.com/uploads/2021/11/16/eg3drawio.png) + +``` +输入：head = [2,1] +输出：[2] +解释： +上图表示给出的链表。 +对于 n = 2 ，值为 1 的节点 1 是中间节点，用红色标注。 +值为 2 的节点 0 是移除节点 1 后剩下的唯一一个节点。 +``` + + **提示：** + +* 链表中节点的数目在范围 `[1, 10^5]` 内 +* `1 <= Node.val <= 10^5` + +--- + +快慢指针： + +通过找规律发现，当快指针为空或者快指针的下一个节点为空时，慢指针恰好为需要被删除的节点，因此用 `pre` 节点记录被删除节点的前一个节点。需要额外考虑的情况为当链表只存在一个节点时，直接返回空。 + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode deleteMiddle(ListNode head) { + if(head.next == null) return null; + ListNode fast = head, slow = head, pre = null; + while(fast != null && fast.next != null){ + pre = slow; + slow = slow.next; + fast = fast.next.next; + } + pre.next = pre.next.next; + return head; + } +} +``` \ No newline at end of file From 30992bd22ac5a9f2883ebf44d15589be46235453 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 23 Jun 2023 13:42:57 +0800 Subject: [PATCH 083/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3d907da..bcdfec4 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | | 2023-06-20 22:15 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 11 | **5** | | 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | | 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | From bc3ec4e953b31874bcb15cfe7048abb3d820692e Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 25 Jun 2023 13:56:04 +0800 Subject: [PATCH 084/373] =?UTF-8?q?Create=20162.=20=E5=AF=BB=E6=89=BE?= =?UTF-8?q?=E5=B3=B0=E5=80=BC.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...73\346\211\276\345\263\260\345\200\274.md" | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 "Dichotomy/162. \345\257\273\346\211\276\345\263\260\345\200\274.md" diff --git "a/Dichotomy/162. \345\257\273\346\211\276\345\263\260\345\200\274.md" "b/Dichotomy/162. \345\257\273\346\211\276\345\263\260\345\200\274.md" new file mode 100644 index 0000000..b9d320d --- /dev/null +++ "b/Dichotomy/162. \345\257\273\346\211\276\345\263\260\345\200\274.md" @@ -0,0 +1,72 @@ +#### 162. 寻找峰值 + +难度：中等 + +--- + +峰值元素是指其值严格大于左右相邻值的元素。 + +给你一个整数数组 `nums`，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 **任何一个峰值** 所在位置即可。 + +你可以假设 `nums[-1] = nums[n] = -∞` 。 + +你必须实现时间复杂度为 `O(log n)` 的算法来解决此问题。 + + **示例 1：** + +``` +输入：nums = [1,2,3,1] +输出：2 +解释：3 是峰值元素，你的函数应该返回其索引 2。 +``` + + **示例 2：** + +``` +输入：nums = [1,2,1,3,5,6,4] +输出：1 或 5 +解释：你的函数可以返回索引 1，其峰值元素为 2； +  或者返回索引 5， 其峰值元素为 6。 +``` + + **提示：** + +* `1 <= nums.length <= 1000` +* `-2^31 <= nums[i] <= 2^31 - 1` +* 对于所有有效的 `i` 都有 `nums[i] != nums[i + 1]` + +--- + +二分查找 + 爬坡理论： + +> 如果我们从一个位置开始，不断地向高处走，那么最终一定可以到达一个峰值位置。 + +基于爬坡理论可以确定一点： + +**如果当前元素不同于相邻元素时，那么沿着元素值递增的方向一定能找到一个峰值。** + +```Java +class Solution { + public int findPeakElement(int[] nums) { + int left = 0, right = nums.length - 1; + while(left <= right){ + int mid = (left + right) / 2; + if(compareLeft(nums, mid) && compareRight(nums, mid)){ + return mid; + } else if(compareLeft(nums, mid)) left = mid + 1; + else right = mid - 1; + } + return -1; + } + + private boolean compareLeft(int[] nums, int index){ + if(index == 0 || nums[index] > nums[index - 1]) return true; + return false; + } + + private boolean compareRight(int[] nums, int index){ + if(index == nums.length - 1 || nums[index] > nums[index + 1]) return true; + return false; + } +} +``` \ No newline at end of file From 7a3cd726ac120f4bad9529b9b9fb32c0f19b18e3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 25 Jun 2023 13:58:35 +0800 Subject: [PATCH 085/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index bcdfec4..791cb52 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | | 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | | 2023-06-20 22:15 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 11 | **5** | | 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | From 9f86427beb9db5e3b324109896501838fce6c2e5 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Tue, 27 Jun 2023 21:39:57 +0800 Subject: [PATCH 086/373] =?UTF-8?q?Update=20912.=20=E5=BF=AB=E9=80=9F?= =?UTF-8?q?=E6=8E=92=E5=BA=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \345\277\253\351\200\237\346\216\222\345\272\217.md" | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git "a/Sort/912. \345\277\253\351\200\237\346\216\222\345\272\217.md" "b/Sort/912. \345\277\253\351\200\237\346\216\222\345\272\217.md" index 5a173c2..091c23c 100644 --- "a/Sort/912. \345\277\253\351\200\237\346\216\222\345\272\217.md" +++ "b/Sort/912. \345\277\253\351\200\237\346\216\222\345\272\217.md" @@ -40,12 +40,14 @@ class Solution { private void quickSort(int[] nums, int left, int right){ if(right <= left) return; - int pivot = func(nums, left, right); + // int index = new Random().nextInt(right - left + 1) + left; // 随机选取下标并与最左侧元素交换，优化点1 + // swap(nums, left, index); + int pivot = findPivot(nums, left, right); quickSort(nums, left, pivot - 1); quickSort(nums, pivot + 1, right); } - private int func(int[] nums, int left, int right){ + private int findPivot(int[] nums, int left, int right){ int index = left, temp = nums[left]; while(left < right){ while(left < right && nums[right] >= temp) right--; // 要先从右边开始找！ @@ -80,7 +82,7 @@ class Solution { private void quickSort(int[] nums, int left, int right){ if(right <= left) return; - int index = new Random().nextInt(right - left + 1) + left; + int index = new Random().nextInt(right - left + 1) + left; // 随机选取下标并与最左侧元素交换，优化点1 swap(nums, left, index); int lt = left, i = left + 1, gt = right + 1; From 1b720e88be4240fd406cc6deb644f6f7538cd430 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 27 Jun 2023 21:42:53 +0800 Subject: [PATCH 087/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 791cb52..afcd18f 100644 --- a/README.md +++ b/README.md @@ -28,9 +28,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | | 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | | 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | -| 2023-06-20 22:15 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 11 | **5** | | 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | | 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | | 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | From bbbae20d775187ef4cdfcc4c47559999043eaa03 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Mon, 3 Jul 2023 23:39:05 +0800 Subject: [PATCH 088/373] =?UTF-8?q?Create=20445.=20=E4=B8=A4=E6=95=B0?= =?UTF-8?q?=E7=9B=B8=E5=8A=A0=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...346\225\260\347\233\270\345\212\240 II.md" | 89 +++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 "Linked List/445. \344\270\244\346\225\260\347\233\270\345\212\240 II.md" diff --git "a/Linked List/445. \344\270\244\346\225\260\347\233\270\345\212\240 II.md" "b/Linked List/445. \344\270\244\346\225\260\347\233\270\345\212\240 II.md" new file mode 100644 index 0000000..8091acc --- /dev/null +++ "b/Linked List/445. \344\270\244\346\225\260\347\233\270\345\212\240 II.md" @@ -0,0 +1,89 @@ +#### 445. 两数相加 II + +难度：中等 + +--- + +给你两个 **非空** 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 + +你可以假设除了数字 0 之外，这两个数字都不会以零开头。 + + **示例1：** + +![](https://pic.leetcode-cn.com/1626420025-fZfzMX-image.png) + +``` +输入：l1 = [7,2,4,3], l2 = [5,6,4] +输出：[7,8,0,7] +``` + + **示例2：** + +``` +输入：l1 = [2,4,3], l2 = [5,6,4] +输出：[8,0,7] +``` + + **示例3：** + +``` +输入：l1 = [0], l2 = [0] +输出：[0] +``` + + **提示：** + +* 链表的长度范围为 `[1, 100]` +* `0 <= node.val <= 9` +* 输入数据保证链表代表的数字无前导 0 + + **进阶：** 如果输入链表不能翻转该如何解决？ + +--- + +反转链表 + 两数相加： + +思路比较简单，**先反转两个链表，各个位上的数相加后再将链表反转**。中间的一些细节，比如当前两个链表指针都为空但仍有进位时，不能忽略这种情况。 + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode addTwoNumbers(ListNode l1, ListNode l2) { + ListNode head1 = reverseListNode(l1), head2 = reverseListNode(l2), dummy = new ListNode(0), cur = dummy; + int carry = 0; + while(head1 != null || head2 != null || carry != 0){ + if(head1 != null){ + carry += head1.val; + head1 = head1.next; + } + if(head2 != null) { + carry += head2.val; + head2 = head2.next; + } + cur = cur.next = new ListNode(carry % 10); // Java 连等赋值时自右向左赋值的 + carry /= 10; + } + return reverseListNode(dummy.next); + } + + public ListNode reverseListNode(ListNode head){ + ListNode pre = null, node = head; + while(node != null){ + ListNode temp = node.next; + node.next = pre; + pre = node; + node = temp; + } + return pre; + } +} +``` \ No newline at end of file From a8abdc5950dc1eb5ecb62fae650f1e0d02db96d5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 3 Jul 2023 23:42:12 +0800 Subject: [PATCH 089/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index afcd18f..7800e82 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | | 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | | 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | | 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | From 63491e0b56187925b4e2be3b21b2ee4c8f69e573 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 6 Jul 2023 00:34:12 +0800 Subject: [PATCH 090/373] =?UTF-8?q?Create=20328.=20=E5=A5=87=E5=81=B6?= =?UTF-8?q?=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...07\345\201\266\351\223\276\350\241\250.md" | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 "Linked List/328. \345\245\207\345\201\266\351\223\276\350\241\250.md" diff --git "a/Linked List/328. \345\245\207\345\201\266\351\223\276\350\241\250.md" "b/Linked List/328. \345\245\207\345\201\266\351\223\276\350\241\250.md" new file mode 100644 index 0000000..493d7b4 --- /dev/null +++ "b/Linked List/328. \345\245\207\345\201\266\351\223\276\350\241\250.md" @@ -0,0 +1,72 @@ +#### 328. 奇偶链表 + +难度：中等 + +--- + +给定单链表的头节点 `head` ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。 + + **第一个** 节点的索引被认为是 **奇数** ， **第二个** 节点的索引为  **偶数** ，以此类推。 + +请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。 + +你必须在 `O(1)` 的额外空间复杂度和 `O(n)` 的时间复杂度下解决这个问题。 + + **示例 1:** + +![](https://assets.leetcode.com/uploads/2021/03/10/oddeven-linked-list.jpg) + +``` +输入: head = [1,2,3,4,5] +输出: [1,3,5,2,4] +``` + + **示例 2:** + +![](https://assets.leetcode.com/uploads/2021/03/10/oddeven2-linked-list.jpg) + +``` +输入: head = [2,1,3,5,6,4,7] +输出: [2,3,6,7,1,5,4] +``` + + **提示:** + +* `n ==`  链表中的节点数 +* `0 <= n <= 10^4` +* `-10^6 <= Node.val <= 10^6` + +--- + +双指针： + +一个指针指向头节点（代表奇数节点），另一个指针指向头节点的下一个节点（代表偶数节点），接着奇数节点和偶数节点的下一个节点均指向原节点下一个节点的下一个节点（完成节点的跨越）。 + +因为偶数节点肯定位于奇数节点后，那么循环推出条件只需要判断偶数节点和偶数节点的下一个节点是否为空（通过多次尝试得出的结论），最后退出循环时将两个节点拼接到一起即可。 + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode oddEvenList(ListNode head) { + if(head == null || head.next == null) return head; + ListNode odd = head, even = head.next, temp = even; + while(even != null && even.next != null){ + odd.next = odd.next.next; + even.next = even.next.next; + odd = odd.next; + even = even.next; + } + odd.next = temp; + return head; + } +} +``` \ No newline at end of file From 73b2209fb3f94016342b05e2afac79f6ca560b4e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 6 Jul 2023 00:36:45 +0800 Subject: [PATCH 091/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 7800e82..9f5e96c 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | | 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | | 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | | 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | From f86dfd620ac87c7249f81e941c8ba0e35b4f0c1b Mon Sep 17 00:00:00 2001 From: NUC11 Date: Mon, 10 Jul 2023 23:27:22 +0800 Subject: [PATCH 092/373] =?UTF-8?q?Create=20394.=20=E5=AD=97=E7=AC=A6?= =?UTF-8?q?=E4=B8=B2=E8=A7=A3=E7=A0=81.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...46\344\270\262\350\247\243\347\240\201.md" | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 "Stack/394. \345\255\227\347\254\246\344\270\262\350\247\243\347\240\201.md" diff --git "a/Stack/394. \345\255\227\347\254\246\344\270\262\350\247\243\347\240\201.md" "b/Stack/394. \345\255\227\347\254\246\344\270\262\350\247\243\347\240\201.md" new file mode 100644 index 0000000..c8a8ec6 --- /dev/null +++ "b/Stack/394. \345\255\227\347\254\246\344\270\262\350\247\243\347\240\201.md" @@ -0,0 +1,94 @@ +#### 394. 字符串解码 + +难度：中等 + +--- + +给定一个经过编码的字符串，返回它解码后的字符串。 + +编码规则为: `k[encoded_string]`，表示其中方括号内部的 `encoded_string` 正好重复 `k` 次。注意 `k` 保证为正整数。 + +你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。 + +此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 `k` ，例如不会出现像 `3a` 或 `2[4]` 的输入。 + + **示例 1：** + +``` +输入：s = "3[a]2[bc]" +输出："aaabcbc" +``` + + **示例 2：** + +``` +输入：s = "3[a2[c]]" +输出："accaccacc" +``` + + **示例 3：** + +``` +输入：s = "2[abc]3[cd]ef" +输出："abcabccdcdcdef" +``` + + **示例 4：** + +``` +输入：s = "abc3[cd]xyz" +输出："abccdcdcdxyz" +``` + + **提示：** + +* `1 <= s.length <= 30` +* `s` 由小写英文字母、数字和方括号 `'[]'` 组成 +* `s` 保证是一个  **有效**  的输入。 +* `s` 中所有整数的取值范围为 `[1, 300]` + +--- + +栈： + +**注意 `k` 可能是两位以上的数。** + +```Java +class Solution { + public String decodeString(String s) { + int n = s.length(); + ArrayDeque number = new ArrayDeque<>(); + ArrayDeque stack = new ArrayDeque<>(); + for(int i = 0; i < n; i++){ + if(s.charAt(i) >= '0' && s.charAt(i) <= '9'){ + int num = 0; + while(s.charAt(i) >= '0' && s.charAt(i) <= '9'){ + num = num * 10 + s.charAt(i) - '0'; + i++; + } + i--; + number.push(num); + } + else if(s.charAt(i) != ']') stack.push(s.charAt(i)); + else { + StringBuilder sb = new StringBuilder(); + while(!stack.isEmpty() && stack.peek() != '['){ + sb.append(stack.pop()); + } + if(!stack.isEmpty()) stack.pop(); + int times = number.pop(); + for(int j = 0; j < times; j++){ + for(int k = sb.length() - 1; k >= 0; k--){ + stack.push(sb.charAt(k)); + } + } + } + } + StringBuilder ans = new StringBuilder(); + while(!stack.isEmpty()){ + ans.append(stack.pop()); + } + return ans.reverse().toString(); + } +} +``` \ No newline at end of file From 373f2221d1dc882afb9eec73b15d7ac5a2ca7c93 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 10 Jul 2023 23:30:18 +0800 Subject: [PATCH 093/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9f5e96c..14e5614 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | | 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | | 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | | 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | From 2016db50436bbf6c5147611dc07bce9cea8d96e9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 12 Jul 2023 20:18:36 +0800 Subject: [PATCH 094/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 14e5614..0897f87 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | | 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | | 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | | 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | From c07557a8d03dcd16833a322e4f1522182956af65 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Wed, 12 Jul 2023 21:19:06 +0800 Subject: [PATCH 095/373] =?UTF-8?q?Create=20450.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91=E4=B8=AD=E7=9A=84?= =?UTF-8?q?=E8=8A=82=E7=82=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...55\347\232\204\350\212\202\347\202\271.md" | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 "Linked List/450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" diff --git "a/Linked List/450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" "b/Linked List/450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" new file mode 100644 index 0000000..003a8a8 --- /dev/null +++ "b/Linked List/450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" @@ -0,0 +1,118 @@ +#### 450. 删除二叉搜索树中的节点 + +难度：中等 + +--- + +给定一个二叉搜索树的根节点 **root** 和一个值 **key** ，删除二叉搜索树中的  **key**  对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。 + +一般来说，删除节点可分为两个步骤： + +1. 首先找到需要删除的节点； +2. 如果找到了，删除它。 + + **示例 1:** + +![](https://assets.leetcode.com/uploads/2020/09/04/del_node_1.jpg) + +``` +输入：root = [5,3,6,2,4,null,7], key = 3 +输出：[5,4,6,2,null,null,7] +解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。 +一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。 +另一个正确答案是 [5,2,6,null,4,null,7]。 +``` + + **示例 2:** + +``` +输入: root = [5,3,6,2,4,null,7], key = 0 +输出: [5,3,6,2,4,null,7] +解释: 二叉树不包含值为 0 的节点 +``` + + **示例 3:** + +``` +输入: root = [], key = 0 +输出: [] +``` + + **提示:** + +* 节点数的范围 `[0, 10^4]`. +* `-10^5 <= Node.val <= 10^5` +* 节点值唯一 +* `root` 是合法的二叉搜索树 +* `-10^5 <= key <= 10^5` + + **进阶：** 要求算法时间复杂度为 O(h)，h 为树的高度。 + +--- + +链表的删除： + +将需要删除的节点的左节点连接至右节点的最左节点。 + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public TreeNode deleteNode(TreeNode root, int key) { + TreeNode node = root, dummy = new TreeNode(), pre = dummy; + dummy.left = root; + boolean isLeft = true; + while(node !=null && node.val != key){ + pre = node; + if(node.val < key){ + node = node.right; + isLeft = false; + } + else { + node = node.left; + isLeft = true; + } + } + if(node == null) return root; + jointNode(pre, isLeft); + return dummy.left; + } + + private void jointNode(TreeNode pre, boolean isLeft){ + TreeNode left = null, right = null; + if(isLeft) { + left = pre.left.left; + right = pre.left.right; + } else { + left = pre.right.left; + right = pre.right.right; + } + if(right == null){ + if(isLeft) pre.left = left; + else pre.right = left; + } else { + TreeNode temp = right; + while(temp.left != null){ + temp = temp.left; + } + temp.left = left; + if(isLeft) pre.left = right; + else pre.right = right; + } + + } +} +``` \ No newline at end of file From 2693b3bd96cfbd57252182b0f78d7cc505a3ba1a Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 13 Jul 2023 23:37:12 +0800 Subject: [PATCH 096/373] =?UTF-8?q?Create=20931.=20=E4=B8=8B=E9=99=8D?= =?UTF-8?q?=E8=B7=AF=E5=BE=84=E6=9C=80=E5=B0=8F=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\346\234\200\345\260\217\345\222\214.md" | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 "Dynamic Programming/931. \344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214.md" diff --git "a/Dynamic Programming/931. \344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214.md" "b/Dynamic Programming/931. \344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214.md" new file mode 100644 index 0000000..3eb352d --- /dev/null +++ "b/Dynamic Programming/931. \344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214.md" @@ -0,0 +1,62 @@ +#### 931. 下降路径最小和 + +难度：中等 + +--- + +给你一个 `n x n` 的 **方形** 整数数组 `matrix` ，请你找出并返回通过 `matrix` 的 **下降路径** 的 **最小和** 。 + + **下降路径** 可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置 `(row, col)` 的下一个元素应当是 `(row + 1, col - 1)`、`(row + 1, col)` 或者 `(row + 1, col + 1)` 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/11/03/failing1-grid.jpg) + +``` +输入：matrix = [[2,1,3],[6,5,4],[7,8,9]] +输出：13 +解释：如图所示，为和最小的两条下降路径 +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2021/11/03/failing2-grid.jpg) + +``` +输入：matrix = [[-19,57],[-40,-5]] +输出：-59 +解释：如图所示，为和最小的下降路径 +``` + + **提示：** + +* `n == matrix.length == matrix[i].length` +* `1 <= n <= 100` +* `-100 <= matrix[i][j] <= 100` + +--- + +二维动态规划： + +可以发现，坐标为 `[x, y]` 的最小路径和为 `min([x - 1][y - 1], [x - 1][y], [x - 1][y + 1]) + matrix[x][y]`，相当于状态转移函数。那么用一个dp数组记录即可求出末行每个元素的和最小下降路径。 + +```Java +class Solution { + public int minFallingPathSum(int[][] matrix) { + int n = matrix.length; + int[][] dp = new int[n][n]; + for(int j = 0; j < n; j++){ + dp[0][j] = matrix[0][j]; + } + for(int i = 1; i < n; i++){ + for(int j = 0; j < n; j++){ + int minn = dp[i - 1][j]; + if(j >= 1) minn = Math.min(minn, dp[i - 1][j - 1]); + if(j < n - 1) minn = Math.min(minn, dp[i - 1][j + 1]); + dp[i][j] = minn + matrix[i][j]; + } + } + return Arrays.stream(dp[n - 1]).min().getAsInt(); + } +} +``` \ No newline at end of file From 10b2ba68de82b062b44be37bbcabfb17a7967761 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 13 Jul 2023 23:40:17 +0800 Subject: [PATCH 097/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0897f87..2c875bf 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | | 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | | 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | | 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | From 4f6b2f2d6d9beb12bb456cccce544bbe8260bd64 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 16 Jul 2023 12:40:52 +0800 Subject: [PATCH 098/373] =?UTF-8?q?Create=201679.=20K=20=E5=92=8C=E6=95=B0?= =?UTF-8?q?=E5=AF=B9=E7=9A=84=E6=9C=80=E5=A4=A7=E6=95=B0=E7=9B=AE.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\244\247\346\225\260\347\233\256.md" | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 "Two Pointers/1679. K \345\222\214\346\225\260\345\257\271\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256.md" diff --git "a/Two Pointers/1679. K \345\222\214\346\225\260\345\257\271\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256.md" "b/Two Pointers/1679. K \345\222\214\346\225\260\345\257\271\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256.md" new file mode 100644 index 0000000..7dbb3c4 --- /dev/null +++ "b/Two Pointers/1679. K \345\222\214\346\225\260\345\257\271\347\232\204\346\234\200\345\244\247\346\225\260\347\233\256.md" @@ -0,0 +1,65 @@ +#### 1679. K 和数对的最大数目 + +难度：中等 + +--- + +给你一个整数数组 `nums` 和一个整数 `k` 。 + +每一步操作中，你需要从数组中选出和为 `k` 的两个整数，并将它们移出数组。 + +返回你可以对数组执行的最大操作数。 + + **示例 1：** + +``` +输入：nums = [1,2,3,4], k = 5 +输出：2 +解释：开始时 nums = [1,2,3,4]： +- 移出 1 和 4 ，之后 nums = [2,3] +- 移出 2 和 3 ，之后 nums = [] +不再有和为 5 的数对，因此最多执行 2 次操作。 +``` + + **示例 2：** + +``` +输入：nums = [3,1,3,4,3], k = 6 +输出：1 +解释：开始时 nums = [3,1,3,4,3]： +- 移出前两个 3 ，之后nums = [1,4,3] +不再有和为 6 的数对，因此最多执行 1 次操作。 +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `1 <= nums[i] <= 10^9` +* `1 <= k <= 10^9` + +--- + +排序 + 双指针： + +先将数组升序排序，当双指针元素之和小于 `k` 时，左指针右移一位；大于 `k` 时，右指针左移一位；等于 `k` 时，同时移动双指针。 + +```Java +class Solution { + public int maxOperations(int[] nums, int k) { + Arrays.sort(nums); + int left = 0, right = nums.length - 1, ans = 0; + while(left < right){ + if(nums[left] + nums[right] < k){ + left++; + } else if(nums[left] + nums[right] > k){ + right--; + } else { + ans++; + left++; + right--; + } + } + return ans; + } +} +``` \ No newline at end of file From cac322fa3357be6685abc3944ba7245ce1be07fa Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 16 Jul 2023 12:43:39 +0800 Subject: [PATCH 099/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2c875bf..3abbb9d 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | | 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | | 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | From 9db6904f81af95d52313d6593ccd440f03eff0e5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 22 Jul 2023 20:14:07 +0800 Subject: [PATCH 100/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3abbb9d..456b9f7 100644 --- a/README.md +++ b/README.md @@ -99,7 +99,7 @@ | 2023-01-01 19:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | | 2022-12-31 10:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | | 2022-12-19 14:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | -| 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | MEDIUM | 1 | 1 | +| 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | | 2022-12-17 18:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | | 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | | 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | From 774816fe647405074ee79b6a54e273e18964c419 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 3 Aug 2023 20:16:22 +0800 Subject: [PATCH 101/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 456b9f7..40f4e96 100644 --- a/README.md +++ b/README.md @@ -202,7 +202,7 @@ | 2022-08-10 18:34 | [#640 求解方程](https://leetcode.cn/problems/solve-the-equation) | MEDIUM | 4 | 1 | | 2022-08-01 12:42 | [#1374 生成每种字符都是奇数个的字符串](https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts) | EASY | 1 | 1 | | 2022-07-25 14:34 | [#919 完全二叉树插入器](https://leetcode.cn/problems/complete-binary-tree-inserter) | MEDIUM | 1 | 1 | -| 2022-07-23 14:13 | [#剑指 Offer II 115 重建序列](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | +| 2022-07-23 14:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | | 2022-07-17 11:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | | 2022-07-14 13:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | | 2022-07-13 19:22 | [#735 行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | @@ -220,7 +220,7 @@ | 2022-06-21 19:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | | 2022-06-19 23:06 | [#98 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree) | MEDIUM | 13 | 1 | | 2022-06-19 15:20 | [#508 出现次数最多的子树元素和](https://leetcode.cn/problems/most-frequent-subtree-sum) | MEDIUM | 2 | 1 | -| 2022-06-18 14:19 | [#剑指 Offer II 029 排序的循环链表](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | +| 2022-06-18 14:19 | [#LCR 029 循环有序列表的插入](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | | 2022-06-17 15:48 | [#1089 复写零](https://leetcode.cn/problems/duplicate-zeros) | EASY | 2 | 1 | | 2022-06-13 23:05 | [#1051 高度检查器](https://leetcode.cn/problems/height-checker) | EASY | 2 | 1 | | 2022-06-12 23:05 | [#890 查找和替换模式](https://leetcode.cn/problems/find-and-replace-pattern) | MEDIUM | 1 | 1 | From 6447a3598274700b2a03cedf0762526a02f1b29d Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Fri, 4 Aug 2023 15:09:54 +0800 Subject: [PATCH 102/373] =?UTF-8?q?Create=2046.=20=E5=85=A8=E6=8E=92?= =?UTF-8?q?=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \345\205\250\346\216\222\345\210\227.md" | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 "Backtrace/46. \345\205\250\346\216\222\345\210\227.md" diff --git "a/Backtrace/46. \345\205\250\346\216\222\345\210\227.md" "b/Backtrace/46. \345\205\250\346\216\222\345\210\227.md" new file mode 100644 index 0000000..18e7777 --- /dev/null +++ "b/Backtrace/46. \345\205\250\346\216\222\345\210\227.md" @@ -0,0 +1,70 @@ +#### 46. 全排列 + +难度：中等 + +--- + +给定一个不含重复数字的数组 `nums` ，返回其 _所有可能的全排列_ 。你可以 **按任意顺序** 返回答案。 + + **示例 1：** + +``` +输入：nums = [1,2,3] +输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] +``` + + **示例 2：** + +``` +输入：nums = [0,1] +输出：[[0,1],[1,0]] +``` + + **示例 3：** + +``` +输入：nums = [1] +输出：[[1]] +``` + + **提示：** + +* `1 <= nums.length <= 6` +* `-10 <= nums[i] <= 10` +* `nums` 中的所有整数 **互不相同** + +--- + +回溯： + +需要一个辅助数组记录是否已经被回溯过。复杂度会比较高。 + +时间复杂度：$O(N!N)$，$N$ 为数组长度。 + +```Java +class Solution { + public List> permute(int[] nums) { + int n = nums.length; + boolean[] visited = new boolean[n]; + List> res = new ArrayList<>(); + bactrack(nums, res, new ArrayList(), visited); + return res; + } + + private void bactrack(int[] nums, List> res, ArrayList temp, boolean[] visited){ + if(temp.size() == visited.length){ + res.add(new ArrayList<>(temp)); + return; + } + for(int i = 0; i < visited.length; i++){ + if(visited[i] == true) continue; + visited[i] = true; + temp.add(nums[i]); + bactrack(nums, res, temp, visited); + visited[i] = false; + temp.remove(temp.size() - 1); + } + + } +} +``` \ No newline at end of file From e7f89e778bc5bdfbbf6156ba5a1a996e83605308 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 4 Aug 2023 15:12:42 +0800 Subject: [PATCH 103/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 40f4e96..a68cc89 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-08-04 14:42 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 4 | **2** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | | 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | @@ -333,7 +334,6 @@ | 2021-05-05 10:49 | [#剑指 Offer 11 旋转数组的最小数字](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | | 2021-04-13 18:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | | 2021-03-30 15:03 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 1 | 1 | -| 2021-03-30 14:38 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 3 | 1 | | 2021-03-30 13:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | | 2021-03-27 22:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | | 2021-03-22 18:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | From 9c06495f6681df62585310fce432d5dbea4b20d9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 9 Aug 2023 21:46:34 +0800 Subject: [PATCH 104/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a68cc89..5ee13c2 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-08-09 20:46 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 2 | **2** | | 2023-08-04 14:42 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 4 | **2** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | @@ -333,7 +334,6 @@ | 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | | 2021-05-05 10:49 | [#剑指 Offer 11 旋转数组的最小数字](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | | 2021-04-13 18:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | -| 2021-03-30 15:03 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 1 | 1 | | 2021-03-30 13:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | | 2021-03-27 22:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | | 2021-03-22 18:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | From 1b1ad968b98f808fdd2b67fc2f41850a295b795f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 10 Aug 2023 20:16:25 +0800 Subject: [PATCH 105/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5ee13c2..1dba242 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-08-10 17:44 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 6 | **3** | | 2023-08-09 20:46 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 2 | **2** | | 2023-08-04 14:42 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 4 | **2** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | @@ -163,7 +164,6 @@ | 2022-11-02 20:43 | [#1620 网络信号最好的坐标](https://leetcode.cn/problems/coordinate-with-maximum-network-quality) | MEDIUM | 1 | 1 | | 2022-11-01 14:49 | [#1662 检查两个字符串数组是否相等](https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent) | EASY | 1 | 1 | | 2022-10-31 10:25 | [#481 神奇字符串](https://leetcode.cn/problems/magical-string) | MEDIUM | 4 | 1 | -| 2022-10-30 20:27 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 4 | **2** | | 2022-10-29 23:17 | [#1773 统计匹配检索规则的物品数量](https://leetcode.cn/problems/count-items-matching-a-rule) | EASY | 2 | 1 | | 2022-10-27 10:20 | [#1822 数组元素积的符号](https://leetcode.cn/problems/sign-of-the-product-of-an-array) | EASY | 2 | 1 | | 2022-10-24 15:37 | [#1235 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling) | HARD | 7 | **2** | From cec29d1befc29078d21c1f89e6904ddc610fba43 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Thu, 10 Aug 2023 20:27:11 +0800 Subject: [PATCH 106/373] =?UTF-8?q?Create=20784.=20=E5=AD=97=E6=AF=8D?= =?UTF-8?q?=E5=A4=A7=E5=B0=8F=E5=86=99=E5=85=A8=E6=8E=92=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...31\345\205\250\346\216\222\345\210\227.md" | 89 +++++++++++++++++++ 1 file changed, 89 insertions(+) create mode 100644 "Depth First Search/784. \345\255\227\346\257\215\345\244\247\345\260\217\345\206\231\345\205\250\346\216\222\345\210\227.md" diff --git "a/Depth First Search/784. \345\255\227\346\257\215\345\244\247\345\260\217\345\206\231\345\205\250\346\216\222\345\210\227.md" "b/Depth First Search/784. \345\255\227\346\257\215\345\244\247\345\260\217\345\206\231\345\205\250\346\216\222\345\210\227.md" new file mode 100644 index 0000000..96cbee3 --- /dev/null +++ "b/Depth First Search/784. \345\255\227\346\257\215\345\244\247\345\260\217\345\206\231\345\205\250\346\216\222\345\210\227.md" @@ -0,0 +1,89 @@ +#### 784. 字母大小写全排列 + +难度：中等 + +--- + +给定一个字符串 `s` ，通过将字符串 `s` 中的每个字母转变大小写，我们可以获得一个新的字符串。 + +返回 _所有可能得到的字符串集合_ 。以 **任意顺序** 返回输出。 + + **示例 1：** + +``` +输入：s = "a1b2" +输出：["a1b2", "a1B2", "A1b2", "A1B2"] +``` + + **示例 2:** + +``` +输入: s = "3z4" +输出: ["3z4","3Z4"] +``` + + **提示:** + +* `1 <= s.length <= 12` +* `s` 由小写英文字母、大写英文字母和数字组成 + +--- + +法一，深度优先搜索： + +如果当前字符是字母，则变换大小写再调用本身。 + +```Java +class Solution { + public List letterCasePermutation(String s) { + List res = new ArrayList<>(); + dfs(res, new StringBuilder(), s); + return res; + } + + private void dfs(List res, StringBuilder sb, String s){ + int index = sb.length(); + if(index == s.length()){ + res.add(sb.toString()); + return; + } + char c = s.charAt(index); + dfs(res, new StringBuilder(sb).append(c), s); + if(Character.isLetter(c)){ + c ^= ' '; // 大小写转换，或与32异或也可以实现 + dfs(res, new StringBuilder(sb).append(c), s); + } + + } +} +``` + +法二，回溯： + +与法一类似，如果当前字符是字母，则大小写转换后回溯，同时回溯后需要将字母变换回来。 + +```java +class Solution { + public List letterCasePermutation(String s) { + List res = new ArrayList<>(); + backtrace(res, new StringBuilder(), s); + return res; + } + + private void backtrace(List res, StringBuilder sb, String s){ + int index = sb.length(); + if(index == s.length()){ + res.add(sb.toString()); + return; + } + char c = s.charAt(index); + if(Character.isLetter(c)){ + c ^= 32; + backtrace(res, new StringBuilder(sb).append(c), s); + c ^= 32; + } + backtrace(res, new StringBuilder(sb).append(c), s); + } +} +``` + From e1ae0519624ebfb296e828790ec2fafca7f61aaa Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 10 Aug 2023 20:30:51 +0800 Subject: [PATCH 107/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1dba242..277a128 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2023-08-10 17:44 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 6 | **3** | +| 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | | 2023-08-09 20:46 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 2 | **2** | | 2023-08-04 14:42 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 4 | **2** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | From 1eba76c5fdfa4fc772ba19935afda4716ba806e3 Mon Sep 17 00:00:00 2001 From: NUC11 Date: Sun, 13 Aug 2023 13:32:22 +0800 Subject: [PATCH 108/373] =?UTF-8?q?Create=2047.=20=E5=85=A8=E6=8E=92?= =?UTF-8?q?=E5=88=97=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...345\205\250\346\216\222\345\210\227 II.md" | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 "Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" diff --git "a/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" "b/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" new file mode 100644 index 0000000..36671d6 --- /dev/null +++ "b/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" @@ -0,0 +1,63 @@ +#### 47. 全排列 II + +难度：中等 + +--- + +给定一个可包含重复数字的序列 `nums` ，_**按任意顺序**_ 返回所有不重复的全排列。 + + **示例 1：** + +``` +输入：nums = [1,1,2] +输出： +[[1,1,2], + [1,2,1], + [2,1,1]] +``` + + **示例 2：** + +``` +输入：nums = [1,2,3] +输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] +``` + + **提示：** + +* `1 <= nums.length <= 8` +* `-10 <= nums[i] <= 10` + +--- + +回溯： + +与[全排列](https://leetcode.cn/problems/permutations-ii/)不同的是，本题需要进行去重操作。具体见代码。 + +```Java +class Solution { + public List> permuteUnique(int[] nums) { + Arrays.sort(nums); + List> res = new ArrayList<>(); + backtrace(nums, res, new ArrayList(), new boolean[nums.length]); + return res; + } + + private void backtrace(int[] nums, List> res, ArrayList temp, boolean[] visited){ + if(nums.length == temp.size()){ + res.add(new ArrayList<>(temp)); + return; + } + for(int i = 0; i < nums.length; i++){ + if(visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1])){ // 去重 + continue; + } + visited[i] = true; + temp.add(nums[i]); + backtrace(nums, res, temp, visited); + visited[i] = false; + temp.remove(temp.size() - 1); + } + } +} +``` \ No newline at end of file From 38e68050020ed405b89d68ad95a619d28b78eff1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 13 Aug 2023 13:34:40 +0800 Subject: [PATCH 109/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 277a128..c62f371 100644 --- a/README.md +++ b/README.md @@ -28,9 +28,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | +| 2023-08-13 12:56 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 5 | **3** | | 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | -| 2023-08-09 20:46 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 2 | **2** | -| 2023-08-04 14:42 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 4 | **2** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | | 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | From 926c28ff859b79d165ad69d2e96b070c0ccb5764 Mon Sep 17 00:00:00 2001 From: zlin1 Date: Fri, 1 Sep 2023 11:12:03 +0800 Subject: [PATCH 110/373] feat: login with cookie --- .github/workflows/action.yml | 2 +- leetcode.py | 32 ++++++++++---------------------- 2 files changed, 11 insertions(+), 23 deletions(-) diff --git a/.github/workflows/action.yml b/.github/workflows/action.yml index 24e9325..5a49237 100644 --- a/.github/workflows/action.yml +++ b/.github/workflows/action.yml @@ -50,7 +50,7 @@ jobs: # 运行leetcode.py文件 # 将在程序当前生成目录下生成一个新的README.md文件 - name: Get LeetCode Data - run: python leetcode.py ${{ secrets.LEETCODE_EMAIL }} ${{ secrets.LEETCODE_PASSWORD }} + run: python leetcode.py ${{ secrets.LEETCODE_SESSION }} # 执行push操作，推送最新的README.md文件 - uses: stefanzweifel/git-auto-commit-action@v4 diff --git a/leetcode.py b/leetcode.py index 4ba1aac..c33da60 100644 --- a/leetcode.py +++ b/leetcode.py @@ -4,9 +4,9 @@ """ @project: PyCharm @file: leetcode.py -@author: Shengqiang Zhang -@time: 2020/8/13 22:24 -@mail: sqzhang77@gmail.com +@author: CompetitiveLin +@time: 2023/09/01 10:58 +@mail: zee_lin@foxmail.com """ import sys @@ -19,29 +19,19 @@ # 登录 -def login(EMAIL, PASSWORD): +def login(LEETCODE_SESSION): session = requests.Session() # 建立会话 session.mount('http://', HTTPAdapter(max_retries=6)) # 超时重试次数 session.mount('https://', HTTPAdapter(max_retries=6)) # 超时重试次数 session.encoding = "utf-8" # 编码格式 - # 使用账号密码方式登录, 请确保账号密码正确 - login_data = { - 'login': EMAIL, - 'password': PASSWORD - } - - sign_in_url = 'https://leetcode.cn/accounts/login/' - headers = {'User-Agent': "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.122 Safari/537.36", 'Connection': 'keep-alive', 'Referer': sign_in_url, "origin": "https://leetcode.cn/"} - - # 发送登录请求 - session.post(sign_in_url, headers=headers, data=login_data, timeout=10, allow_redirects=False) + session.cookies.set('LEETCODE_SESSION', LEETCODE_SESSION) is_login = session.cookies.get('LEETCODE_SESSION') != None if is_login: print("登录成功!") return session else: - raise Exception("登录失败, 请检查账号密码是否正确!") + raise Exception("登录失败, 请检查COOKIE是否正确或过期!") # 获取某个题目的提交记录 @@ -115,12 +105,10 @@ def generate_markdown_text(response_data, session): markdown_text += "根据个人需求，目前只考虑获取**提交次数**和**重刷次数**这两个指标，以便更好地进行刷题。\n\n" markdown_text += "采用 GitHub Actions 进行自动化部署，无需本地服务器资源。\n\n" markdown_text += "## 使用教程\n\n" - markdown_text += "1. 由模板项目[生成](https://github.com/shengqiangzhang/leetcode-revise/generate)自己的项目\n\n" + markdown_text += "1. 由模板项目[生成](https://github.com/CompetitiveLin/leetcode-revise/generate)自己的项目\n\n" markdown_text += "2. 点击生成项目下的 Settings -> Secrets -> Actions -> New repository secret，分别添加以下 Secrets：\n" - markdown_text += " - Name：`LEETCODE_EMAIL`\n" - markdown_text += " - Secret：你的LeetCode账号\n" - markdown_text += " - Name：`LEETCODE_PASSWORD`\n" - markdown_text += " - Secret：你的LeetCode密码\n\n" + markdown_text += " - Name：`LEETCODE_SESSION`\n" + markdown_text += " - Secret：已登录 LeetCode 账号的浏览器中 Cookie 名为 LEETCODE_SESSION 的值\n\n" markdown_text += "3. 回到项目首页并进入 Actions 部分，在左侧点击`Github LeetCode Bot`，再点击蓝色提示框中的 `Run workflow`，最后点击绿色的 `Run workflow` 按钮即可\n\n" markdown_text += "## 补充说明\n\n" markdown_text += "默认配置为每12小时更新一次，可根据需求修改 [action.yml](.github/workflows/action.yml#L9) 文件的第 `9` 行。如有其他需求，欢迎提交PR。\n\n" @@ -178,7 +166,7 @@ def generate_markdown_text(response_data, session): if __name__ == '__main__': - session = login(sys.argv[1], sys.argv[2]) # 登录，第一个参数为leetcode邮箱账号，第二个参数为leetcode密码 + session = login(sys.argv[1]) # 登录，参数为已登录 LeetCode 账号的浏览器中 Cookie 名为 LEETCODE_SESSION 的值 response_data = get_accepted_problems(session) # 获取所有通过的题目列表 markdown_text = generate_markdown_text(response_data, session) # 生成Markdown文本 From 3651d64b5baff0be84bf96463f3128e991482762 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 1 Sep 2023 11:16:20 +0800 Subject: [PATCH 111/373] Update changes --- README.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index c62f371..7fd10b1 100644 --- a/README.md +++ b/README.md @@ -8,13 +8,11 @@ ## 使用教程 -1. 由模板项目[生成](https://github.com/shengqiangzhang/leetcode-revise/generate)自己的项目 +1. 由模板项目[生成](https://github.com/CompetitiveLin/leetcode-revise/generate)自己的项目 2. 点击生成项目下的 Settings -> Secrets -> Actions -> New repository secret，分别添加以下 Secrets： - - Name：`LEETCODE_EMAIL` - - Secret：你的LeetCode账号 - - Name：`LEETCODE_PASSWORD` - - Secret：你的LeetCode密码 + - Name：`LEETCODE_SESSION` + - Secret：已登录 LeetCode 账号的浏览器中 Cookie 名为 LEETCODE_SESSION 的值 3. 回到项目首页并进入 Actions 部分，在左侧点击`Github LeetCode Bot`，再点击蓝色提示框中的 `Run workflow`，最后点击绿色的 `Run workflow` 按钮即可 @@ -28,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | +| 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | +| 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | | 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | | 2023-08-13 12:56 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 5 | **3** | | 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | From d0bd71d1d0c1197229bc2c4f3ce59265c8855de6 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 1 Sep 2023 21:09:56 +0800 Subject: [PATCH 112/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7fd10b1..d022a0d 100644 --- a/README.md +++ b/README.md @@ -26,11 +26,11 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | | 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | | 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | -| 2023-08-13 12:56 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 5 | **3** | | 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | From 964e0a2ded11cbfceff48387c1cacf4bac0c4841 Mon Sep 17 00:00:00 2001 From: survive Date: Wed, 6 Sep 2023 17:48:34 +0800 Subject: [PATCH 113/373] =?UTF-8?q?Create=20=E5=B0=8F=E4=BA=8E=20N=20?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\346\234\200\345\244\247\346\225\260.md" | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 "Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" diff --git "a/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" "b/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" new file mode 100644 index 0000000..1a3282d --- /dev/null +++ "b/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" @@ -0,0 +1,111 @@ +### 题目描述 + +数组 nums 中给定可以使用的 1 ~ 9 的数，返回由数组 nums 中的元素组成的小于 n 的最大数。元素可以重复使用。 + +示例 1：nums = {1, 2, 9, 4}，n = 2533，返回 2499。 + +示例 2：nums = {1, 2, 5, 4}，n = 2543，返回 2542。 + +示例 3：nums = {1, 2, 5, 4}，n = 2541，返回 2525。 + +示例 4：nums = {1, 2, 9, 4}，n = 2111，返回 1999。 + +示例 5：nums = {5, 9}，n = 5555，返回 999。 + +--- + +贪心 + 二分查找：详见注释。 + +```java +package com.example.demo.test; + + +// nums = [5, 4, 8, 2], n = 5416, res = 5288 + +import java.util.Arrays; + + +public class Solution { + + public static void main(String[] args) { + int[] nums = {1,2,5,4}; + int n = 2541; + Arrays.sort(nums); + String s = findMin(n, nums[0]); + StringBuilder sb = new StringBuilder(); + boolean flag = false; + for(int i = 0; i < s.length(); i++){ + /* + 每位都找小于等于该位最大的数，如果s这个位置的数大于等于nums的最大值，就用最大值，否则去数组找最接近的 + 如果当前从数组中找的数字小于s对应这位的数字，此后选择的数字都可以是数组中的最大值 + 例如2513和{2,4,6,8}，选到第二位4之后，4比5小，此后就可以都选择8，组成2488 + */ + char c = s.charAt(i); + if(flag){ + sb.append(nums[nums.length - 1]); + } else { + int index = getIndex(nums, i, s); + sb.append(nums[index]); + if(nums[index] < c - '0') flag = true; + } + } + System.out.println(sb); + } + + public static int getIndex(int[] nums, int index, String s){ + int target = s.charAt(index) - '0'; + /* + 此外，选择数字还要受到下一位数字的影响 + 假设s为2411，nums为{2,4,6,8} + 第二位数字应该选4，但如果选了4，后面再拼接就一定会大于s了。 + */ + if(index < s.length() - 1){ + int next = s.charAt(index + 1) - '0'; + if(next <= nums[0]){ + target -= 1; + } + } + return dichotomy(nums, target); + } + + + /** + * 二分查找，查找小于等于target的最大下标。 + * @param nums + * @param target + * @return + */ + public static int dichotomy(int[] nums, int target){ + int left = 0, right = nums.length; + while(left < right){ + int mid = (left + right) / 2; + if(nums[mid] < target){ + left = mid + 1; + } else if(nums[mid] > target){ + right = mid; + } else return mid; + } + return left - 1; + } + + /** + * 判断是否能拼出和 n 长度一样的字符串，通过判断str的第一位与nums[0](minValue)的大小关系，无法判断则迭代判断下一位 + * @param n + * @param minValue + * @return + */ + public static String findMin(int n, int minValue){ + boolean flag = false; + String numStr = String.valueOf(n); + for(int i = 0; i < numStr.length(); i++){ + if(minValue < (numStr.charAt(i) - '0')){ + flag = true; + break; + } + } + int maxValue = flag ? (n - 1) : (int)(Math.pow(10, numStr.length() - 1) - 1); + return String.valueOf(maxValue); + } +} + +``` From 599413c1952fc9360db911eeacdcfe9178b0f86d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Sep 2023 11:07:45 +0800 Subject: [PATCH 114/373] =?UTF-8?q?Create=2053.=20=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E5=AD=90=E6=95=B0=E7=BB=84=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...20\346\225\260\347\273\204\345\222\214.md" | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 "Prefix Sum/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" diff --git "a/Prefix Sum/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" "b/Prefix Sum/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" new file mode 100644 index 0000000..00fbe8f --- /dev/null +++ "b/Prefix Sum/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" @@ -0,0 +1,60 @@ +#### 53. 最大子数组和 + +难度：中等 + +--- + +给你一个整数数组 `nums` ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 + + **子数组** 是数组中的一个连续部分。 + + **示例 1：** + +``` +输入：nums = [-2,1,-3,4,-1,2,1,-5,4] +输出：6 +解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 +``` + + **示例 2：** + +``` +输入：nums = [1] +输出：1 +``` + + **示例 3：** + +``` +输入：nums = [5,4,-1,7,8] +输出：23 +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `-10^4 <= nums[i] <= 10^4` + + **进阶：** 如果你已经实现复杂度为 `O(n)` 的解法，尝试使用更为精妙的 **分治法** 求解。 + +--- + +前缀和： + +顺序遍历并记录前缀和的最小值，与当前前缀和进行对比，取差值最大的即可。注意的是**前缀和数组长度为原数组长度 + 1**。 + +```Java +class Solution { + public int maxSubArray(int[] nums) { + int n = nums.length; + int[] prefix = new int[n + 1]; + int current = 0, res = nums[0]; + for(int i = 1; i < n + 1; i++){ + prefix[i] = prefix[i - 1] + nums[i - 1]; + res = Math.max(res, prefix[i] - current); + current = Math.min(current, prefix[i]); + } + return res; + } +} +``` \ No newline at end of file From 2abe4e10ae2c6deb53e03c594d313a9455685c23 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Sep 2023 11:15:29 +0800 Subject: [PATCH 115/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d022a0d..471ce1e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | | 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | From 10a0e1874aa0b84e65d987260c6ba3f150e715a5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Sep 2023 13:34:04 +0800 Subject: [PATCH 116/373] =?UTF-8?q?Create=202594.=20=E4=BF=AE=E8=BD=A6?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=B0=91=E6=97=B6=E9=97=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\260\221\346\227\266\351\227\264.md" | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 "Dichotomy/2594. \344\277\256\350\275\246\347\232\204\346\234\200\345\260\221\346\227\266\351\227\264.md" diff --git "a/Dichotomy/2594. \344\277\256\350\275\246\347\232\204\346\234\200\345\260\221\346\227\266\351\227\264.md" "b/Dichotomy/2594. \344\277\256\350\275\246\347\232\204\346\234\200\345\260\221\346\227\266\351\227\264.md" new file mode 100644 index 0000000..eb7b197 --- /dev/null +++ "b/Dichotomy/2594. \344\277\256\350\275\246\347\232\204\346\234\200\345\260\221\346\227\266\351\227\264.md" @@ -0,0 +1,75 @@ +#### 2594. 修车的最少时间 + +难度：中等 + +--- + +给你一个整数数组 `ranks` ，表示一些机械工的 **能力值**  。`ranksi` 是第 `i` 位机械工的能力值。能力值为 `r` 的机械工可以在 `r * n^2` 分钟内修好 `n` 辆车。 + +同时给你一个整数 `cars` ，表示总共需要修理的汽车数目。 + +请你返回修理所有汽车  **最少**  需要多少时间。 + + **注意：** 所有机械工可以同时修理汽车。 + + **示例 1：** + +``` +输入：ranks = [4,2,3,1], cars = 10 +输出：16 +解释： +- 第一位机械工修 2 辆车，需要 4 * 2 * 2 = 16 分钟。 +- 第二位机械工修 2 辆车，需要 2 * 2 * 2 = 8 分钟。 +- 第三位机械工修 2 辆车，需要 3 * 2 * 2 = 12 分钟。 +- 第四位机械工修 4 辆车，需要 1 * 4 * 4 = 16 分钟。 +16 分钟是修理完所有车需要的最少时间。 +``` + + **示例 2：** + +``` +输入：ranks = [5,1,8], cars = 6 +输出：16 +解释： +- 第一位机械工修 1 辆车，需要 5 * 1 * 1 = 5 分钟。 +- 第二位机械工修 4 辆车，需要 1 * 4 * 4 = 16 分钟。 +- 第三位机械工修 1 辆车，需要 8 * 1 * 1 = 8 分钟。 +16 分钟时修理完所有车需要的最少时间。 +``` + + **提示：** + +* `1 <= ranks.length <= 10^5` +* `1 <= ranks[i] <= 100` +* `1 <= cars <= 10^6` + +--- + +二分查找： + +按时间维度进行二分查找，上界可以取正无穷，也可以取任意一个工人修完所有车辆所需要的时间；下界取 `1`，最少需要的时间。如果 `t` 时间内完成修车任务，那么一定是所有工人一起工作。 + +```Java +class Solution { + public long repairCars(int[] ranks, int cars) { + long left = 1, right = 1l * ranks[0] * cars * cars; + while(left <= right){ + long mid = (right - left) / 2 + left; + if(check(ranks, cars, mid)){ + right = mid - 1; + } else { + left = mid + 1; + } + } + return left; + } + + private boolean check(int[] ranks, int cars, long time){ + long count = 0; + for(int rank: ranks){ + count += (long) Math.sqrt(time / rank); + } + return count >= cars; + } +} +``` \ No newline at end of file From 1beb1c3618dc522b2e4cf2f4b2f105455e2ec9d1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Sep 2023 13:36:30 +0800 Subject: [PATCH 117/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 471ce1e..543b576 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | | 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | From 9e0764bff8f4fcd1621230cb83f565e04b8d4dcf Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 11 Sep 2023 20:30:23 +0800 Subject: [PATCH 118/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 543b576..d55c49a 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | | 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | @@ -219,7 +220,6 @@ | 2022-07-05 11:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | | 2022-07-04 10:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | | 2022-07-03 20:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | -| 2022-07-03 18:41 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 3 | 1 | | 2022-06-24 13:38 | [#515 在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row) | MEDIUM | 1 | 1 | | 2022-06-22 14:33 | [#513 找树左下角的值](https://leetcode.cn/problems/find-bottom-left-tree-value) | MEDIUM | 4 | 1 | | 2022-06-21 19:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | From 4c920f027ba6a1e4941408d777aa5ee40d35a310 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 11 Sep 2023 23:08:12 +0800 Subject: [PATCH 119/373] =?UTF-8?q?Create=2031.=20=E4=B8=8B=E4=B8=80?= =?UTF-8?q?=E4=B8=AA=E6=8E=92=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\270\252\346\216\222\345\210\227.md" | 85 +++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 "Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" diff --git "a/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" new file mode 100644 index 0000000..7f198c4 --- /dev/null +++ "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" @@ -0,0 +1,85 @@ +#### 31. 下一个排列 + +难度：中等 + +--- + +整数数组的一个 **排列**   就是将其所有成员以序列或线性顺序排列。 + +* 例如，`arr = [1,2,3]` ，以下这些都可以视作 `arr` 的排列：`[1,2,3]`、`[1,3,2]`、`[3,1,2]`、`[2,3,1]` 。 + +整数数组的 **下一个排列** 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 **下一个排列** 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。 + +* 例如，`arr = [1,2,3]` 的下一个排列是 `[1,3,2]` 。 +* 类似地，`arr = [2,3,1]` 的下一个排列是 `[3,1,2]` 。 +* 而 `arr = [3,2,1]` 的下一个排列是 `[1,2,3]` ，因为 `[3,2,1]` 不存在一个字典序更大的排列。 + +给你一个整数数组 `nums` ，找出 `nums` 的下一个排列。 + +必须 **[原地](https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 修改，只允许使用额外常数空间。 + + **示例 1：** + +``` +输入：nums = [1,2,3] +输出：[1,3,2] +``` + + **示例 2：** + +``` +输入：nums = [3,2,1] +输出：[1,2,3] +``` + + **示例 3：** + +``` +输入：nums = [1,1,5] +输出：[1,5,1] +``` + + **提示：** + +* `1 <= nums.length <= 100` +* `0 <= nums[i] <= 100` + +--- + +算法步骤： + +1. 从后往前找到第一个升序的元素对，分别定义其下标为 `index - 1` 和 `index`，即 `nums[index - 1] < nums[i]` +2. 重新从后往前找到第一个大于 `nums[index - 1]` 的元素，定义其下标为 `i`， 即元素为 `nums[i]` 并交换 `nums[index - 1]` +3. 接着反转 `[index , n - 1]` 范围内的所有元素，因为 `[index, n - 1]` 范围内的元素经过第一步筛选后一定是非升序的，下一个更大的排列一定是升序的。 + +```Java +class Solution { + public void nextPermutation(int[] nums) { + int n = nums.length, index = n - 1; + while(index > 0){ + if(nums[index] > nums[index - 1]){ + break; + } + index--; + } + if(index != 0){ + for(int i = n - 1; i >= index; i--){ + if(nums[index - 1] < nums[i]){ + swap(nums, index - 1, i); + break; + } + } + } + int left = index, right = n - 1; + while(left < right){ + swap(nums, left++, right--); + } + } + + private void swap(int[] nums, int i, int j){ + int temp = nums[i]; + nums[i] = nums[j]; + nums[j] = temp; + } +} +``` \ No newline at end of file From d74f90564ab0dfcbfc08deff6d19fab8fa580562 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 12 Sep 2023 20:24:11 +0800 Subject: [PATCH 120/373] =?UTF-8?q?Create=20438.=20=E6=89=BE=E5=88=B0?= =?UTF-8?q?=E5=AD=97=E7=AC=A6=E4=B8=B2=E4=B8=AD=E6=89=80=E6=9C=89=E5=AD=97?= =?UTF-8?q?=E6=AF=8D=E5=BC=82=E4=BD=8D=E8=AF=8D.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...15\345\274\202\344\275\215\350\257\215.md" | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 "Sliding Window/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" diff --git "a/Sliding Window/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/Sliding Window/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" new file mode 100644 index 0000000..f30c60b --- /dev/null +++ "b/Sliding Window/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" @@ -0,0 +1,68 @@ +#### 438. 找到字符串中所有字母异位词 + +难度：中等 + +--- + +给定两个字符串 `s` 和 `p`，找到 `s` 中所有 `p` 的  **异位词**  的子串，返回这些子串的起始索引。不考虑答案输出的顺序。 + + **异位词** 指由相同字母重排列形成的字符串（包括相同的字符串）。 + + **示例 1:** + +``` +输入: s = "cbaebabacd", p = "abc" +输出: [0,6] +解释: +起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。 +起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。 +``` + +  **示例 2:** + +``` +输入: s = "abab", p = "ab" +输出: [0,1,2] +解释: +起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。 +起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。 +起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。 +``` + + **提示:** + +* `1 <= s.length, p.length <= 3 * 10^4` +* `s` 和 `p` 仅包含小写字母 + +--- + +滑动窗口： + +注意审题，在 `s` 中找所有 `p` 的子串。还有 `Arrays.equals(array1, array2)` 这个方法的使用来判断两个数组是否相同，不过也可以用数组遍历的方式替代。 + +以 `p` 为固定长度的数组在字符串 `s` 中进行滑动，每次滑动都进行相应的加减操作。 + +```Java +class Solution { + public List findAnagrams(String s, String p) { + if(s.length() < p.length()) return new ArrayList(); + int[] sCount = new int[26], pCount = new int[26]; + List ans = new ArrayList<>(); + for(int i = 0; i < p.length(); i++){ + sCount[s.charAt(i) - 'a']++; + pCount[p.charAt(i) - 'a']++; + } + if(Arrays.equals(sCount, pCount)){ + ans.add(0); + } + for(int i = 0; i < s.length() - p.length(); i++){ // 滑动 + sCount[s.charAt(i) - 'a']--; + sCount[s.charAt(i + p.length()) - 'a']++; + if(Arrays.equals(sCount, pCount)){ + ans.add(i + 1); + } + } + return ans; + } +} +``` \ No newline at end of file From 47eb5f7a12013f41e776769e7def6dde76505e11 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 12 Sep 2023 20:26:55 +0800 Subject: [PATCH 121/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d55c49a..ebd40a7 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | From bfa91f0366c1ea39672e041e3d57d95c9ab4d72a Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Wed, 13 Sep 2023 20:26:03 +0800 Subject: [PATCH 122/373] =?UTF-8?q?Create=20763.=20=E5=88=92=E5=88=86?= =?UTF-8?q?=E5=AD=97=E6=AF=8D=E5=8C=BA=E9=97=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...27\346\257\215\345\214\272\351\227\264.md" | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 "Greedy/763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" diff --git "a/Greedy/763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" "b/Greedy/763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" new file mode 100644 index 0000000..91c8bb6 --- /dev/null +++ "b/Greedy/763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" @@ -0,0 +1,65 @@ +#### 763. 划分字母区间 + +难度：中等 + +--- + +给你一个字符串 `s` 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。 + +注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 `s` 。 + +返回一个表示每个字符串片段的长度的列表。 + + **示例 1：** +``` +输入：s = "ababcbacadefegdehijhklij" +输出：[9,7,8] +解释： +划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。 +每个字母最多出现在一个片段中。 +像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 +``` + + **示例 2：** + +``` +输入：s = "eccbbbbdec" +输出：[10] +``` + + **提示：** + +* `1 <= s.length <= 500` +* `s` 仅由小写英文字母组成 + +--- + +贪心： + +由于同一个字母只能出现在同一个片段，显然同一个字母的第一次出现的下标位置和最后一次出现的下标位置必须出现在同一个片段。 + +因此先顺序遍历，记录每一个字母出现的最大下标处。 + +接着再顺序遍历一遍，遍历的过程中将指针**移动当前字母出现的最大下标处**。如果指针刚好是当前下标，则意味着从起始位置到当前位置是一个符合要求的答案，接着更新起始位置下标继续遍历。 + +```Java +class Solution { + public List partitionLabels(String s) { + int n = s.length(); + int[] alphabet = new int[26]; + for(int i = 0; i < n; i++){ + alphabet[s.charAt(i) - 'a'] = i; + } + List res = new ArrayList<>(); + int start = 0, end = 0; + for(int i = 0; i < n; i++){ + end = Math.max(end, alphabet[s.charAt(i) - 'a']); // 直接将尾指针移到了当前字母出现的最大下标处 + if(i == end){ + res.add(end - start + 1); + start = end + 1; + } + } + return res; + } +} +``` \ No newline at end of file From f56f3145ee4e7fee59d77161c977da73af0835aa Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 13 Sep 2023 20:28:44 +0800 Subject: [PATCH 123/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ebd40a7..59ba6a4 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | From 15d17da5b923688176079b11a85d4f72e8113242 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 14 Sep 2023 20:26:27 +0800 Subject: [PATCH 124/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 59ba6a4..252d989 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | From 9737c46f202d3e9a53056f02e23019636bde0131 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 15 Sep 2023 17:47:18 +0800 Subject: [PATCH 125/373] =?UTF-8?q?Create=2075.=20=E9=A2=9C=E8=89=B2?= =?UTF-8?q?=E5=88=86=E7=B1=BB.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...34\350\211\262\345\210\206\347\261\273.md" | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 "Two Pointers/75. \351\242\234\350\211\262\345\210\206\347\261\273.md" diff --git "a/Two Pointers/75. \351\242\234\350\211\262\345\210\206\347\261\273.md" "b/Two Pointers/75. \351\242\234\350\211\262\345\210\206\347\261\273.md" new file mode 100644 index 0000000..88362f9 --- /dev/null +++ "b/Two Pointers/75. \351\242\234\350\211\262\345\210\206\347\261\273.md" @@ -0,0 +1,68 @@ +#### 75. 颜色分类 + +难度：中等 + +--- + +给定一个包含红色、白色和蓝色、共 `n` 个元素的数组 `nums` ， **[原地](https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。 + +我们使用整数 `0`、 `1` 和 `2` 分别表示红色、白色和蓝色。 + +必须在不使用库内置的 sort 函数的情况下解决这个问题。 + + **示例 1：** + +``` +输入：nums = [2,0,2,1,1,0] +输出：[0,0,1,1,2,2] +``` + + **示例 2：** + +``` +输入：nums = [2,0,1] +输出：[0,1,2] +``` + + **提示：** + +* `n == nums.length` +* `1 <= n <= 300` +* `nums[i]` 为 `0`、`1` 或 `2` + + **进阶：** + +* 你能想出一个仅使用常数空间的一趟扫描算法吗？ + +--- + +双指针： + +**尾指针**指向最后，**头指针**指向最前。另外需要一个**遍历指针**从头向尾遍历，然后分类讨论（重要）： + +1. 如果当前元素为 `0`，与头指针元素交换并将遍历指针和头指针都向右移动一个单位。 +2. 如果当前元素为 `1`，只移动遍历指针 +3. 如果当前元素为 `2`，与尾指针元素交换并左移尾指针，此时不移动遍历指针！！！ + +```Java +class Solution { + public void sortColors(int[] nums) { + int left = 0, right = nums.length - 1, index = 0; + while(index <= right){ + if(nums[index] == 2){ + swap(nums, index, right--); + continue; + } else if(nums[index] == 0){ + swap(nums, left++, index); + } + index++; + } + } + + private void swap(int[] nums, int left, int right){ + int temp = nums[left]; + nums[left] = nums[right]; + nums[right] = temp; + } +} +``` \ No newline at end of file From f7eed28775f84d5bce261f1412e873fd6426bab3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 16 Sep 2023 13:15:28 +0800 Subject: [PATCH 126/373] =?UTF-8?q?Create=20198.=20=E6=89=93=E5=AE=B6?= =?UTF-8?q?=E5=8A=AB=E8=88=8D.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...23\345\256\266\345\212\253\350\210\215.md" | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 "Dynamic Programming/198. \346\211\223\345\256\266\345\212\253\350\210\215.md" diff --git "a/Dynamic Programming/198. \346\211\223\345\256\266\345\212\253\350\210\215.md" "b/Dynamic Programming/198. \346\211\223\345\256\266\345\212\253\350\210\215.md" new file mode 100644 index 0000000..c7c29f4 --- /dev/null +++ "b/Dynamic Programming/198. \346\211\223\345\256\266\345\212\253\350\210\215.md" @@ -0,0 +1,60 @@ +#### 198. 打家劫舍 + +难度：中等 + +--- + +你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统， **如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警** 。 + +给定一个代表每个房屋存放金额的非负整数数组，计算你 **不触动警报装置的情况下** ，一夜之内能够偷窃到的最高金额。 + + **示例 1：** + +``` +输入：[1,2,3,1] +输出：4 +解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 +  偷窃到的最高金额 = 1 + 3 = 4 。 +``` + + **示例 2：** + +``` +输入：[2,7,9,3,1] +输出：12 +解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 +  偷窃到的最高金额 = 2 + 9 + 1 = 12 。 +``` + + **提示：** + +* `1 <= nums.length <= 100` +* `0 <= nums[i] <= 400` + +--- + +动态规划： + +子问题：偷**前 `k` 个房子**的最大金额。 + +状态转移方程： +$$ +dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]) +$$ + + +```Java +class Solution { + public int rob(int[] nums) { + int n = nums.length; + if(n == 1) return nums[0]; + int[] dp = new int[n]; + dp[0] = nums[0]; + dp[1] = Math.max(nums[0], nums[1]); + for(int i = 2; i < n; i++){ + dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]); + } + return dp[n - 1]; + } +} +``` \ No newline at end of file From b46220e31a662d4d52961caa5f998d6e087442af Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 16 Sep 2023 13:17:50 +0800 Subject: [PATCH 127/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 252d989..01de647 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-16 12:58 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 9 | **4** | | 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | @@ -288,7 +289,6 @@ | 2022-04-06 14:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | | 2022-04-05 15:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | | 2022-04-03 20:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | -| 2022-04-02 20:52 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 8 | **3** | | 2022-04-02 18:50 | [#132 分割回文串 II](https://leetcode.cn/problems/palindrome-partitioning-ii) | HARD | 4 | 1 | | 2022-04-01 11:41 | [#954 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs) | MEDIUM | 10 | 1 | | 2022-03-31 12:57 | [#728 自除数](https://leetcode.cn/problems/self-dividing-numbers) | EASY | 1 | 1 | From 9bbda0f6cabcef74a3992d1e85d884e37775b401 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 17 Sep 2023 22:06:07 +0800 Subject: [PATCH 128/373] =?UTF-8?q?Create=20213.=20=E6=89=93=E5=AE=B6?= =?UTF-8?q?=E5=8A=AB=E8=88=8D=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...345\256\266\345\212\253\350\210\215 II.md" | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 "Dynamic Programming/213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md" diff --git "a/Dynamic Programming/213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md" "b/Dynamic Programming/213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md" new file mode 100644 index 0000000..e29d965 --- /dev/null +++ "b/Dynamic Programming/213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md" @@ -0,0 +1,66 @@ +#### 213. 打家劫舍 II + +难度：中等 + +--- + +你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 **围成一圈** ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统， **如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警** 。 + +给定一个代表每个房屋存放金额的非负整数数组，计算你 **在不触动警报装置的情况下** ，今晚能够偷窃到的最高金额。 + + **示例 1：** + +``` +输入：nums = [2,3,2] +输出：3 +解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。 +``` + + **示例 2：** + +``` +输入：nums = [1,2,3,1] +输出：4 +解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。 +  偷窃到的最高金额 = 1 + 3 = 4 。 +``` + + **示例 3：** + +``` +输入：nums = [1,2,3] +输出：3 +``` + + **提示：** + +* `1 <= nums.length <= 100` +* `0 <= nums[i] <= 1000` + +--- + +动态规划： + +与打家劫舍相比，考虑以下两种情况： + +1. 偷 `nums[0]`，那么 `nums[1]` 和 `nums[n - 1]` 不能偷，问题变成了 `nums[2]` 到 `nums[n - 2]` 的打家劫舍 +2. 不偷 `nums[0]`，那么问题变成了 `nums[1]` 到 `nums[n - 1]` 的打家劫舍 + +```Java +class Solution { + public int rob(int[] nums) { + int n = nums.length; + return Math.max(nums[0] + subrob(nums, 2, n - 1), subrob(nums, 1, n)); + } + + private int subrob(int[] nums, int left, int right){ + int f0 = 0, f1 = 0; + for(int i = left; i < right; i++){ + int newF = Math.max(f1, f0 + nums[i]); + f0 = f1; + f1 = newF; + } + return f1; + } +} +``` \ No newline at end of file From 9a51c021b7f2b2599928877f8e5f0c123df2d8a0 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 17 Sep 2023 22:09:14 +0800 Subject: [PATCH 129/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 01de647..1063b40 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2023-09-16 12:58 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 9 | **4** | +| 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | +| 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | | 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | @@ -318,7 +319,6 @@ | 2021-07-13 09:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | | 2021-07-12 19:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | | 2021-07-12 18:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | -| 2021-07-07 14:10 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 3 | 1 | | 2021-07-06 16:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | | 2021-07-06 16:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | | 2021-07-05 15:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | From 174b718dff6b16fae5f9f224ebfcf99287504d0b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Sep 2023 19:58:05 +0800 Subject: [PATCH 130/373] =?UTF-8?q?Create=20337.=20=E6=89=93=E5=AE=B6?= =?UTF-8?q?=E5=8A=AB=E8=88=8D=20III.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...45\256\266\345\212\253\350\210\215 III.md" | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 "Depth First Search/337. \346\211\223\345\256\266\345\212\253\350\210\215 III.md" diff --git "a/Depth First Search/337. \346\211\223\345\256\266\345\212\253\350\210\215 III.md" "b/Depth First Search/337. \346\211\223\345\256\266\345\212\253\350\210\215 III.md" new file mode 100644 index 0000000..7af77e7 --- /dev/null +++ "b/Depth First Search/337. \346\211\223\345\256\266\345\212\253\350\210\215 III.md" @@ -0,0 +1,77 @@ +#### 337. 打家劫舍 III + +难度：中等 + +--- + +小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 `root` 。 + +除了 `root` 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 **两个直接相连的房子在同一天晚上被打劫** ，房屋将自动报警。 + +给定二叉树的 `root` 。返回 _ **在不触动警报的情况下**  ，小偷能够盗取的最高金额_ 。 + + **示例 1:** + +![](https://assets.leetcode.com/uploads/2021/03/10/rob1-tree.jpg) + +``` +输入: root = [3,2,3,null,3,null,1] +输出: 7 +解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7 +``` + + **示例 2:** + +![](https://assets.leetcode.com/uploads/2021/03/10/rob2-tree.jpg) + +``` +输入: root = [3,4,5,1,3,null,1] +输出: 9 +解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9 +``` + + **提示：** + +* 树的节点数在 `[1, 10^4]` 范围内 +* `0 <= Node.val <= 10^4` + +--- + +深度优先搜索： + +假设当前节点不选择，那么当前节点的最大盗取金额为左节点的最大值（不管左节点选还是不选）和右节点的最大值（同样的，不管右节点选还是不选）。 + +递归方法的返回类型应为长度为 `2` 的数组，第一个元素表示选当前节点的最大值，第二个元素表示不选当前节点的最大值。 + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int rob(TreeNode root) { + int[] array = dfs(root); + return Math.max(array[0], array[1]); + } + + private int[] dfs(TreeNode root){ + if(root == null) return new int[]{0, 0}; + int[] left = dfs(root.left); + int[] right = dfs(root.right); + int selected = root.val + left[1] + right[1]; + int notSelected = Math.max(left[0], left[1]) + Math.max(right[0], right[1]); + return new int[]{selected, notSelected}; + } +} +``` \ No newline at end of file From cc0f641d7dd01bb4f6bb2061c6746fad3556f5e5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Sep 2023 20:00:37 +0800 Subject: [PATCH 131/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1063b40..c013695 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | | 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | | 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | | 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | @@ -353,7 +354,6 @@ | 2020-08-10 14:09 | [#696 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings) | EASY | 4 | 1 | | 2020-08-08 09:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | | 2020-08-06 16:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | -| 2020-08-05 16:41 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 2 | 1 | | 2020-08-03 20:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | | 2020-08-02 19:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | | 2020-07-31 13:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | From 2abb8191f45ebd46a737f5880030d02744e1cd54 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 20 Sep 2023 08:57:16 +0800 Subject: [PATCH 132/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c013695..f3f2e69 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | | 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | | 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | | 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | From 3f05361c4d47a12f10d09c7a459a3933f5360e51 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 21 Sep 2023 13:50:27 +0800 Subject: [PATCH 133/373] Update changes --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index f3f2e69..63623f3 100644 --- a/README.md +++ b/README.md @@ -86,7 +86,7 @@ | 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | | 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | | 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | -| 2023-03-08 21:52 | [#剑指 Offer 47 礼物的最大价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | +| 2023-03-08 21:52 | [#LCR 166 珠宝的最高价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | | 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | | 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | | 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | @@ -117,7 +117,7 @@ | 2022-12-17 18:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | | 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | | 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | -| 2022-12-15 20:42 | [#剑指 Offer 25 合并两个排序的链表](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | +| 2022-12-15 20:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | | 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | | 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | | 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | @@ -218,7 +218,7 @@ | 2022-07-23 14:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | | 2022-07-17 11:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | | 2022-07-14 13:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | -| 2022-07-13 19:22 | [#735 行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | +| 2022-07-13 19:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | | 2022-07-11 13:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | | 2022-07-08 14:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | | 2022-07-08 13:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | @@ -340,7 +340,7 @@ | 2021-05-21 14:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | | 2021-05-10 15:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | | 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | -| 2021-05-05 10:49 | [#剑指 Offer 11 旋转数组的最小数字](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | +| 2021-05-05 10:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | | 2021-04-13 18:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | | 2021-03-30 13:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | | 2021-03-27 22:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | From 542eda18a510c5685aeae907456c30cd0cfbe3af Mon Sep 17 00:00:00 2001 From: survive Date: Thu, 21 Sep 2023 13:50:58 +0800 Subject: [PATCH 134/373] Update action.yml --- .github/workflows/action.yml | 27 ++------------------------- 1 file changed, 2 insertions(+), 25 deletions(-) diff --git a/.github/workflows/action.yml b/.github/workflows/action.yml index 5a49237..f83cc63 100644 --- a/.github/workflows/action.yml +++ b/.github/workflows/action.yml @@ -11,34 +11,11 @@ on: jobs: bot: - # 运行环境，Ubuntu-20.04 - runs-on: Ubuntu-20.04 + 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 @@ -55,4 +32,4 @@ jobs: # 执行push操作，推送最新的README.md文件 - uses: stefanzweifel/git-auto-commit-action@v4 with: - commit_message: Update changes \ No newline at end of file + commit_message: Update changes From d0cae462ae058fe397a2df3c54e028c88812c986 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 21 Sep 2023 05:53:17 +0000 Subject: [PATCH 135/373] Update changes --- README.md | 688 +++++++++++++++++++++++++++--------------------------- 1 file changed, 344 insertions(+), 344 deletions(-) diff --git a/README.md b/README.md index 63623f3..35803f6 100644 --- a/README.md +++ b/README.md @@ -26,347 +26,347 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | -| 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | -| 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | -| 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | -| 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | -| 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | -| 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | -| 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | -| 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | -| 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | -| 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | -| 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | -| 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | -| 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | -| 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | -| 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | -| 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | -| 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | -| 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | -| 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | -| 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | -| 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | -| 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | -| 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | -| 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | -| 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | -| 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | -| 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | -| 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | -| 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | -| 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | -| 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | -| 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | -| 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | -| 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | -| 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | -| 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | -| 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | -| 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | -| 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | -| 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | -| 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | -| 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | -| 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | -| 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | -| 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | -| 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | -| 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | -| 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | -| 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | -| 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | -| 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | -| 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | -| 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | -| 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | -| 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | -| 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | -| 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | -| 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | -| 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | -| 2023-03-08 21:52 | [#LCR 166 珠宝的最高价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | -| 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | -| 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | -| 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | -| 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | -| 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | -| 2023-02-12 09:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | -| 2023-02-09 17:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | -| 2023-02-08 14:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | -| 2023-01-30 19:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | -| 2023-01-29 16:50 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 2 | 1 | -| 2023-01-28 14:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | -| 2023-01-27 20:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | -| 2023-01-27 19:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | -| 2023-01-26 18:25 | [#1663 具有给定数值的最小字符串](https://leetcode.cn/problems/smallest-string-with-a-given-numeric-value) | MEDIUM | 2 | 1 | -| 2023-01-23 22:32 | [#199 二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view) | MEDIUM | 2 | 1 | -| 2023-01-16 22:39 | [#1813 句子相似性 III](https://leetcode.cn/problems/sentence-similarity-iii) | MEDIUM | 3 | 1 | -| 2023-01-13 20:15 | [#38 外观数列](https://leetcode.cn/problems/count-and-say) | MEDIUM | 1 | 1 | -| 2023-01-13 14:19 | [#36 有效的数独](https://leetcode.cn/problems/valid-sudoku) | MEDIUM | 1 | 1 | -| 2023-01-09 16:15 | [#1806 还原排列的最少操作步数](https://leetcode.cn/problems/minimum-number-of-operations-to-reinitialize-a-permutation) | MEDIUM | 1 | 1 | -| 2023-01-07 22:33 | [#1658 将 x 减到 0 的最小操作数](https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero) | MEDIUM | 1 | 1 | -| 2023-01-05 20:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | -| 2023-01-05 19:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | -| 2023-01-03 15:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | -| 2023-01-01 19:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | -| 2022-12-31 10:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | -| 2022-12-19 14:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | -| 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | -| 2022-12-17 18:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | -| 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | -| 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | -| 2022-12-15 20:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | -| 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | -| 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | -| 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | -| 2022-12-13 11:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | -| 2022-12-12 16:15 | [#1781 所有子字符串美丽值之和](https://leetcode.cn/problems/sum-of-beauty-of-all-substrings) | MEDIUM | 1 | 1 | -| 2022-12-11 16:13 | [#1827 最少操作使数组递增](https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing) | EASY | 1 | 1 | -| 2022-12-10 18:47 | [#1691 堆叠长方体的最大高度](https://leetcode.cn/problems/maximum-height-by-stacking-cuboids) | HARD | 12 | 1 | -| 2022-12-08 09:57 | [#1812 判断国际象棋棋盘中一个格子的颜色](https://leetcode.cn/problems/determine-color-of-a-chessboard-square) | EASY | 2 | 1 | -| 2022-12-07 22:24 | [#1775 通过最少操作次数使数组的和相等](https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations) | MEDIUM | 7 | 1 | -| 2022-12-06 18:03 | [#852 山脉数组的峰顶索引](https://leetcode.cn/problems/peak-index-in-a-mountain-array) | MEDIUM | 2 | **2** | -| 2022-12-06 17:43 | [#1805 字符串中不同整数的数目](https://leetcode.cn/problems/number-of-different-integers-in-a-string) | EASY | 5 | 1 | -| 2022-12-05 14:01 | [#8 字符串转换整数 (atoi)](https://leetcode.cn/problems/string-to-integer-atoi) | MEDIUM | 17 | 1 | -| 2022-12-03 10:38 | [#1796 字符串中第二大的数字](https://leetcode.cn/problems/second-largest-digit-in-a-string) | EASY | 4 | 1 | -| 2022-12-02 10:12 | [#1769 移动所有球到每个盒子所需的最小操作数](https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box) | MEDIUM | 1 | 1 | -| 2022-12-01 10:32 | [#1779 找到最近的有相同 X 或 Y 坐标的点](https://leetcode.cn/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate) | EASY | 1 | 1 | -| 2022-11-30 15:35 | [#895 最大频率栈](https://leetcode.cn/problems/maximum-frequency-stack) | HARD | 2 | 1 | -| 2022-11-29 18:06 | [#1758 生成交替二进制字符串的最少操作数](https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string) | EASY | 1 | 1 | -| 2022-11-28 16:31 | [#813 最大平均值和的分组](https://leetcode.cn/problems/largest-sum-of-averages) | MEDIUM | 3 | 1 | -| 2022-11-27 20:12 | [#1752 检查数组是否经排序和轮转得到](https://leetcode.cn/problems/check-if-array-is-sorted-and-rotated) | EASY | 2 | 1 | -| 2022-11-26 19:10 | [#743 网络延迟时间](https://leetcode.cn/problems/network-delay-time) | MEDIUM | 9 | **5** | -| 2022-11-26 18:56 | [#787 K 站中转内最便宜的航班](https://leetcode.cn/problems/cheapest-flights-within-k-stops) | MEDIUM | 6 | **2** | -| 2022-11-26 16:01 | [#882 细分图中的可到达节点](https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph) | HARD | 2 | 1 | -| 2022-11-26 13:52 | [#809 情感丰富的文字](https://leetcode.cn/problems/expressive-words) | MEDIUM | 2 | 1 | -| 2022-11-24 16:25 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 6 | **2** | -| 2022-11-24 15:52 | [#1668 最大重复子字符串](https://leetcode.cn/problems/maximum-repeating-substring) | EASY | 4 | **2** | -| 2022-11-24 15:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | -| 2022-11-23 21:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | -| 2022-11-23 17:30 | [#1742 盒子中小球的最大数量](https://leetcode.cn/problems/maximum-number-of-balls-in-a-box) | EASY | 1 | 1 | -| 2022-11-21 20:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | -| 2022-11-21 19:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | -| 2022-11-21 18:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | -| 2022-11-21 16:43 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 5 | **2** | -| 2022-11-21 14:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | -| 2022-11-21 11:04 | [#799 香槟塔](https://leetcode.cn/problems/champagne-tower) | MEDIUM | 2 | 1 | -| 2022-11-19 20:48 | [#139 单词拆分](https://leetcode.cn/problems/word-break) | MEDIUM | 3 | 1 | -| 2022-11-19 16:56 | [#208 实现 Trie (前缀树)](https://leetcode.cn/problems/implement-trie-prefix-tree) | MEDIUM | 2 | 1 | -| 2022-11-19 10:02 | [#1732 找到最高海拔](https://leetcode.cn/problems/find-the-highest-altitude) | EASY | 1 | 1 | -| 2022-11-18 00:48 | [#792 匹配子序列的单词数](https://leetcode.cn/problems/number-of-matching-subsequences) | MEDIUM | 2 | 1 | -| 2022-11-16 13:19 | [#775 全局倒置与局部倒置](https://leetcode.cn/problems/global-and-local-inversions) | MEDIUM | 9 | 1 | -| 2022-11-15 20:30 | [#1926 迷宫中离入口最近的出口](https://leetcode.cn/problems/nearest-exit-from-entrance-in-maze) | MEDIUM | 4 | 1 | -| 2022-11-15 19:11 | [#1710 卡车上的最大单元数](https://leetcode.cn/problems/maximum-units-on-a-truck) | EASY | 2 | 1 | -| 2022-11-14 00:19 | [#704 二分查找](https://leetcode.cn/problems/binary-search) | EASY | 10 | **2** | -| 2022-11-13 17:37 | [#916 单词子集](https://leetcode.cn/problems/word-subsets) | MEDIUM | 4 | 1 | -| 2022-11-13 15:18 | [#剑指 Offer 51 数组中的逆序对](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | -| 2022-11-13 13:33 | [#791 自定义字符串排序](https://leetcode.cn/problems/custom-sort-string) | MEDIUM | 2 | 1 | -| 2022-11-12 20:54 | [#1339 分裂二叉树的最大乘积](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree) | MEDIUM | 3 | 1 | -| 2022-11-12 14:18 | [#790 多米诺和托米诺平铺](https://leetcode.cn/problems/domino-and-tromino-tiling) | MEDIUM | 4 | 1 | -| 2022-11-11 13:02 | [#129 求根节点到叶节点数字之和](https://leetcode.cn/problems/sum-root-to-leaf-numbers) | MEDIUM | 3 | 1 | -| 2022-11-11 10:03 | [#1704 判断字符串的两半是否相似](https://leetcode.cn/problems/determine-if-string-halves-are-alike) | EASY | 1 | 1 | -| 2022-11-08 08:26 | [#1684 统计一致字符串的数目](https://leetcode.cn/problems/count-the-number-of-consistent-strings) | EASY | 1 | 1 | -| 2022-11-07 15:37 | [#816 模糊坐标](https://leetcode.cn/problems/ambiguous-coordinates) | MEDIUM | 2 | 1 | -| 2022-11-06 11:38 | [#1678 设计 Goal 解析器](https://leetcode.cn/problems/goal-parser-interpretation) | EASY | 1 | 1 | -| 2022-11-05 18:31 | [#1106 解析布尔表达式](https://leetcode.cn/problems/parsing-a-boolean-expression) | HARD | 3 | 1 | -| 2022-11-04 14:12 | [#754 到达终点数字](https://leetcode.cn/problems/reach-a-number) | MEDIUM | 4 | 1 | -| 2022-11-02 20:43 | [#1620 网络信号最好的坐标](https://leetcode.cn/problems/coordinate-with-maximum-network-quality) | MEDIUM | 1 | 1 | -| 2022-11-01 14:49 | [#1662 检查两个字符串数组是否相等](https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent) | EASY | 1 | 1 | -| 2022-10-31 10:25 | [#481 神奇字符串](https://leetcode.cn/problems/magical-string) | MEDIUM | 4 | 1 | -| 2022-10-29 23:17 | [#1773 统计匹配检索规则的物品数量](https://leetcode.cn/problems/count-items-matching-a-rule) | EASY | 2 | 1 | -| 2022-10-27 10:20 | [#1822 数组元素积的符号](https://leetcode.cn/problems/sign-of-the-product-of-an-array) | EASY | 2 | 1 | -| 2022-10-24 15:37 | [#1235 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling) | HARD | 7 | **2** | -| 2022-10-24 08:13 | [#915 分割数组](https://leetcode.cn/problems/partition-array-into-disjoint-intervals) | MEDIUM | 3 | 1 | -| 2022-10-23 18:07 | [#1768 交替合并字符串](https://leetcode.cn/problems/merge-strings-alternately) | EASY | 2 | 1 | -| 2022-10-21 10:50 | [#901 股票价格跨度](https://leetcode.cn/problems/online-stock-span) | MEDIUM | 1 | 1 | -| 2022-10-20 21:51 | [#779 第K个语法符号](https://leetcode.cn/problems/k-th-symbol-in-grammar) | MEDIUM | 1 | 1 | -| 2022-10-19 16:47 | [#1700 无法吃午餐的学生数量](https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch) | EASY | 2 | 1 | -| 2022-10-17 12:25 | [#904 水果成篮](https://leetcode.cn/problems/fruit-into-baskets) | MEDIUM | 3 | 1 | -| 2022-10-16 13:16 | [#886 可能的二分法](https://leetcode.cn/problems/possible-bipartition) | MEDIUM | 4 | 1 | -| 2022-10-15 14:16 | [#7 整数反转](https://leetcode.cn/problems/reverse-integer) | MEDIUM | 4 | 1 | -| 2022-10-15 10:09 | [#1441 用栈操作构建数组](https://leetcode.cn/problems/build-an-array-with-stack-operations) | MEDIUM | 4 | 1 | -| 2022-10-14 16:07 | [#940 不同的子序列 II](https://leetcode.cn/problems/distinct-subsequences-ii) | HARD | 6 | 1 | -| 2022-10-13 20:08 | [#769 最多能完成排序的块](https://leetcode.cn/problems/max-chunks-to-make-sorted) | MEDIUM | 2 | 1 | -| 2022-10-12 10:03 | [#817 链表组件](https://leetcode.cn/problems/linked-list-components) | MEDIUM | 6 | 1 | -| 2022-10-11 10:02 | [#1790 仅执行一次字符串交换能否使两个字符串相等](https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal) | EASY | 3 | 1 | -| 2022-10-10 12:24 | [#856 括号的分数](https://leetcode.cn/problems/score-of-parentheses) | MEDIUM | 2 | 1 | -| 2022-10-08 10:54 | [#870 优势洗牌](https://leetcode.cn/problems/advantage-shuffle) | MEDIUM | 2 | 1 | -| 2022-10-07 12:41 | [#1694 重新格式化电话号码](https://leetcode.cn/problems/reformat-phone-number) | EASY | 2 | 1 | -| 2022-10-07 12:16 | [#1800 最大升序子数组和](https://leetcode.cn/problems/maximum-ascending-subarray-sum) | EASY | 3 | 1 | -| 2022-10-05 12:22 | [#811 子域名访问计数](https://leetcode.cn/problems/subdomain-visit-count) | MEDIUM | 1 | 1 | -| 2022-10-04 22:20 | [#921 使括号有效的最少添加](https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid) | MEDIUM | 4 | 1 | -| 2022-09-30 15:12 | [#73 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes) | MEDIUM | 1 | 1 | -| 2022-09-30 14:44 | [#面试题 01.08 零矩阵](https://leetcode.cn/problems/zero-matrix-lcci) | MEDIUM | 2 | 1 | -| 2022-09-29 23:57 | [#面试题 17.09 第 k 个数](https://leetcode.cn/problems/get-kth-magic-number-lcci) | MEDIUM | 3 | 1 | -| 2022-09-29 10:16 | [#面试题 01.09 字符串轮转](https://leetcode.cn/problems/string-rotation-lcci) | EASY | 1 | 1 | -| 2022-09-27 22:47 | [#面试题 01.02 判定是否互为字符重排](https://leetcode.cn/problems/check-permutation-lcci) | EASY | 1 | 1 | -| 2022-09-27 11:35 | [#面试题 17.19 消失的两个数字](https://leetcode.cn/problems/missing-two-lcci) | HARD | 3 | 1 | -| 2022-09-26 15:21 | [#788 旋转数字](https://leetcode.cn/problems/rotated-digits) | MEDIUM | 1 | 1 | -| 2022-09-22 09:45 | [#1640 能否连接形成数组](https://leetcode.cn/problems/check-array-formation-through-concatenation) | EASY | 3 | 1 | -| 2022-09-13 15:55 | [#1608 特殊数组的特征值](https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x) | EASY | 7 | 1 | -| 2022-09-13 15:06 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 7 | 1 | -| 2022-09-09 15:29 | [#1598 文件夹操作日志搜集器](https://leetcode.cn/problems/crawler-log-folder) | EASY | 3 | 1 | -| 2022-09-01 13:48 | [#1475 商品折扣后的最终价格](https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop) | EASY | 1 | 1 | -| 2022-08-31 13:22 | [#946 验证栈序列](https://leetcode.cn/problems/validate-stack-sequences) | MEDIUM | 2 | 1 | -| 2022-08-19 12:44 | [#1450 在既定时间做作业的学生人数](https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time) | EASY | 1 | 1 | -| 2022-08-17 12:14 | [#1302 层数最深叶子节点的和](https://leetcode.cn/problems/deepest-leaves-sum) | MEDIUM | 1 | 1 | -| 2022-08-10 18:34 | [#640 求解方程](https://leetcode.cn/problems/solve-the-equation) | MEDIUM | 4 | 1 | -| 2022-08-01 12:42 | [#1374 生成每种字符都是奇数个的字符串](https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts) | EASY | 1 | 1 | -| 2022-07-25 14:34 | [#919 完全二叉树插入器](https://leetcode.cn/problems/complete-binary-tree-inserter) | MEDIUM | 1 | 1 | -| 2022-07-23 14:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | -| 2022-07-17 11:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | -| 2022-07-14 13:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | -| 2022-07-13 19:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | -| 2022-07-11 13:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | -| 2022-07-08 14:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | -| 2022-07-08 13:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | -| 2022-07-07 15:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | -| 2022-07-05 14:13 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 3 | **2** | -| 2022-07-05 11:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | -| 2022-07-04 10:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | -| 2022-07-03 20:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | -| 2022-06-24 13:38 | [#515 在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row) | MEDIUM | 1 | 1 | -| 2022-06-22 14:33 | [#513 找树左下角的值](https://leetcode.cn/problems/find-bottom-left-tree-value) | MEDIUM | 4 | 1 | -| 2022-06-21 19:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | -| 2022-06-19 23:06 | [#98 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree) | MEDIUM | 13 | 1 | -| 2022-06-19 15:20 | [#508 出现次数最多的子树元素和](https://leetcode.cn/problems/most-frequent-subtree-sum) | MEDIUM | 2 | 1 | -| 2022-06-18 14:19 | [#LCR 029 循环有序列表的插入](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | -| 2022-06-17 15:48 | [#1089 复写零](https://leetcode.cn/problems/duplicate-zeros) | EASY | 2 | 1 | -| 2022-06-13 23:05 | [#1051 高度检查器](https://leetcode.cn/problems/height-checker) | EASY | 2 | 1 | -| 2022-06-12 23:05 | [#890 查找和替换模式](https://leetcode.cn/problems/find-and-replace-pattern) | MEDIUM | 1 | 1 | -| 2022-06-05 14:59 | [#478 在圆内随机生成点](https://leetcode.cn/problems/generate-random-point-in-a-circle) | MEDIUM | 8 | 1 | -| 2022-06-04 12:34 | [#929 独特的电子邮件地址](https://leetcode.cn/problems/unique-email-addresses) | EASY | 5 | 1 | -| 2022-05-30 20:32 | [#1022 从根到叶的二进制数之和](https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers) | EASY | 3 | 1 | -| 2022-05-28 12:21 | [#1021 删除最外层的括号](https://leetcode.cn/problems/remove-outermost-parentheses) | EASY | 1 | 1 | -| 2022-05-27 17:40 | [#面试题 17.11 单词距离](https://leetcode.cn/problems/find-closest-lcci) | MEDIUM | 2 | 1 | -| 2022-05-24 12:35 | [#965 单值二叉树](https://leetcode.cn/problems/univalued-binary-tree) | EASY | 2 | 1 | -| 2022-05-21 17:47 | [#961 在长度 2N 的数组中找出重复 N 次的元素](https://leetcode.cn/problems/n-repeated-element-in-size-2n-array) | EASY | 2 | 1 | -| 2022-05-20 14:55 | [#436 寻找右区间](https://leetcode.cn/problems/find-right-interval) | MEDIUM | 3 | 1 | -| 2022-05-19 13:50 | [#462 最小操作次数使数组元素相等 II](https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii) | MEDIUM | 1 | 1 | -| 2022-05-18 13:08 | [#668 乘法表中第k小的数](https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table) | HARD | 3 | 1 | -| 2022-05-17 11:08 | [#953 验证外星语词典](https://leetcode.cn/problems/verifying-an-alien-dictionary) | EASY | 2 | 1 | -| 2022-05-16 16:08 | [#面试题 04.06 后继者](https://leetcode.cn/problems/successor-lcci) | MEDIUM | 5 | 1 | -| 2022-05-15 14:35 | [#812 最大三角形面积](https://leetcode.cn/problems/largest-triangle-area) | EASY | 4 | 1 | -| 2022-05-13 22:09 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 3 | 1 | -| 2022-05-13 13:28 | [#面试题 01.05 一次编辑](https://leetcode.cn/problems/one-away-lcci) | MEDIUM | 3 | 1 | -| 2022-05-12 21:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | -| 2022-05-10 15:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | -| 2022-05-09 14:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | -| 2022-05-09 14:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | -| 2022-05-09 14:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | -| 2022-05-09 13:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | -| 2022-05-08 10:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | -| 2022-05-07 20:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | -| 2022-05-07 16:37 | [#433 最小基因变化](https://leetcode.cn/problems/minimum-genetic-mutation) | MEDIUM | 3 | 1 | -| 2022-05-06 15:00 | [#113 路径总和 II](https://leetcode.cn/problems/path-sum-ii) | MEDIUM | 1 | 1 | -| 2022-05-06 14:46 | [#933 最近的请求次数](https://leetcode.cn/problems/number-of-recent-calls) | EASY | 1 | 1 | -| 2022-05-05 11:07 | [#713 乘积小于 K 的子数组](https://leetcode.cn/problems/subarray-product-less-than-k) | MEDIUM | 3 | 1 | -| 2022-05-04 12:31 | [#1823 找出游戏的获胜者](https://leetcode.cn/problems/find-the-winner-of-the-circular-game) | MEDIUM | 2 | 1 | -| 2022-05-03 12:37 | [#937 重新排列日志文件](https://leetcode.cn/problems/reorder-data-in-log-files) | MEDIUM | 2 | 1 | -| 2022-05-02 15:00 | [#591 标签验证器](https://leetcode.cn/problems/tag-validator) | HARD | 8 | 1 | -| 2022-05-02 14:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | -| 2022-05-01 17:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | -| 2022-04-30 14:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | -| 2022-04-29 15:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | -| 2022-04-28 12:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | -| 2022-04-26 19:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | -| 2022-04-25 12:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | -| 2022-04-24 13:08 | [#868 二进制间距](https://leetcode.cn/problems/binary-gap) | EASY | 1 | 1 | -| 2022-04-22 15:01 | [#396 旋转函数](https://leetcode.cn/problems/rotate-function) | MEDIUM | 2 | 1 | -| 2022-04-21 13:01 | [#824 山羊拉丁文](https://leetcode.cn/problems/goat-latin) | EASY | 1 | 1 | -| 2022-04-20 14:44 | [#388 文件的最长绝对路径](https://leetcode.cn/problems/longest-absolute-file-path) | MEDIUM | 2 | 1 | -| 2022-04-19 12:26 | [#821 字符的最短距离](https://leetcode.cn/problems/shortest-distance-to-a-character) | EASY | 1 | 1 | -| 2022-04-18 15:36 | [#386 字典序排数](https://leetcode.cn/problems/lexicographical-numbers) | MEDIUM | 2 | 1 | -| 2022-04-17 13:28 | [#819 最常见的单词](https://leetcode.cn/problems/most-common-word) | EASY | 3 | 1 | -| 2022-04-16 12:46 | [#479 最大回文数乘积](https://leetcode.cn/problems/largest-palindrome-product) | HARD | 2 | 1 | -| 2022-04-15 15:05 | [#385 迷你语法分析器](https://leetcode.cn/problems/mini-parser) | MEDIUM | 4 | 1 | -| 2022-04-14 10:21 | [#1672 最富有客户的资产总量](https://leetcode.cn/problems/richest-customer-wealth) | EASY | 1 | 1 | -| 2022-04-13 18:53 | [#380 O(1) 时间插入、删除和获取随机元素](https://leetcode.cn/problems/insert-delete-getrandom-o1) | MEDIUM | 5 | 1 | -| 2022-04-12 10:06 | [#806 写字符串需要的行数](https://leetcode.cn/problems/number-of-lines-to-write-string) | EASY | 1 | 1 | -| 2022-04-11 15:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | -| 2022-04-10 12:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | -| 2022-04-09 18:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | -| 2022-04-08 11:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | -| 2022-04-06 14:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | -| 2022-04-05 15:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | -| 2022-04-03 20:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | -| 2022-04-02 18:50 | [#132 分割回文串 II](https://leetcode.cn/problems/palindrome-partitioning-ii) | HARD | 4 | 1 | -| 2022-04-01 11:41 | [#954 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs) | MEDIUM | 10 | 1 | -| 2022-03-31 12:57 | [#728 自除数](https://leetcode.cn/problems/self-dividing-numbers) | EASY | 1 | 1 | -| 2022-03-30 17:45 | [#1606 找到处理最多请求的服务器](https://leetcode.cn/problems/find-servers-that-handled-most-number-of-requests) | HARD | 6 | 1 | -| 2022-03-29 13:49 | [#2024 考试的最大困扰度](https://leetcode.cn/problems/maximize-the-confusion-of-an-exam) | MEDIUM | 1 | 1 | -| 2022-03-28 14:22 | [#693 交替位二进制数](https://leetcode.cn/problems/binary-number-with-alternating-bits) | EASY | 1 | 1 | -| 2022-03-27 12:46 | [#2028 找出缺失的观测数据](https://leetcode.cn/problems/find-missing-observations) | MEDIUM | 7 | 1 | -| 2022-03-26 15:02 | [#682 棒球比赛](https://leetcode.cn/problems/baseball-game) | EASY | 1 | 1 | -| 2022-03-25 13:23 | [#172 阶乘后的零](https://leetcode.cn/problems/factorial-trailing-zeroes) | MEDIUM | 4 | 1 | -| 2022-03-24 10:20 | [#661 图片平滑器](https://leetcode.cn/problems/image-smoother) | EASY | 1 | 1 | -| 2022-03-23 18:40 | [#440 字典序的第K小数字](https://leetcode.cn/problems/k-th-smallest-in-lexicographical-order) | HARD | 6 | 1 | -| 2022-03-22 12:43 | [#2038 如果相邻两个颜色均相同则删除当前颜色](https://leetcode.cn/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color) | MEDIUM | 3 | 1 | -| 2022-03-21 15:27 | [#653 两数之和 IV - 输入二叉搜索树](https://leetcode.cn/problems/two-sum-iv-input-is-a-bst) | EASY | 1 | 1 | -| 2022-03-20 15:10 | [#2039 网络空闲的时刻](https://leetcode.cn/problems/the-time-when-the-network-becomes-idle) | MEDIUM | 1 | 1 | -| 2022-03-19 15:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | EASY | 3 | 1 | -| 2022-03-18 12:11 | [#2043 简易银行系统](https://leetcode.cn/problems/simple-bank-system) | MEDIUM | 1 | 1 | -| 2022-03-17 14:57 | [#720 词典中最长的单词](https://leetcode.cn/problems/longest-word-in-dictionary) | MEDIUM | 8 | 1 | -| 2022-03-16 19:29 | [#432 全 O(1) 的数据结构](https://leetcode.cn/problems/all-oone-data-structure) | HARD | 4 | 1 | -| 2022-03-15 15:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | -| 2022-03-14 11:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | -| 2022-03-13 16:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | -| 2022-03-12 13:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | -| 2021-09-14 15:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | -| 2021-08-03 13:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | -| 2021-07-30 19:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | -| 2021-07-13 09:53 | [#40 组合总和 II](https://leetcode.cn/problems/combination-sum-ii) | MEDIUM | 3 | 1 | -| 2021-07-13 09:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | -| 2021-07-12 19:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | -| 2021-07-12 18:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | -| 2021-07-06 16:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | -| 2021-07-06 16:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | -| 2021-07-05 15:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | -| 2021-07-05 14:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | -| 2021-07-05 13:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | -| 2021-07-05 13:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | -| 2021-07-05 12:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | -| 2021-07-05 12:30 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 1 | 1 | -| 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | -| 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | -| 2021-06-13 15:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | -| 2021-06-07 19:49 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 1 | 1 | -| 2021-06-04 09:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | -| 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | -| 2021-05-24 11:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | -| 2021-05-22 00:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | -| 2021-05-21 14:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | -| 2021-05-10 15:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | -| 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | -| 2021-05-05 10:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | -| 2021-04-13 18:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | -| 2021-03-30 13:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | -| 2021-03-27 22:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | -| 2021-03-22 18:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | -| 2020-11-27 20:12 | [#454 四数相加 II](https://leetcode.cn/problems/4sum-ii) | MEDIUM | 5 | 1 | -| 2020-11-25 22:35 | [#1370 上升下降字符串](https://leetcode.cn/problems/increasing-decreasing-string) | EASY | 1 | 1 | -| 2020-10-25 19:58 | [#845 数组中的最长山脉](https://leetcode.cn/problems/longest-mountain-in-array) | MEDIUM | 1 | 1 | -| 2020-10-15 20:52 | [#9 回文数](https://leetcode.cn/problems/palindrome-number) | EASY | 1 | 1 | -| 2020-09-04 13:05 | [#257 二叉树的所有路径](https://leetcode.cn/problems/binary-tree-paths) | EASY | 1 | 1 | -| 2020-08-16 15:28 | [#733 图像渲染](https://leetcode.cn/problems/flood-fill) | EASY | 2 | 1 | -| 2020-08-14 23:14 | [#20 有效的括号](https://leetcode.cn/problems/valid-parentheses) | EASY | 6 | 1 | -| 2020-08-10 14:09 | [#696 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings) | EASY | 4 | 1 | -| 2020-08-08 09:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | -| 2020-08-06 16:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | -| 2020-08-03 20:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | -| 2020-08-02 19:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | -| 2020-07-31 13:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | -| 2020-07-31 13:05 | [#面试题 08.03 魔术索引](https://leetcode.cn/problems/magic-index-lcci) | EASY | 2 | 1 | -| 2020-07-29 10:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | -| 2020-07-28 18:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | -| 2020-07-27 10:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | -| 2020-07-23 15:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | -| 2020-07-23 14:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | -| 2020-07-23 14:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | -| 2020-07-22 21:24 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 4 | 1 | -| 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | -| 2020-07-18 23:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | -| 2020-07-17 16:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | -| 2020-04-22 22:11 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 3 | 1 | +| 2023-09-19 13:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | +| 2023-09-18 11:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | +| 2023-09-17 14:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | +| 2023-09-17 14:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | +| 2023-09-14 12:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | +| 2023-09-13 12:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | +| 2023-09-12 12:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | +| 2023-09-11 12:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | +| 2023-09-10 04:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | +| 2023-09-10 02:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | +| 2023-09-01 09:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | +| 2023-09-01 01:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | +| 2023-08-28 11:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | +| 2023-08-25 01:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | +| 2023-08-13 05:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | +| 2023-08-10 12:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | +| 2023-07-16 04:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | +| 2023-07-13 15:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | +| 2023-07-12 11:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | +| 2023-07-10 14:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | +| 2023-07-05 16:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | +| 2023-07-03 15:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | +| 2023-06-27 13:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | +| 2023-06-25 05:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | +| 2023-06-23 05:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | +| 2023-06-11 11:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | +| 2023-06-08 13:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | +| 2023-06-07 12:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | +| 2023-06-02 05:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | +| 2023-06-01 08:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | +| 2023-05-31 13:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | +| 2023-05-29 14:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | +| 2023-05-25 08:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | +| 2023-05-21 06:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | +| 2023-05-14 10:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | +| 2023-05-12 14:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | +| 2023-05-11 09:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | +| 2023-05-11 02:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | +| 2023-05-07 04:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | +| 2023-05-06 14:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | +| 2023-05-05 05:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | +| 2023-05-04 08:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | +| 2023-05-03 14:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | +| 2023-05-02 03:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | +| 2023-05-01 04:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | +| 2023-04-30 11:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | +| 2023-04-30 06:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | +| 2023-04-14 12:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | +| 2023-04-09 03:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | +| 2023-04-03 14:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | +| 2023-03-30 12:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | +| 2023-03-29 15:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | +| 2023-03-22 12:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | +| 2023-03-22 11:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | +| 2023-03-21 11:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | +| 2023-03-18 03:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | +| 2023-03-17 13:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | +| 2023-03-15 03:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | +| 2023-03-14 11:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | +| 2023-03-13 07:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | +| 2023-03-08 13:52 | [#LCR 166 珠宝的最高价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | +| 2023-03-06 13:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | +| 2023-03-03 11:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | +| 2023-02-28 13:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | +| 2023-02-27 09:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | +| 2023-02-20 02:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | +| 2023-02-12 01:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | +| 2023-02-09 09:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | +| 2023-02-08 06:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | +| 2023-01-30 11:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | +| 2023-01-29 08:50 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 2 | 1 | +| 2023-01-28 06:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | +| 2023-01-27 12:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | +| 2023-01-27 11:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | +| 2023-01-26 10:25 | [#1663 具有给定数值的最小字符串](https://leetcode.cn/problems/smallest-string-with-a-given-numeric-value) | MEDIUM | 2 | 1 | +| 2023-01-23 14:32 | [#199 二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view) | MEDIUM | 2 | 1 | +| 2023-01-16 14:39 | [#1813 句子相似性 III](https://leetcode.cn/problems/sentence-similarity-iii) | MEDIUM | 3 | 1 | +| 2023-01-13 12:15 | [#38 外观数列](https://leetcode.cn/problems/count-and-say) | MEDIUM | 1 | 1 | +| 2023-01-13 06:19 | [#36 有效的数独](https://leetcode.cn/problems/valid-sudoku) | MEDIUM | 1 | 1 | +| 2023-01-09 08:15 | [#1806 还原排列的最少操作步数](https://leetcode.cn/problems/minimum-number-of-operations-to-reinitialize-a-permutation) | MEDIUM | 1 | 1 | +| 2023-01-07 14:33 | [#1658 将 x 减到 0 的最小操作数](https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero) | MEDIUM | 1 | 1 | +| 2023-01-05 12:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | +| 2023-01-05 11:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | +| 2023-01-03 07:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | +| 2023-01-01 11:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | +| 2022-12-31 02:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | +| 2022-12-19 06:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | +| 2022-12-18 13:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | +| 2022-12-17 10:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | +| 2022-12-16 04:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | +| 2022-12-15 12:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | +| 2022-12-15 12:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | +| 2022-12-15 12:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | +| 2022-12-15 03:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | +| 2022-12-13 04:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | +| 2022-12-13 03:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | +| 2022-12-12 08:15 | [#1781 所有子字符串美丽值之和](https://leetcode.cn/problems/sum-of-beauty-of-all-substrings) | MEDIUM | 1 | 1 | +| 2022-12-11 08:13 | [#1827 最少操作使数组递增](https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing) | EASY | 1 | 1 | +| 2022-12-10 10:47 | [#1691 堆叠长方体的最大高度](https://leetcode.cn/problems/maximum-height-by-stacking-cuboids) | HARD | 12 | 1 | +| 2022-12-08 01:57 | [#1812 判断国际象棋棋盘中一个格子的颜色](https://leetcode.cn/problems/determine-color-of-a-chessboard-square) | EASY | 2 | 1 | +| 2022-12-07 14:24 | [#1775 通过最少操作次数使数组的和相等](https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations) | MEDIUM | 7 | 1 | +| 2022-12-06 10:03 | [#852 山脉数组的峰顶索引](https://leetcode.cn/problems/peak-index-in-a-mountain-array) | MEDIUM | 2 | **2** | +| 2022-12-06 09:43 | [#1805 字符串中不同整数的数目](https://leetcode.cn/problems/number-of-different-integers-in-a-string) | EASY | 5 | 1 | +| 2022-12-05 06:01 | [#8 字符串转换整数 (atoi)](https://leetcode.cn/problems/string-to-integer-atoi) | MEDIUM | 17 | 1 | +| 2022-12-03 02:38 | [#1796 字符串中第二大的数字](https://leetcode.cn/problems/second-largest-digit-in-a-string) | EASY | 4 | 1 | +| 2022-12-02 02:12 | [#1769 移动所有球到每个盒子所需的最小操作数](https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box) | MEDIUM | 1 | 1 | +| 2022-12-01 02:32 | [#1779 找到最近的有相同 X 或 Y 坐标的点](https://leetcode.cn/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate) | EASY | 1 | 1 | +| 2022-11-30 07:35 | [#895 最大频率栈](https://leetcode.cn/problems/maximum-frequency-stack) | HARD | 2 | 1 | +| 2022-11-29 10:06 | [#1758 生成交替二进制字符串的最少操作数](https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string) | EASY | 1 | 1 | +| 2022-11-28 08:31 | [#813 最大平均值和的分组](https://leetcode.cn/problems/largest-sum-of-averages) | MEDIUM | 3 | 1 | +| 2022-11-27 12:12 | [#1752 检查数组是否经排序和轮转得到](https://leetcode.cn/problems/check-if-array-is-sorted-and-rotated) | EASY | 2 | 1 | +| 2022-11-26 11:10 | [#743 网络延迟时间](https://leetcode.cn/problems/network-delay-time) | MEDIUM | 9 | **5** | +| 2022-11-26 10:56 | [#787 K 站中转内最便宜的航班](https://leetcode.cn/problems/cheapest-flights-within-k-stops) | MEDIUM | 6 | **2** | +| 2022-11-26 08:01 | [#882 细分图中的可到达节点](https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph) | HARD | 2 | 1 | +| 2022-11-26 05:52 | [#809 情感丰富的文字](https://leetcode.cn/problems/expressive-words) | MEDIUM | 2 | 1 | +| 2022-11-24 08:25 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 6 | **2** | +| 2022-11-24 07:52 | [#1668 最大重复子字符串](https://leetcode.cn/problems/maximum-repeating-substring) | EASY | 4 | **2** | +| 2022-11-24 07:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | +| 2022-11-23 13:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | +| 2022-11-23 09:30 | [#1742 盒子中小球的最大数量](https://leetcode.cn/problems/maximum-number-of-balls-in-a-box) | EASY | 1 | 1 | +| 2022-11-21 12:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | +| 2022-11-21 11:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | +| 2022-11-21 10:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | +| 2022-11-21 08:43 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 5 | **2** | +| 2022-11-21 06:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | +| 2022-11-21 03:04 | [#799 香槟塔](https://leetcode.cn/problems/champagne-tower) | MEDIUM | 2 | 1 | +| 2022-11-19 12:48 | [#139 单词拆分](https://leetcode.cn/problems/word-break) | MEDIUM | 3 | 1 | +| 2022-11-19 08:56 | [#208 实现 Trie (前缀树)](https://leetcode.cn/problems/implement-trie-prefix-tree) | MEDIUM | 2 | 1 | +| 2022-11-19 02:02 | [#1732 找到最高海拔](https://leetcode.cn/problems/find-the-highest-altitude) | EASY | 1 | 1 | +| 2022-11-17 16:48 | [#792 匹配子序列的单词数](https://leetcode.cn/problems/number-of-matching-subsequences) | MEDIUM | 2 | 1 | +| 2022-11-16 05:19 | [#775 全局倒置与局部倒置](https://leetcode.cn/problems/global-and-local-inversions) | MEDIUM | 9 | 1 | +| 2022-11-15 12:30 | [#1926 迷宫中离入口最近的出口](https://leetcode.cn/problems/nearest-exit-from-entrance-in-maze) | MEDIUM | 4 | 1 | +| 2022-11-15 11:11 | [#1710 卡车上的最大单元数](https://leetcode.cn/problems/maximum-units-on-a-truck) | EASY | 2 | 1 | +| 2022-11-13 16:19 | [#704 二分查找](https://leetcode.cn/problems/binary-search) | EASY | 10 | 1 | +| 2022-11-13 09:37 | [#916 单词子集](https://leetcode.cn/problems/word-subsets) | MEDIUM | 4 | 1 | +| 2022-11-13 07:18 | [#剑指 Offer 51 数组中的逆序对](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | +| 2022-11-13 05:33 | [#791 自定义字符串排序](https://leetcode.cn/problems/custom-sort-string) | MEDIUM | 2 | 1 | +| 2022-11-12 12:54 | [#1339 分裂二叉树的最大乘积](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree) | MEDIUM | 3 | 1 | +| 2022-11-12 06:18 | [#790 多米诺和托米诺平铺](https://leetcode.cn/problems/domino-and-tromino-tiling) | MEDIUM | 4 | 1 | +| 2022-11-11 05:02 | [#129 求根节点到叶节点数字之和](https://leetcode.cn/problems/sum-root-to-leaf-numbers) | MEDIUM | 3 | 1 | +| 2022-11-11 02:03 | [#1704 判断字符串的两半是否相似](https://leetcode.cn/problems/determine-if-string-halves-are-alike) | EASY | 1 | 1 | +| 2022-11-08 00:26 | [#1684 统计一致字符串的数目](https://leetcode.cn/problems/count-the-number-of-consistent-strings) | EASY | 1 | 1 | +| 2022-11-07 07:37 | [#816 模糊坐标](https://leetcode.cn/problems/ambiguous-coordinates) | MEDIUM | 2 | 1 | +| 2022-11-06 03:38 | [#1678 设计 Goal 解析器](https://leetcode.cn/problems/goal-parser-interpretation) | EASY | 1 | 1 | +| 2022-11-05 10:31 | [#1106 解析布尔表达式](https://leetcode.cn/problems/parsing-a-boolean-expression) | HARD | 3 | 1 | +| 2022-11-04 06:12 | [#754 到达终点数字](https://leetcode.cn/problems/reach-a-number) | MEDIUM | 4 | 1 | +| 2022-11-02 12:43 | [#1620 网络信号最好的坐标](https://leetcode.cn/problems/coordinate-with-maximum-network-quality) | MEDIUM | 1 | 1 | +| 2022-11-01 06:49 | [#1662 检查两个字符串数组是否相等](https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent) | EASY | 1 | 1 | +| 2022-10-31 02:25 | [#481 神奇字符串](https://leetcode.cn/problems/magical-string) | MEDIUM | 4 | 1 | +| 2022-10-29 15:17 | [#1773 统计匹配检索规则的物品数量](https://leetcode.cn/problems/count-items-matching-a-rule) | EASY | 2 | 1 | +| 2022-10-27 02:20 | [#1822 数组元素积的符号](https://leetcode.cn/problems/sign-of-the-product-of-an-array) | EASY | 2 | 1 | +| 2022-10-24 07:37 | [#1235 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling) | HARD | 7 | **2** | +| 2022-10-24 00:13 | [#915 分割数组](https://leetcode.cn/problems/partition-array-into-disjoint-intervals) | MEDIUM | 3 | 1 | +| 2022-10-23 10:07 | [#1768 交替合并字符串](https://leetcode.cn/problems/merge-strings-alternately) | EASY | 2 | 1 | +| 2022-10-21 02:50 | [#901 股票价格跨度](https://leetcode.cn/problems/online-stock-span) | MEDIUM | 1 | 1 | +| 2022-10-20 13:51 | [#779 第K个语法符号](https://leetcode.cn/problems/k-th-symbol-in-grammar) | MEDIUM | 1 | 1 | +| 2022-10-19 08:47 | [#1700 无法吃午餐的学生数量](https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch) | EASY | 2 | 1 | +| 2022-10-17 04:25 | [#904 水果成篮](https://leetcode.cn/problems/fruit-into-baskets) | MEDIUM | 3 | 1 | +| 2022-10-16 05:16 | [#886 可能的二分法](https://leetcode.cn/problems/possible-bipartition) | MEDIUM | 4 | 1 | +| 2022-10-15 06:16 | [#7 整数反转](https://leetcode.cn/problems/reverse-integer) | MEDIUM | 4 | 1 | +| 2022-10-15 02:09 | [#1441 用栈操作构建数组](https://leetcode.cn/problems/build-an-array-with-stack-operations) | MEDIUM | 4 | 1 | +| 2022-10-14 08:07 | [#940 不同的子序列 II](https://leetcode.cn/problems/distinct-subsequences-ii) | HARD | 6 | 1 | +| 2022-10-13 12:08 | [#769 最多能完成排序的块](https://leetcode.cn/problems/max-chunks-to-make-sorted) | MEDIUM | 2 | 1 | +| 2022-10-12 02:03 | [#817 链表组件](https://leetcode.cn/problems/linked-list-components) | MEDIUM | 6 | 1 | +| 2022-10-11 02:02 | [#1790 仅执行一次字符串交换能否使两个字符串相等](https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal) | EASY | 3 | 1 | +| 2022-10-10 04:24 | [#856 括号的分数](https://leetcode.cn/problems/score-of-parentheses) | MEDIUM | 2 | 1 | +| 2022-10-08 02:54 | [#870 优势洗牌](https://leetcode.cn/problems/advantage-shuffle) | MEDIUM | 2 | 1 | +| 2022-10-07 04:41 | [#1694 重新格式化电话号码](https://leetcode.cn/problems/reformat-phone-number) | EASY | 2 | 1 | +| 2022-10-07 04:16 | [#1800 最大升序子数组和](https://leetcode.cn/problems/maximum-ascending-subarray-sum) | EASY | 3 | 1 | +| 2022-10-05 04:22 | [#811 子域名访问计数](https://leetcode.cn/problems/subdomain-visit-count) | MEDIUM | 1 | 1 | +| 2022-10-04 14:20 | [#921 使括号有效的最少添加](https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid) | MEDIUM | 4 | 1 | +| 2022-09-30 07:12 | [#73 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes) | MEDIUM | 1 | 1 | +| 2022-09-30 06:44 | [#面试题 01.08 零矩阵](https://leetcode.cn/problems/zero-matrix-lcci) | MEDIUM | 2 | 1 | +| 2022-09-29 15:57 | [#面试题 17.09 第 k 个数](https://leetcode.cn/problems/get-kth-magic-number-lcci) | MEDIUM | 3 | 1 | +| 2022-09-29 02:16 | [#面试题 01.09 字符串轮转](https://leetcode.cn/problems/string-rotation-lcci) | EASY | 1 | 1 | +| 2022-09-27 14:47 | [#面试题 01.02 判定是否互为字符重排](https://leetcode.cn/problems/check-permutation-lcci) | EASY | 1 | 1 | +| 2022-09-27 03:35 | [#面试题 17.19 消失的两个数字](https://leetcode.cn/problems/missing-two-lcci) | HARD | 3 | 1 | +| 2022-09-26 07:21 | [#788 旋转数字](https://leetcode.cn/problems/rotated-digits) | MEDIUM | 1 | 1 | +| 2022-09-22 01:45 | [#1640 能否连接形成数组](https://leetcode.cn/problems/check-array-formation-through-concatenation) | EASY | 3 | 1 | +| 2022-09-13 07:55 | [#1608 特殊数组的特征值](https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x) | EASY | 7 | 1 | +| 2022-09-13 07:06 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 7 | 1 | +| 2022-09-09 07:29 | [#1598 文件夹操作日志搜集器](https://leetcode.cn/problems/crawler-log-folder) | EASY | 3 | 1 | +| 2022-09-01 05:48 | [#1475 商品折扣后的最终价格](https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop) | EASY | 1 | 1 | +| 2022-08-31 05:22 | [#946 验证栈序列](https://leetcode.cn/problems/validate-stack-sequences) | MEDIUM | 2 | 1 | +| 2022-08-19 04:44 | [#1450 在既定时间做作业的学生人数](https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time) | EASY | 1 | 1 | +| 2022-08-17 04:14 | [#1302 层数最深叶子节点的和](https://leetcode.cn/problems/deepest-leaves-sum) | MEDIUM | 1 | 1 | +| 2022-08-10 10:34 | [#640 求解方程](https://leetcode.cn/problems/solve-the-equation) | MEDIUM | 4 | 1 | +| 2022-08-01 04:42 | [#1374 生成每种字符都是奇数个的字符串](https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts) | EASY | 1 | 1 | +| 2022-07-25 06:34 | [#919 完全二叉树插入器](https://leetcode.cn/problems/complete-binary-tree-inserter) | MEDIUM | 1 | 1 | +| 2022-07-23 06:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | +| 2022-07-17 03:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | +| 2022-07-14 05:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | +| 2022-07-13 11:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | +| 2022-07-11 05:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | +| 2022-07-08 06:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | +| 2022-07-08 05:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | +| 2022-07-07 07:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | +| 2022-07-05 06:13 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 3 | **2** | +| 2022-07-05 03:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | +| 2022-07-04 02:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | +| 2022-07-03 12:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | +| 2022-06-24 05:38 | [#515 在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row) | MEDIUM | 1 | 1 | +| 2022-06-22 06:33 | [#513 找树左下角的值](https://leetcode.cn/problems/find-bottom-left-tree-value) | MEDIUM | 4 | 1 | +| 2022-06-21 11:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | +| 2022-06-19 15:06 | [#98 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree) | MEDIUM | 13 | 1 | +| 2022-06-19 07:20 | [#508 出现次数最多的子树元素和](https://leetcode.cn/problems/most-frequent-subtree-sum) | MEDIUM | 2 | 1 | +| 2022-06-18 06:19 | [#LCR 029 循环有序列表的插入](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | +| 2022-06-17 07:48 | [#1089 复写零](https://leetcode.cn/problems/duplicate-zeros) | EASY | 2 | 1 | +| 2022-06-13 15:05 | [#1051 高度检查器](https://leetcode.cn/problems/height-checker) | EASY | 2 | 1 | +| 2022-06-12 15:05 | [#890 查找和替换模式](https://leetcode.cn/problems/find-and-replace-pattern) | MEDIUM | 1 | 1 | +| 2022-06-05 06:59 | [#478 在圆内随机生成点](https://leetcode.cn/problems/generate-random-point-in-a-circle) | MEDIUM | 8 | 1 | +| 2022-06-04 04:34 | [#929 独特的电子邮件地址](https://leetcode.cn/problems/unique-email-addresses) | EASY | 5 | 1 | +| 2022-05-30 12:32 | [#1022 从根到叶的二进制数之和](https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers) | EASY | 3 | 1 | +| 2022-05-28 04:21 | [#1021 删除最外层的括号](https://leetcode.cn/problems/remove-outermost-parentheses) | EASY | 1 | 1 | +| 2022-05-27 09:40 | [#面试题 17.11 单词距离](https://leetcode.cn/problems/find-closest-lcci) | MEDIUM | 2 | 1 | +| 2022-05-24 04:35 | [#965 单值二叉树](https://leetcode.cn/problems/univalued-binary-tree) | EASY | 2 | 1 | +| 2022-05-21 09:47 | [#961 在长度 2N 的数组中找出重复 N 次的元素](https://leetcode.cn/problems/n-repeated-element-in-size-2n-array) | EASY | 2 | 1 | +| 2022-05-20 06:55 | [#436 寻找右区间](https://leetcode.cn/problems/find-right-interval) | MEDIUM | 3 | 1 | +| 2022-05-19 05:50 | [#462 最小操作次数使数组元素相等 II](https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii) | MEDIUM | 1 | 1 | +| 2022-05-18 05:08 | [#668 乘法表中第k小的数](https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table) | HARD | 3 | 1 | +| 2022-05-17 03:08 | [#953 验证外星语词典](https://leetcode.cn/problems/verifying-an-alien-dictionary) | EASY | 2 | 1 | +| 2022-05-16 08:08 | [#面试题 04.06 后继者](https://leetcode.cn/problems/successor-lcci) | MEDIUM | 5 | 1 | +| 2022-05-15 06:35 | [#812 最大三角形面积](https://leetcode.cn/problems/largest-triangle-area) | EASY | 4 | 1 | +| 2022-05-13 14:09 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 3 | 1 | +| 2022-05-13 05:28 | [#面试题 01.05 一次编辑](https://leetcode.cn/problems/one-away-lcci) | MEDIUM | 3 | 1 | +| 2022-05-12 13:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | +| 2022-05-10 07:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | +| 2022-05-09 06:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | +| 2022-05-09 06:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | +| 2022-05-09 06:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | +| 2022-05-09 05:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | +| 2022-05-08 02:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | +| 2022-05-07 12:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | +| 2022-05-07 08:37 | [#433 最小基因变化](https://leetcode.cn/problems/minimum-genetic-mutation) | MEDIUM | 3 | 1 | +| 2022-05-06 07:00 | [#113 路径总和 II](https://leetcode.cn/problems/path-sum-ii) | MEDIUM | 1 | 1 | +| 2022-05-06 06:46 | [#933 最近的请求次数](https://leetcode.cn/problems/number-of-recent-calls) | EASY | 1 | 1 | +| 2022-05-05 03:07 | [#713 乘积小于 K 的子数组](https://leetcode.cn/problems/subarray-product-less-than-k) | MEDIUM | 3 | 1 | +| 2022-05-04 04:31 | [#1823 找出游戏的获胜者](https://leetcode.cn/problems/find-the-winner-of-the-circular-game) | MEDIUM | 2 | 1 | +| 2022-05-03 04:37 | [#937 重新排列日志文件](https://leetcode.cn/problems/reorder-data-in-log-files) | MEDIUM | 2 | 1 | +| 2022-05-02 07:00 | [#591 标签验证器](https://leetcode.cn/problems/tag-validator) | HARD | 8 | 1 | +| 2022-05-02 06:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | +| 2022-05-01 09:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | +| 2022-04-30 06:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | +| 2022-04-29 07:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | +| 2022-04-28 04:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | +| 2022-04-26 11:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | +| 2022-04-25 04:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | +| 2022-04-24 05:08 | [#868 二进制间距](https://leetcode.cn/problems/binary-gap) | EASY | 1 | 1 | +| 2022-04-22 07:01 | [#396 旋转函数](https://leetcode.cn/problems/rotate-function) | MEDIUM | 2 | 1 | +| 2022-04-21 05:01 | [#824 山羊拉丁文](https://leetcode.cn/problems/goat-latin) | EASY | 1 | 1 | +| 2022-04-20 06:44 | [#388 文件的最长绝对路径](https://leetcode.cn/problems/longest-absolute-file-path) | MEDIUM | 2 | 1 | +| 2022-04-19 04:26 | [#821 字符的最短距离](https://leetcode.cn/problems/shortest-distance-to-a-character) | EASY | 1 | 1 | +| 2022-04-18 07:36 | [#386 字典序排数](https://leetcode.cn/problems/lexicographical-numbers) | MEDIUM | 2 | 1 | +| 2022-04-17 05:28 | [#819 最常见的单词](https://leetcode.cn/problems/most-common-word) | EASY | 3 | 1 | +| 2022-04-16 04:46 | [#479 最大回文数乘积](https://leetcode.cn/problems/largest-palindrome-product) | HARD | 2 | 1 | +| 2022-04-15 07:05 | [#385 迷你语法分析器](https://leetcode.cn/problems/mini-parser) | MEDIUM | 4 | 1 | +| 2022-04-14 02:21 | [#1672 最富有客户的资产总量](https://leetcode.cn/problems/richest-customer-wealth) | EASY | 1 | 1 | +| 2022-04-13 10:53 | [#380 O(1) 时间插入、删除和获取随机元素](https://leetcode.cn/problems/insert-delete-getrandom-o1) | MEDIUM | 5 | 1 | +| 2022-04-12 02:06 | [#806 写字符串需要的行数](https://leetcode.cn/problems/number-of-lines-to-write-string) | EASY | 1 | 1 | +| 2022-04-11 07:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | +| 2022-04-10 04:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | +| 2022-04-09 10:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | +| 2022-04-08 03:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | +| 2022-04-06 06:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | +| 2022-04-05 07:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | +| 2022-04-03 12:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | +| 2022-04-02 10:50 | [#132 分割回文串 II](https://leetcode.cn/problems/palindrome-partitioning-ii) | HARD | 4 | 1 | +| 2022-04-01 03:41 | [#954 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs) | MEDIUM | 10 | 1 | +| 2022-03-31 04:57 | [#728 自除数](https://leetcode.cn/problems/self-dividing-numbers) | EASY | 1 | 1 | +| 2022-03-30 09:45 | [#1606 找到处理最多请求的服务器](https://leetcode.cn/problems/find-servers-that-handled-most-number-of-requests) | HARD | 6 | 1 | +| 2022-03-29 05:49 | [#2024 考试的最大困扰度](https://leetcode.cn/problems/maximize-the-confusion-of-an-exam) | MEDIUM | 1 | 1 | +| 2022-03-28 06:22 | [#693 交替位二进制数](https://leetcode.cn/problems/binary-number-with-alternating-bits) | EASY | 1 | 1 | +| 2022-03-27 04:46 | [#2028 找出缺失的观测数据](https://leetcode.cn/problems/find-missing-observations) | MEDIUM | 7 | 1 | +| 2022-03-26 07:02 | [#682 棒球比赛](https://leetcode.cn/problems/baseball-game) | EASY | 1 | 1 | +| 2022-03-25 05:23 | [#172 阶乘后的零](https://leetcode.cn/problems/factorial-trailing-zeroes) | MEDIUM | 4 | 1 | +| 2022-03-24 02:20 | [#661 图片平滑器](https://leetcode.cn/problems/image-smoother) | EASY | 1 | 1 | +| 2022-03-23 10:40 | [#440 字典序的第K小数字](https://leetcode.cn/problems/k-th-smallest-in-lexicographical-order) | HARD | 6 | 1 | +| 2022-03-22 04:43 | [#2038 如果相邻两个颜色均相同则删除当前颜色](https://leetcode.cn/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color) | MEDIUM | 3 | 1 | +| 2022-03-21 07:27 | [#653 两数之和 IV - 输入二叉搜索树](https://leetcode.cn/problems/two-sum-iv-input-is-a-bst) | EASY | 1 | 1 | +| 2022-03-20 07:10 | [#2039 网络空闲的时刻](https://leetcode.cn/problems/the-time-when-the-network-becomes-idle) | MEDIUM | 1 | 1 | +| 2022-03-19 07:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | EASY | 3 | 1 | +| 2022-03-18 04:11 | [#2043 简易银行系统](https://leetcode.cn/problems/simple-bank-system) | MEDIUM | 1 | 1 | +| 2022-03-17 06:57 | [#720 词典中最长的单词](https://leetcode.cn/problems/longest-word-in-dictionary) | MEDIUM | 8 | 1 | +| 2022-03-16 11:29 | [#432 全 O(1) 的数据结构](https://leetcode.cn/problems/all-oone-data-structure) | HARD | 4 | 1 | +| 2022-03-15 07:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | +| 2022-03-14 03:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | +| 2022-03-13 08:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | +| 2022-03-12 05:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | +| 2021-09-14 07:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | +| 2021-08-03 05:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | +| 2021-07-30 11:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | +| 2021-07-13 01:53 | [#40 组合总和 II](https://leetcode.cn/problems/combination-sum-ii) | MEDIUM | 3 | 1 | +| 2021-07-13 01:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | +| 2021-07-12 11:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | +| 2021-07-12 10:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | +| 2021-07-06 08:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | +| 2021-07-06 08:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | +| 2021-07-05 07:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | +| 2021-07-05 06:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | +| 2021-07-05 05:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | +| 2021-07-05 05:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | +| 2021-07-05 04:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | +| 2021-07-05 04:30 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 1 | 1 | +| 2021-07-02 07:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | +| 2021-06-15 02:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | +| 2021-06-13 07:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | +| 2021-06-07 11:49 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 1 | 1 | +| 2021-06-04 01:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | +| 2021-05-24 08:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | +| 2021-05-24 03:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | +| 2021-05-21 16:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | +| 2021-05-21 06:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | +| 2021-05-10 07:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | +| 2021-05-05 02:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | +| 2021-05-05 02:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | +| 2021-04-13 10:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | +| 2021-03-30 05:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | +| 2021-03-27 14:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | +| 2021-03-22 10:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | +| 2020-11-27 12:12 | [#454 四数相加 II](https://leetcode.cn/problems/4sum-ii) | MEDIUM | 5 | 1 | +| 2020-11-25 14:35 | [#1370 上升下降字符串](https://leetcode.cn/problems/increasing-decreasing-string) | EASY | 1 | 1 | +| 2020-10-25 11:58 | [#845 数组中的最长山脉](https://leetcode.cn/problems/longest-mountain-in-array) | MEDIUM | 1 | 1 | +| 2020-10-15 12:52 | [#9 回文数](https://leetcode.cn/problems/palindrome-number) | EASY | 1 | 1 | +| 2020-09-04 05:05 | [#257 二叉树的所有路径](https://leetcode.cn/problems/binary-tree-paths) | EASY | 1 | 1 | +| 2020-08-16 07:28 | [#733 图像渲染](https://leetcode.cn/problems/flood-fill) | EASY | 2 | 1 | +| 2020-08-14 15:14 | [#20 有效的括号](https://leetcode.cn/problems/valid-parentheses) | EASY | 6 | 1 | +| 2020-08-10 06:09 | [#696 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings) | EASY | 4 | 1 | +| 2020-08-08 01:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | +| 2020-08-06 08:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | +| 2020-08-03 12:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | +| 2020-08-02 11:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | +| 2020-07-31 05:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | +| 2020-07-31 05:05 | [#面试题 08.03 魔术索引](https://leetcode.cn/problems/magic-index-lcci) | EASY | 2 | 1 | +| 2020-07-29 02:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | +| 2020-07-28 10:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | +| 2020-07-27 02:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | +| 2020-07-23 07:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | +| 2020-07-23 06:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | +| 2020-07-23 06:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | +| 2020-07-22 13:24 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 4 | 1 | +| 2020-07-20 06:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | +| 2020-07-18 15:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | +| 2020-07-17 08:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | +| 2020-04-22 14:11 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 3 | 1 | From b456cada138b9fab2656c065fd65d2c3d72b3745 Mon Sep 17 00:00:00 2001 From: survive Date: Thu, 21 Sep 2023 14:00:35 +0800 Subject: [PATCH 136/373] Update action.yml --- .github/workflows/action.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/action.yml b/.github/workflows/action.yml index f83cc63..daddda7 100644 --- a/.github/workflows/action.yml +++ b/.github/workflows/action.yml @@ -16,6 +16,12 @@ jobs: # 检测代码 - name: 'Checkout codes' uses: actions/checkout@v2 + + # 修改系统时区 + - name: Setup the time zone to Asia/Shanghai + uses: zcong1993/setup-timezone@master + with: + timezone: Asia/Shanghai # 安装requirements.txt中的依赖包 - name: Install dependencies From b44a61c42921c87fcbdf39662986d95eae6f2537 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 21 Sep 2023 14:03:04 +0800 Subject: [PATCH 137/373] Update changes --- README.md | 688 +++++++++++++++++++++++++++--------------------------- 1 file changed, 344 insertions(+), 344 deletions(-) diff --git a/README.md b/README.md index 35803f6..63623f3 100644 --- a/README.md +++ b/README.md @@ -26,347 +26,347 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2023-09-19 13:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | -| 2023-09-18 11:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | -| 2023-09-17 14:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | -| 2023-09-17 14:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | -| 2023-09-14 12:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | -| 2023-09-13 12:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | -| 2023-09-12 12:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | -| 2023-09-11 12:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | -| 2023-09-10 04:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | -| 2023-09-10 02:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | -| 2023-09-01 09:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | -| 2023-09-01 01:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | -| 2023-08-28 11:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | -| 2023-08-25 01:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | -| 2023-08-13 05:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | -| 2023-08-10 12:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | -| 2023-07-16 04:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | -| 2023-07-13 15:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | -| 2023-07-12 11:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | -| 2023-07-10 14:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | -| 2023-07-05 16:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | -| 2023-07-03 15:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | -| 2023-06-27 13:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | -| 2023-06-25 05:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | -| 2023-06-23 05:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | -| 2023-06-11 11:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | -| 2023-06-08 13:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | -| 2023-06-07 12:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | -| 2023-06-02 05:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | -| 2023-06-01 08:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | -| 2023-05-31 13:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | -| 2023-05-29 14:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | -| 2023-05-25 08:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | -| 2023-05-21 06:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | -| 2023-05-14 10:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | -| 2023-05-12 14:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | -| 2023-05-11 09:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | -| 2023-05-11 02:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | -| 2023-05-07 04:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | -| 2023-05-06 14:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | -| 2023-05-05 05:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | -| 2023-05-04 08:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | -| 2023-05-03 14:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | -| 2023-05-02 03:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | -| 2023-05-01 04:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | -| 2023-04-30 11:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | -| 2023-04-30 06:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | -| 2023-04-14 12:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | -| 2023-04-09 03:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | -| 2023-04-03 14:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | -| 2023-03-30 12:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | -| 2023-03-29 15:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | -| 2023-03-22 12:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | -| 2023-03-22 11:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | -| 2023-03-21 11:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | -| 2023-03-18 03:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | -| 2023-03-17 13:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | -| 2023-03-15 03:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | -| 2023-03-14 11:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | -| 2023-03-13 07:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | -| 2023-03-08 13:52 | [#LCR 166 珠宝的最高价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | -| 2023-03-06 13:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | -| 2023-03-03 11:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | -| 2023-02-28 13:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | -| 2023-02-27 09:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | -| 2023-02-20 02:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | -| 2023-02-12 01:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | -| 2023-02-09 09:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | -| 2023-02-08 06:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | -| 2023-01-30 11:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | -| 2023-01-29 08:50 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 2 | 1 | -| 2023-01-28 06:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | -| 2023-01-27 12:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | -| 2023-01-27 11:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | -| 2023-01-26 10:25 | [#1663 具有给定数值的最小字符串](https://leetcode.cn/problems/smallest-string-with-a-given-numeric-value) | MEDIUM | 2 | 1 | -| 2023-01-23 14:32 | [#199 二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view) | MEDIUM | 2 | 1 | -| 2023-01-16 14:39 | [#1813 句子相似性 III](https://leetcode.cn/problems/sentence-similarity-iii) | MEDIUM | 3 | 1 | -| 2023-01-13 12:15 | [#38 外观数列](https://leetcode.cn/problems/count-and-say) | MEDIUM | 1 | 1 | -| 2023-01-13 06:19 | [#36 有效的数独](https://leetcode.cn/problems/valid-sudoku) | MEDIUM | 1 | 1 | -| 2023-01-09 08:15 | [#1806 还原排列的最少操作步数](https://leetcode.cn/problems/minimum-number-of-operations-to-reinitialize-a-permutation) | MEDIUM | 1 | 1 | -| 2023-01-07 14:33 | [#1658 将 x 减到 0 的最小操作数](https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero) | MEDIUM | 1 | 1 | -| 2023-01-05 12:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | -| 2023-01-05 11:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | -| 2023-01-03 07:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | -| 2023-01-01 11:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | -| 2022-12-31 02:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | -| 2022-12-19 06:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | -| 2022-12-18 13:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | -| 2022-12-17 10:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | -| 2022-12-16 04:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | -| 2022-12-15 12:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | -| 2022-12-15 12:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | -| 2022-12-15 12:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | -| 2022-12-15 03:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | -| 2022-12-13 04:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | -| 2022-12-13 03:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | -| 2022-12-12 08:15 | [#1781 所有子字符串美丽值之和](https://leetcode.cn/problems/sum-of-beauty-of-all-substrings) | MEDIUM | 1 | 1 | -| 2022-12-11 08:13 | [#1827 最少操作使数组递增](https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing) | EASY | 1 | 1 | -| 2022-12-10 10:47 | [#1691 堆叠长方体的最大高度](https://leetcode.cn/problems/maximum-height-by-stacking-cuboids) | HARD | 12 | 1 | -| 2022-12-08 01:57 | [#1812 判断国际象棋棋盘中一个格子的颜色](https://leetcode.cn/problems/determine-color-of-a-chessboard-square) | EASY | 2 | 1 | -| 2022-12-07 14:24 | [#1775 通过最少操作次数使数组的和相等](https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations) | MEDIUM | 7 | 1 | -| 2022-12-06 10:03 | [#852 山脉数组的峰顶索引](https://leetcode.cn/problems/peak-index-in-a-mountain-array) | MEDIUM | 2 | **2** | -| 2022-12-06 09:43 | [#1805 字符串中不同整数的数目](https://leetcode.cn/problems/number-of-different-integers-in-a-string) | EASY | 5 | 1 | -| 2022-12-05 06:01 | [#8 字符串转换整数 (atoi)](https://leetcode.cn/problems/string-to-integer-atoi) | MEDIUM | 17 | 1 | -| 2022-12-03 02:38 | [#1796 字符串中第二大的数字](https://leetcode.cn/problems/second-largest-digit-in-a-string) | EASY | 4 | 1 | -| 2022-12-02 02:12 | [#1769 移动所有球到每个盒子所需的最小操作数](https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box) | MEDIUM | 1 | 1 | -| 2022-12-01 02:32 | [#1779 找到最近的有相同 X 或 Y 坐标的点](https://leetcode.cn/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate) | EASY | 1 | 1 | -| 2022-11-30 07:35 | [#895 最大频率栈](https://leetcode.cn/problems/maximum-frequency-stack) | HARD | 2 | 1 | -| 2022-11-29 10:06 | [#1758 生成交替二进制字符串的最少操作数](https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string) | EASY | 1 | 1 | -| 2022-11-28 08:31 | [#813 最大平均值和的分组](https://leetcode.cn/problems/largest-sum-of-averages) | MEDIUM | 3 | 1 | -| 2022-11-27 12:12 | [#1752 检查数组是否经排序和轮转得到](https://leetcode.cn/problems/check-if-array-is-sorted-and-rotated) | EASY | 2 | 1 | -| 2022-11-26 11:10 | [#743 网络延迟时间](https://leetcode.cn/problems/network-delay-time) | MEDIUM | 9 | **5** | -| 2022-11-26 10:56 | [#787 K 站中转内最便宜的航班](https://leetcode.cn/problems/cheapest-flights-within-k-stops) | MEDIUM | 6 | **2** | -| 2022-11-26 08:01 | [#882 细分图中的可到达节点](https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph) | HARD | 2 | 1 | -| 2022-11-26 05:52 | [#809 情感丰富的文字](https://leetcode.cn/problems/expressive-words) | MEDIUM | 2 | 1 | -| 2022-11-24 08:25 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 6 | **2** | -| 2022-11-24 07:52 | [#1668 最大重复子字符串](https://leetcode.cn/problems/maximum-repeating-substring) | EASY | 4 | **2** | -| 2022-11-24 07:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | -| 2022-11-23 13:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | -| 2022-11-23 09:30 | [#1742 盒子中小球的最大数量](https://leetcode.cn/problems/maximum-number-of-balls-in-a-box) | EASY | 1 | 1 | -| 2022-11-21 12:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | -| 2022-11-21 11:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | -| 2022-11-21 10:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | -| 2022-11-21 08:43 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 5 | **2** | -| 2022-11-21 06:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | -| 2022-11-21 03:04 | [#799 香槟塔](https://leetcode.cn/problems/champagne-tower) | MEDIUM | 2 | 1 | -| 2022-11-19 12:48 | [#139 单词拆分](https://leetcode.cn/problems/word-break) | MEDIUM | 3 | 1 | -| 2022-11-19 08:56 | [#208 实现 Trie (前缀树)](https://leetcode.cn/problems/implement-trie-prefix-tree) | MEDIUM | 2 | 1 | -| 2022-11-19 02:02 | [#1732 找到最高海拔](https://leetcode.cn/problems/find-the-highest-altitude) | EASY | 1 | 1 | -| 2022-11-17 16:48 | [#792 匹配子序列的单词数](https://leetcode.cn/problems/number-of-matching-subsequences) | MEDIUM | 2 | 1 | -| 2022-11-16 05:19 | [#775 全局倒置与局部倒置](https://leetcode.cn/problems/global-and-local-inversions) | MEDIUM | 9 | 1 | -| 2022-11-15 12:30 | [#1926 迷宫中离入口最近的出口](https://leetcode.cn/problems/nearest-exit-from-entrance-in-maze) | MEDIUM | 4 | 1 | -| 2022-11-15 11:11 | [#1710 卡车上的最大单元数](https://leetcode.cn/problems/maximum-units-on-a-truck) | EASY | 2 | 1 | -| 2022-11-13 16:19 | [#704 二分查找](https://leetcode.cn/problems/binary-search) | EASY | 10 | 1 | -| 2022-11-13 09:37 | [#916 单词子集](https://leetcode.cn/problems/word-subsets) | MEDIUM | 4 | 1 | -| 2022-11-13 07:18 | [#剑指 Offer 51 数组中的逆序对](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | -| 2022-11-13 05:33 | [#791 自定义字符串排序](https://leetcode.cn/problems/custom-sort-string) | MEDIUM | 2 | 1 | -| 2022-11-12 12:54 | [#1339 分裂二叉树的最大乘积](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree) | MEDIUM | 3 | 1 | -| 2022-11-12 06:18 | [#790 多米诺和托米诺平铺](https://leetcode.cn/problems/domino-and-tromino-tiling) | MEDIUM | 4 | 1 | -| 2022-11-11 05:02 | [#129 求根节点到叶节点数字之和](https://leetcode.cn/problems/sum-root-to-leaf-numbers) | MEDIUM | 3 | 1 | -| 2022-11-11 02:03 | [#1704 判断字符串的两半是否相似](https://leetcode.cn/problems/determine-if-string-halves-are-alike) | EASY | 1 | 1 | -| 2022-11-08 00:26 | [#1684 统计一致字符串的数目](https://leetcode.cn/problems/count-the-number-of-consistent-strings) | EASY | 1 | 1 | -| 2022-11-07 07:37 | [#816 模糊坐标](https://leetcode.cn/problems/ambiguous-coordinates) | MEDIUM | 2 | 1 | -| 2022-11-06 03:38 | [#1678 设计 Goal 解析器](https://leetcode.cn/problems/goal-parser-interpretation) | EASY | 1 | 1 | -| 2022-11-05 10:31 | [#1106 解析布尔表达式](https://leetcode.cn/problems/parsing-a-boolean-expression) | HARD | 3 | 1 | -| 2022-11-04 06:12 | [#754 到达终点数字](https://leetcode.cn/problems/reach-a-number) | MEDIUM | 4 | 1 | -| 2022-11-02 12:43 | [#1620 网络信号最好的坐标](https://leetcode.cn/problems/coordinate-with-maximum-network-quality) | MEDIUM | 1 | 1 | -| 2022-11-01 06:49 | [#1662 检查两个字符串数组是否相等](https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent) | EASY | 1 | 1 | -| 2022-10-31 02:25 | [#481 神奇字符串](https://leetcode.cn/problems/magical-string) | MEDIUM | 4 | 1 | -| 2022-10-29 15:17 | [#1773 统计匹配检索规则的物品数量](https://leetcode.cn/problems/count-items-matching-a-rule) | EASY | 2 | 1 | -| 2022-10-27 02:20 | [#1822 数组元素积的符号](https://leetcode.cn/problems/sign-of-the-product-of-an-array) | EASY | 2 | 1 | -| 2022-10-24 07:37 | [#1235 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling) | HARD | 7 | **2** | -| 2022-10-24 00:13 | [#915 分割数组](https://leetcode.cn/problems/partition-array-into-disjoint-intervals) | MEDIUM | 3 | 1 | -| 2022-10-23 10:07 | [#1768 交替合并字符串](https://leetcode.cn/problems/merge-strings-alternately) | EASY | 2 | 1 | -| 2022-10-21 02:50 | [#901 股票价格跨度](https://leetcode.cn/problems/online-stock-span) | MEDIUM | 1 | 1 | -| 2022-10-20 13:51 | [#779 第K个语法符号](https://leetcode.cn/problems/k-th-symbol-in-grammar) | MEDIUM | 1 | 1 | -| 2022-10-19 08:47 | [#1700 无法吃午餐的学生数量](https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch) | EASY | 2 | 1 | -| 2022-10-17 04:25 | [#904 水果成篮](https://leetcode.cn/problems/fruit-into-baskets) | MEDIUM | 3 | 1 | -| 2022-10-16 05:16 | [#886 可能的二分法](https://leetcode.cn/problems/possible-bipartition) | MEDIUM | 4 | 1 | -| 2022-10-15 06:16 | [#7 整数反转](https://leetcode.cn/problems/reverse-integer) | MEDIUM | 4 | 1 | -| 2022-10-15 02:09 | [#1441 用栈操作构建数组](https://leetcode.cn/problems/build-an-array-with-stack-operations) | MEDIUM | 4 | 1 | -| 2022-10-14 08:07 | [#940 不同的子序列 II](https://leetcode.cn/problems/distinct-subsequences-ii) | HARD | 6 | 1 | -| 2022-10-13 12:08 | [#769 最多能完成排序的块](https://leetcode.cn/problems/max-chunks-to-make-sorted) | MEDIUM | 2 | 1 | -| 2022-10-12 02:03 | [#817 链表组件](https://leetcode.cn/problems/linked-list-components) | MEDIUM | 6 | 1 | -| 2022-10-11 02:02 | [#1790 仅执行一次字符串交换能否使两个字符串相等](https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal) | EASY | 3 | 1 | -| 2022-10-10 04:24 | [#856 括号的分数](https://leetcode.cn/problems/score-of-parentheses) | MEDIUM | 2 | 1 | -| 2022-10-08 02:54 | [#870 优势洗牌](https://leetcode.cn/problems/advantage-shuffle) | MEDIUM | 2 | 1 | -| 2022-10-07 04:41 | [#1694 重新格式化电话号码](https://leetcode.cn/problems/reformat-phone-number) | EASY | 2 | 1 | -| 2022-10-07 04:16 | [#1800 最大升序子数组和](https://leetcode.cn/problems/maximum-ascending-subarray-sum) | EASY | 3 | 1 | -| 2022-10-05 04:22 | [#811 子域名访问计数](https://leetcode.cn/problems/subdomain-visit-count) | MEDIUM | 1 | 1 | -| 2022-10-04 14:20 | [#921 使括号有效的最少添加](https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid) | MEDIUM | 4 | 1 | -| 2022-09-30 07:12 | [#73 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes) | MEDIUM | 1 | 1 | -| 2022-09-30 06:44 | [#面试题 01.08 零矩阵](https://leetcode.cn/problems/zero-matrix-lcci) | MEDIUM | 2 | 1 | -| 2022-09-29 15:57 | [#面试题 17.09 第 k 个数](https://leetcode.cn/problems/get-kth-magic-number-lcci) | MEDIUM | 3 | 1 | -| 2022-09-29 02:16 | [#面试题 01.09 字符串轮转](https://leetcode.cn/problems/string-rotation-lcci) | EASY | 1 | 1 | -| 2022-09-27 14:47 | [#面试题 01.02 判定是否互为字符重排](https://leetcode.cn/problems/check-permutation-lcci) | EASY | 1 | 1 | -| 2022-09-27 03:35 | [#面试题 17.19 消失的两个数字](https://leetcode.cn/problems/missing-two-lcci) | HARD | 3 | 1 | -| 2022-09-26 07:21 | [#788 旋转数字](https://leetcode.cn/problems/rotated-digits) | MEDIUM | 1 | 1 | -| 2022-09-22 01:45 | [#1640 能否连接形成数组](https://leetcode.cn/problems/check-array-formation-through-concatenation) | EASY | 3 | 1 | -| 2022-09-13 07:55 | [#1608 特殊数组的特征值](https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x) | EASY | 7 | 1 | -| 2022-09-13 07:06 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 7 | 1 | -| 2022-09-09 07:29 | [#1598 文件夹操作日志搜集器](https://leetcode.cn/problems/crawler-log-folder) | EASY | 3 | 1 | -| 2022-09-01 05:48 | [#1475 商品折扣后的最终价格](https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop) | EASY | 1 | 1 | -| 2022-08-31 05:22 | [#946 验证栈序列](https://leetcode.cn/problems/validate-stack-sequences) | MEDIUM | 2 | 1 | -| 2022-08-19 04:44 | [#1450 在既定时间做作业的学生人数](https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time) | EASY | 1 | 1 | -| 2022-08-17 04:14 | [#1302 层数最深叶子节点的和](https://leetcode.cn/problems/deepest-leaves-sum) | MEDIUM | 1 | 1 | -| 2022-08-10 10:34 | [#640 求解方程](https://leetcode.cn/problems/solve-the-equation) | MEDIUM | 4 | 1 | -| 2022-08-01 04:42 | [#1374 生成每种字符都是奇数个的字符串](https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts) | EASY | 1 | 1 | -| 2022-07-25 06:34 | [#919 完全二叉树插入器](https://leetcode.cn/problems/complete-binary-tree-inserter) | MEDIUM | 1 | 1 | -| 2022-07-23 06:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | -| 2022-07-17 03:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | -| 2022-07-14 05:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | -| 2022-07-13 11:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | -| 2022-07-11 05:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | -| 2022-07-08 06:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | -| 2022-07-08 05:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | -| 2022-07-07 07:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | -| 2022-07-05 06:13 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 3 | **2** | -| 2022-07-05 03:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | -| 2022-07-04 02:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | -| 2022-07-03 12:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | -| 2022-06-24 05:38 | [#515 在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row) | MEDIUM | 1 | 1 | -| 2022-06-22 06:33 | [#513 找树左下角的值](https://leetcode.cn/problems/find-bottom-left-tree-value) | MEDIUM | 4 | 1 | -| 2022-06-21 11:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | -| 2022-06-19 15:06 | [#98 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree) | MEDIUM | 13 | 1 | -| 2022-06-19 07:20 | [#508 出现次数最多的子树元素和](https://leetcode.cn/problems/most-frequent-subtree-sum) | MEDIUM | 2 | 1 | -| 2022-06-18 06:19 | [#LCR 029 循环有序列表的插入](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | -| 2022-06-17 07:48 | [#1089 复写零](https://leetcode.cn/problems/duplicate-zeros) | EASY | 2 | 1 | -| 2022-06-13 15:05 | [#1051 高度检查器](https://leetcode.cn/problems/height-checker) | EASY | 2 | 1 | -| 2022-06-12 15:05 | [#890 查找和替换模式](https://leetcode.cn/problems/find-and-replace-pattern) | MEDIUM | 1 | 1 | -| 2022-06-05 06:59 | [#478 在圆内随机生成点](https://leetcode.cn/problems/generate-random-point-in-a-circle) | MEDIUM | 8 | 1 | -| 2022-06-04 04:34 | [#929 独特的电子邮件地址](https://leetcode.cn/problems/unique-email-addresses) | EASY | 5 | 1 | -| 2022-05-30 12:32 | [#1022 从根到叶的二进制数之和](https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers) | EASY | 3 | 1 | -| 2022-05-28 04:21 | [#1021 删除最外层的括号](https://leetcode.cn/problems/remove-outermost-parentheses) | EASY | 1 | 1 | -| 2022-05-27 09:40 | [#面试题 17.11 单词距离](https://leetcode.cn/problems/find-closest-lcci) | MEDIUM | 2 | 1 | -| 2022-05-24 04:35 | [#965 单值二叉树](https://leetcode.cn/problems/univalued-binary-tree) | EASY | 2 | 1 | -| 2022-05-21 09:47 | [#961 在长度 2N 的数组中找出重复 N 次的元素](https://leetcode.cn/problems/n-repeated-element-in-size-2n-array) | EASY | 2 | 1 | -| 2022-05-20 06:55 | [#436 寻找右区间](https://leetcode.cn/problems/find-right-interval) | MEDIUM | 3 | 1 | -| 2022-05-19 05:50 | [#462 最小操作次数使数组元素相等 II](https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii) | MEDIUM | 1 | 1 | -| 2022-05-18 05:08 | [#668 乘法表中第k小的数](https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table) | HARD | 3 | 1 | -| 2022-05-17 03:08 | [#953 验证外星语词典](https://leetcode.cn/problems/verifying-an-alien-dictionary) | EASY | 2 | 1 | -| 2022-05-16 08:08 | [#面试题 04.06 后继者](https://leetcode.cn/problems/successor-lcci) | MEDIUM | 5 | 1 | -| 2022-05-15 06:35 | [#812 最大三角形面积](https://leetcode.cn/problems/largest-triangle-area) | EASY | 4 | 1 | -| 2022-05-13 14:09 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 3 | 1 | -| 2022-05-13 05:28 | [#面试题 01.05 一次编辑](https://leetcode.cn/problems/one-away-lcci) | MEDIUM | 3 | 1 | -| 2022-05-12 13:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | -| 2022-05-10 07:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | -| 2022-05-09 06:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | -| 2022-05-09 06:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | -| 2022-05-09 06:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | -| 2022-05-09 05:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | -| 2022-05-08 02:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | -| 2022-05-07 12:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | -| 2022-05-07 08:37 | [#433 最小基因变化](https://leetcode.cn/problems/minimum-genetic-mutation) | MEDIUM | 3 | 1 | -| 2022-05-06 07:00 | [#113 路径总和 II](https://leetcode.cn/problems/path-sum-ii) | MEDIUM | 1 | 1 | -| 2022-05-06 06:46 | [#933 最近的请求次数](https://leetcode.cn/problems/number-of-recent-calls) | EASY | 1 | 1 | -| 2022-05-05 03:07 | [#713 乘积小于 K 的子数组](https://leetcode.cn/problems/subarray-product-less-than-k) | MEDIUM | 3 | 1 | -| 2022-05-04 04:31 | [#1823 找出游戏的获胜者](https://leetcode.cn/problems/find-the-winner-of-the-circular-game) | MEDIUM | 2 | 1 | -| 2022-05-03 04:37 | [#937 重新排列日志文件](https://leetcode.cn/problems/reorder-data-in-log-files) | MEDIUM | 2 | 1 | -| 2022-05-02 07:00 | [#591 标签验证器](https://leetcode.cn/problems/tag-validator) | HARD | 8 | 1 | -| 2022-05-02 06:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | -| 2022-05-01 09:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | -| 2022-04-30 06:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | -| 2022-04-29 07:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | -| 2022-04-28 04:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | -| 2022-04-26 11:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | -| 2022-04-25 04:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | -| 2022-04-24 05:08 | [#868 二进制间距](https://leetcode.cn/problems/binary-gap) | EASY | 1 | 1 | -| 2022-04-22 07:01 | [#396 旋转函数](https://leetcode.cn/problems/rotate-function) | MEDIUM | 2 | 1 | -| 2022-04-21 05:01 | [#824 山羊拉丁文](https://leetcode.cn/problems/goat-latin) | EASY | 1 | 1 | -| 2022-04-20 06:44 | [#388 文件的最长绝对路径](https://leetcode.cn/problems/longest-absolute-file-path) | MEDIUM | 2 | 1 | -| 2022-04-19 04:26 | [#821 字符的最短距离](https://leetcode.cn/problems/shortest-distance-to-a-character) | EASY | 1 | 1 | -| 2022-04-18 07:36 | [#386 字典序排数](https://leetcode.cn/problems/lexicographical-numbers) | MEDIUM | 2 | 1 | -| 2022-04-17 05:28 | [#819 最常见的单词](https://leetcode.cn/problems/most-common-word) | EASY | 3 | 1 | -| 2022-04-16 04:46 | [#479 最大回文数乘积](https://leetcode.cn/problems/largest-palindrome-product) | HARD | 2 | 1 | -| 2022-04-15 07:05 | [#385 迷你语法分析器](https://leetcode.cn/problems/mini-parser) | MEDIUM | 4 | 1 | -| 2022-04-14 02:21 | [#1672 最富有客户的资产总量](https://leetcode.cn/problems/richest-customer-wealth) | EASY | 1 | 1 | -| 2022-04-13 10:53 | [#380 O(1) 时间插入、删除和获取随机元素](https://leetcode.cn/problems/insert-delete-getrandom-o1) | MEDIUM | 5 | 1 | -| 2022-04-12 02:06 | [#806 写字符串需要的行数](https://leetcode.cn/problems/number-of-lines-to-write-string) | EASY | 1 | 1 | -| 2022-04-11 07:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | -| 2022-04-10 04:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | -| 2022-04-09 10:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | -| 2022-04-08 03:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | -| 2022-04-06 06:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | -| 2022-04-05 07:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | -| 2022-04-03 12:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | -| 2022-04-02 10:50 | [#132 分割回文串 II](https://leetcode.cn/problems/palindrome-partitioning-ii) | HARD | 4 | 1 | -| 2022-04-01 03:41 | [#954 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs) | MEDIUM | 10 | 1 | -| 2022-03-31 04:57 | [#728 自除数](https://leetcode.cn/problems/self-dividing-numbers) | EASY | 1 | 1 | -| 2022-03-30 09:45 | [#1606 找到处理最多请求的服务器](https://leetcode.cn/problems/find-servers-that-handled-most-number-of-requests) | HARD | 6 | 1 | -| 2022-03-29 05:49 | [#2024 考试的最大困扰度](https://leetcode.cn/problems/maximize-the-confusion-of-an-exam) | MEDIUM | 1 | 1 | -| 2022-03-28 06:22 | [#693 交替位二进制数](https://leetcode.cn/problems/binary-number-with-alternating-bits) | EASY | 1 | 1 | -| 2022-03-27 04:46 | [#2028 找出缺失的观测数据](https://leetcode.cn/problems/find-missing-observations) | MEDIUM | 7 | 1 | -| 2022-03-26 07:02 | [#682 棒球比赛](https://leetcode.cn/problems/baseball-game) | EASY | 1 | 1 | -| 2022-03-25 05:23 | [#172 阶乘后的零](https://leetcode.cn/problems/factorial-trailing-zeroes) | MEDIUM | 4 | 1 | -| 2022-03-24 02:20 | [#661 图片平滑器](https://leetcode.cn/problems/image-smoother) | EASY | 1 | 1 | -| 2022-03-23 10:40 | [#440 字典序的第K小数字](https://leetcode.cn/problems/k-th-smallest-in-lexicographical-order) | HARD | 6 | 1 | -| 2022-03-22 04:43 | [#2038 如果相邻两个颜色均相同则删除当前颜色](https://leetcode.cn/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color) | MEDIUM | 3 | 1 | -| 2022-03-21 07:27 | [#653 两数之和 IV - 输入二叉搜索树](https://leetcode.cn/problems/two-sum-iv-input-is-a-bst) | EASY | 1 | 1 | -| 2022-03-20 07:10 | [#2039 网络空闲的时刻](https://leetcode.cn/problems/the-time-when-the-network-becomes-idle) | MEDIUM | 1 | 1 | -| 2022-03-19 07:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | EASY | 3 | 1 | -| 2022-03-18 04:11 | [#2043 简易银行系统](https://leetcode.cn/problems/simple-bank-system) | MEDIUM | 1 | 1 | -| 2022-03-17 06:57 | [#720 词典中最长的单词](https://leetcode.cn/problems/longest-word-in-dictionary) | MEDIUM | 8 | 1 | -| 2022-03-16 11:29 | [#432 全 O(1) 的数据结构](https://leetcode.cn/problems/all-oone-data-structure) | HARD | 4 | 1 | -| 2022-03-15 07:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | -| 2022-03-14 03:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | -| 2022-03-13 08:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | -| 2022-03-12 05:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | -| 2021-09-14 07:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | -| 2021-08-03 05:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | -| 2021-07-30 11:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | -| 2021-07-13 01:53 | [#40 组合总和 II](https://leetcode.cn/problems/combination-sum-ii) | MEDIUM | 3 | 1 | -| 2021-07-13 01:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | -| 2021-07-12 11:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | -| 2021-07-12 10:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | -| 2021-07-06 08:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | -| 2021-07-06 08:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | -| 2021-07-05 07:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | -| 2021-07-05 06:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | -| 2021-07-05 05:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | -| 2021-07-05 05:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | -| 2021-07-05 04:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | -| 2021-07-05 04:30 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 1 | 1 | -| 2021-07-02 07:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | -| 2021-06-15 02:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | -| 2021-06-13 07:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | -| 2021-06-07 11:49 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 1 | 1 | -| 2021-06-04 01:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | -| 2021-05-24 08:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | -| 2021-05-24 03:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | -| 2021-05-21 16:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | -| 2021-05-21 06:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | -| 2021-05-10 07:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | -| 2021-05-05 02:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | -| 2021-05-05 02:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | -| 2021-04-13 10:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | -| 2021-03-30 05:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | -| 2021-03-27 14:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | -| 2021-03-22 10:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | -| 2020-11-27 12:12 | [#454 四数相加 II](https://leetcode.cn/problems/4sum-ii) | MEDIUM | 5 | 1 | -| 2020-11-25 14:35 | [#1370 上升下降字符串](https://leetcode.cn/problems/increasing-decreasing-string) | EASY | 1 | 1 | -| 2020-10-25 11:58 | [#845 数组中的最长山脉](https://leetcode.cn/problems/longest-mountain-in-array) | MEDIUM | 1 | 1 | -| 2020-10-15 12:52 | [#9 回文数](https://leetcode.cn/problems/palindrome-number) | EASY | 1 | 1 | -| 2020-09-04 05:05 | [#257 二叉树的所有路径](https://leetcode.cn/problems/binary-tree-paths) | EASY | 1 | 1 | -| 2020-08-16 07:28 | [#733 图像渲染](https://leetcode.cn/problems/flood-fill) | EASY | 2 | 1 | -| 2020-08-14 15:14 | [#20 有效的括号](https://leetcode.cn/problems/valid-parentheses) | EASY | 6 | 1 | -| 2020-08-10 06:09 | [#696 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings) | EASY | 4 | 1 | -| 2020-08-08 01:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | -| 2020-08-06 08:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | -| 2020-08-03 12:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | -| 2020-08-02 11:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | -| 2020-07-31 05:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | -| 2020-07-31 05:05 | [#面试题 08.03 魔术索引](https://leetcode.cn/problems/magic-index-lcci) | EASY | 2 | 1 | -| 2020-07-29 02:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | -| 2020-07-28 10:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | -| 2020-07-27 02:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | -| 2020-07-23 07:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | -| 2020-07-23 06:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | -| 2020-07-23 06:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | -| 2020-07-22 13:24 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 4 | 1 | -| 2020-07-20 06:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | -| 2020-07-18 15:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | -| 2020-07-17 08:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | -| 2020-04-22 14:11 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 3 | 1 | +| 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | +| 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | +| 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | +| 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | +| 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | +| 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | +| 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | +| 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | +| 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | +| 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | +| 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | +| 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | +| 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | +| 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | +| 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | +| 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | +| 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | +| 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | +| 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | +| 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | +| 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | +| 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | +| 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | +| 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | +| 2023-06-23 13:38 | [#2095 删除链表的中间节点](https://leetcode.cn/problems/delete-the-middle-node-of-a-linked-list) | MEDIUM | 3 | 1 | +| 2023-06-11 19:37 | [#1171 从链表中删去总和值为零的连续节点](https://leetcode.cn/problems/remove-zero-sum-consecutive-nodes-from-linked-list) | MEDIUM | 5 | 1 | +| 2023-06-08 21:01 | [#2390 从字符串中移除星号](https://leetcode.cn/problems/removing-stars-from-a-string) | MEDIUM | 1 | 1 | +| 2023-06-07 20:08 | [#2611 老鼠和奶酪](https://leetcode.cn/problems/mice-and-cheese) | MEDIUM | 5 | 1 | +| 2023-06-02 13:15 | [#2559 统计范围内的元音字符串数](https://leetcode.cn/problems/count-vowel-strings-in-ranges) | MEDIUM | 3 | 1 | +| 2023-06-01 16:33 | [#2517 礼盒的最大甜蜜度](https://leetcode.cn/problems/maximum-tastiness-of-candy-basket) | MEDIUM | 3 | 1 | +| 2023-05-31 21:16 | [#2300 咒语和药水的成功对数](https://leetcode.cn/problems/successful-pairs-of-spells-and-potions) | MEDIUM | 3 | 1 | +| 2023-05-29 22:29 | [#2352 相等行列对](https://leetcode.cn/problems/equal-row-and-column-pairs) | MEDIUM | 2 | 1 | +| 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | +| 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | +| 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | +| 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | +| 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | +| 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | +| 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | +| 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | +| 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | +| 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | +| 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | +| 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | +| 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | +| 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | +| 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | +| 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | +| 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | +| 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | +| 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | +| 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | +| 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | +| 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | +| 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | +| 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | +| 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | +| 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | +| 2023-03-14 19:12 | [#1605 给定行和列的和求可行矩阵](https://leetcode.cn/problems/find-valid-matrix-given-row-and-column-sums) | MEDIUM | 1 | 1 | +| 2023-03-13 15:38 | [#289 生命游戏](https://leetcode.cn/problems/game-of-life) | MEDIUM | 2 | 1 | +| 2023-03-08 21:52 | [#LCR 166 珠宝的最高价值](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof) | MEDIUM | 1 | 1 | +| 2023-03-06 21:52 | [#1653 使字符串平衡的最少删除次数](https://leetcode.cn/problems/minimum-deletions-to-make-string-balanced) | MEDIUM | 4 | 1 | +| 2023-03-03 19:26 | [#1487 保证文件名唯一](https://leetcode.cn/problems/making-file-names-unique) | MEDIUM | 5 | 1 | +| 2023-02-28 21:44 | [#1801 积压订单中的订单总数](https://leetcode.cn/problems/number-of-orders-in-the-backlog) | MEDIUM | 2 | 1 | +| 2023-02-27 17:01 | [#1144 递减元素使数组呈锯齿状](https://leetcode.cn/problems/decrease-elements-to-make-array-zigzag) | MEDIUM | 4 | 1 | +| 2023-02-20 10:19 | [#1792 最大平均通过率](https://leetcode.cn/problems/maximum-average-pass-ratio) | MEDIUM | 2 | 1 | +| 2023-02-12 09:58 | [#1138 字母板上的路径](https://leetcode.cn/problems/alphabet-board-path) | MEDIUM | 4 | 1 | +| 2023-02-09 17:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | +| 2023-02-08 14:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | +| 2023-01-30 19:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | +| 2023-01-29 16:50 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 2 | 1 | +| 2023-01-28 14:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | +| 2023-01-27 20:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | +| 2023-01-27 19:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | +| 2023-01-26 18:25 | [#1663 具有给定数值的最小字符串](https://leetcode.cn/problems/smallest-string-with-a-given-numeric-value) | MEDIUM | 2 | 1 | +| 2023-01-23 22:32 | [#199 二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view) | MEDIUM | 2 | 1 | +| 2023-01-16 22:39 | [#1813 句子相似性 III](https://leetcode.cn/problems/sentence-similarity-iii) | MEDIUM | 3 | 1 | +| 2023-01-13 20:15 | [#38 外观数列](https://leetcode.cn/problems/count-and-say) | MEDIUM | 1 | 1 | +| 2023-01-13 14:19 | [#36 有效的数独](https://leetcode.cn/problems/valid-sudoku) | MEDIUM | 1 | 1 | +| 2023-01-09 16:15 | [#1806 还原排列的最少操作步数](https://leetcode.cn/problems/minimum-number-of-operations-to-reinitialize-a-permutation) | MEDIUM | 1 | 1 | +| 2023-01-07 22:33 | [#1658 将 x 减到 0 的最小操作数](https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero) | MEDIUM | 1 | 1 | +| 2023-01-05 20:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | +| 2023-01-05 19:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | +| 2023-01-03 15:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | +| 2023-01-01 19:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | +| 2022-12-31 10:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | +| 2022-12-19 14:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | +| 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | +| 2022-12-17 18:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | +| 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | +| 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | +| 2022-12-15 20:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | +| 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | +| 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | +| 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | +| 2022-12-13 11:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | +| 2022-12-12 16:15 | [#1781 所有子字符串美丽值之和](https://leetcode.cn/problems/sum-of-beauty-of-all-substrings) | MEDIUM | 1 | 1 | +| 2022-12-11 16:13 | [#1827 最少操作使数组递增](https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing) | EASY | 1 | 1 | +| 2022-12-10 18:47 | [#1691 堆叠长方体的最大高度](https://leetcode.cn/problems/maximum-height-by-stacking-cuboids) | HARD | 12 | 1 | +| 2022-12-08 09:57 | [#1812 判断国际象棋棋盘中一个格子的颜色](https://leetcode.cn/problems/determine-color-of-a-chessboard-square) | EASY | 2 | 1 | +| 2022-12-07 22:24 | [#1775 通过最少操作次数使数组的和相等](https://leetcode.cn/problems/equal-sum-arrays-with-minimum-number-of-operations) | MEDIUM | 7 | 1 | +| 2022-12-06 18:03 | [#852 山脉数组的峰顶索引](https://leetcode.cn/problems/peak-index-in-a-mountain-array) | MEDIUM | 2 | **2** | +| 2022-12-06 17:43 | [#1805 字符串中不同整数的数目](https://leetcode.cn/problems/number-of-different-integers-in-a-string) | EASY | 5 | 1 | +| 2022-12-05 14:01 | [#8 字符串转换整数 (atoi)](https://leetcode.cn/problems/string-to-integer-atoi) | MEDIUM | 17 | 1 | +| 2022-12-03 10:38 | [#1796 字符串中第二大的数字](https://leetcode.cn/problems/second-largest-digit-in-a-string) | EASY | 4 | 1 | +| 2022-12-02 10:12 | [#1769 移动所有球到每个盒子所需的最小操作数](https://leetcode.cn/problems/minimum-number-of-operations-to-move-all-balls-to-each-box) | MEDIUM | 1 | 1 | +| 2022-12-01 10:32 | [#1779 找到最近的有相同 X 或 Y 坐标的点](https://leetcode.cn/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate) | EASY | 1 | 1 | +| 2022-11-30 15:35 | [#895 最大频率栈](https://leetcode.cn/problems/maximum-frequency-stack) | HARD | 2 | 1 | +| 2022-11-29 18:06 | [#1758 生成交替二进制字符串的最少操作数](https://leetcode.cn/problems/minimum-changes-to-make-alternating-binary-string) | EASY | 1 | 1 | +| 2022-11-28 16:31 | [#813 最大平均值和的分组](https://leetcode.cn/problems/largest-sum-of-averages) | MEDIUM | 3 | 1 | +| 2022-11-27 20:12 | [#1752 检查数组是否经排序和轮转得到](https://leetcode.cn/problems/check-if-array-is-sorted-and-rotated) | EASY | 2 | 1 | +| 2022-11-26 19:10 | [#743 网络延迟时间](https://leetcode.cn/problems/network-delay-time) | MEDIUM | 9 | **5** | +| 2022-11-26 18:56 | [#787 K 站中转内最便宜的航班](https://leetcode.cn/problems/cheapest-flights-within-k-stops) | MEDIUM | 6 | **2** | +| 2022-11-26 16:01 | [#882 细分图中的可到达节点](https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph) | HARD | 2 | 1 | +| 2022-11-26 13:52 | [#809 情感丰富的文字](https://leetcode.cn/problems/expressive-words) | MEDIUM | 2 | 1 | +| 2022-11-24 16:25 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 6 | **2** | +| 2022-11-24 15:52 | [#1668 最大重复子字符串](https://leetcode.cn/problems/maximum-repeating-substring) | EASY | 4 | **2** | +| 2022-11-24 15:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | +| 2022-11-23 21:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | +| 2022-11-23 17:30 | [#1742 盒子中小球的最大数量](https://leetcode.cn/problems/maximum-number-of-balls-in-a-box) | EASY | 1 | 1 | +| 2022-11-21 20:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | +| 2022-11-21 19:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | +| 2022-11-21 18:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | +| 2022-11-21 16:43 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 5 | **2** | +| 2022-11-21 14:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | +| 2022-11-21 11:04 | [#799 香槟塔](https://leetcode.cn/problems/champagne-tower) | MEDIUM | 2 | 1 | +| 2022-11-19 20:48 | [#139 单词拆分](https://leetcode.cn/problems/word-break) | MEDIUM | 3 | 1 | +| 2022-11-19 16:56 | [#208 实现 Trie (前缀树)](https://leetcode.cn/problems/implement-trie-prefix-tree) | MEDIUM | 2 | 1 | +| 2022-11-19 10:02 | [#1732 找到最高海拔](https://leetcode.cn/problems/find-the-highest-altitude) | EASY | 1 | 1 | +| 2022-11-18 00:48 | [#792 匹配子序列的单词数](https://leetcode.cn/problems/number-of-matching-subsequences) | MEDIUM | 2 | 1 | +| 2022-11-16 13:19 | [#775 全局倒置与局部倒置](https://leetcode.cn/problems/global-and-local-inversions) | MEDIUM | 9 | 1 | +| 2022-11-15 20:30 | [#1926 迷宫中离入口最近的出口](https://leetcode.cn/problems/nearest-exit-from-entrance-in-maze) | MEDIUM | 4 | 1 | +| 2022-11-15 19:11 | [#1710 卡车上的最大单元数](https://leetcode.cn/problems/maximum-units-on-a-truck) | EASY | 2 | 1 | +| 2022-11-14 00:19 | [#704 二分查找](https://leetcode.cn/problems/binary-search) | EASY | 10 | **2** | +| 2022-11-13 17:37 | [#916 单词子集](https://leetcode.cn/problems/word-subsets) | MEDIUM | 4 | 1 | +| 2022-11-13 15:18 | [#剑指 Offer 51 数组中的逆序对](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | +| 2022-11-13 13:33 | [#791 自定义字符串排序](https://leetcode.cn/problems/custom-sort-string) | MEDIUM | 2 | 1 | +| 2022-11-12 20:54 | [#1339 分裂二叉树的最大乘积](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree) | MEDIUM | 3 | 1 | +| 2022-11-12 14:18 | [#790 多米诺和托米诺平铺](https://leetcode.cn/problems/domino-and-tromino-tiling) | MEDIUM | 4 | 1 | +| 2022-11-11 13:02 | [#129 求根节点到叶节点数字之和](https://leetcode.cn/problems/sum-root-to-leaf-numbers) | MEDIUM | 3 | 1 | +| 2022-11-11 10:03 | [#1704 判断字符串的两半是否相似](https://leetcode.cn/problems/determine-if-string-halves-are-alike) | EASY | 1 | 1 | +| 2022-11-08 08:26 | [#1684 统计一致字符串的数目](https://leetcode.cn/problems/count-the-number-of-consistent-strings) | EASY | 1 | 1 | +| 2022-11-07 15:37 | [#816 模糊坐标](https://leetcode.cn/problems/ambiguous-coordinates) | MEDIUM | 2 | 1 | +| 2022-11-06 11:38 | [#1678 设计 Goal 解析器](https://leetcode.cn/problems/goal-parser-interpretation) | EASY | 1 | 1 | +| 2022-11-05 18:31 | [#1106 解析布尔表达式](https://leetcode.cn/problems/parsing-a-boolean-expression) | HARD | 3 | 1 | +| 2022-11-04 14:12 | [#754 到达终点数字](https://leetcode.cn/problems/reach-a-number) | MEDIUM | 4 | 1 | +| 2022-11-02 20:43 | [#1620 网络信号最好的坐标](https://leetcode.cn/problems/coordinate-with-maximum-network-quality) | MEDIUM | 1 | 1 | +| 2022-11-01 14:49 | [#1662 检查两个字符串数组是否相等](https://leetcode.cn/problems/check-if-two-string-arrays-are-equivalent) | EASY | 1 | 1 | +| 2022-10-31 10:25 | [#481 神奇字符串](https://leetcode.cn/problems/magical-string) | MEDIUM | 4 | 1 | +| 2022-10-29 23:17 | [#1773 统计匹配检索规则的物品数量](https://leetcode.cn/problems/count-items-matching-a-rule) | EASY | 2 | 1 | +| 2022-10-27 10:20 | [#1822 数组元素积的符号](https://leetcode.cn/problems/sign-of-the-product-of-an-array) | EASY | 2 | 1 | +| 2022-10-24 15:37 | [#1235 规划兼职工作](https://leetcode.cn/problems/maximum-profit-in-job-scheduling) | HARD | 7 | **2** | +| 2022-10-24 08:13 | [#915 分割数组](https://leetcode.cn/problems/partition-array-into-disjoint-intervals) | MEDIUM | 3 | 1 | +| 2022-10-23 18:07 | [#1768 交替合并字符串](https://leetcode.cn/problems/merge-strings-alternately) | EASY | 2 | 1 | +| 2022-10-21 10:50 | [#901 股票价格跨度](https://leetcode.cn/problems/online-stock-span) | MEDIUM | 1 | 1 | +| 2022-10-20 21:51 | [#779 第K个语法符号](https://leetcode.cn/problems/k-th-symbol-in-grammar) | MEDIUM | 1 | 1 | +| 2022-10-19 16:47 | [#1700 无法吃午餐的学生数量](https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch) | EASY | 2 | 1 | +| 2022-10-17 12:25 | [#904 水果成篮](https://leetcode.cn/problems/fruit-into-baskets) | MEDIUM | 3 | 1 | +| 2022-10-16 13:16 | [#886 可能的二分法](https://leetcode.cn/problems/possible-bipartition) | MEDIUM | 4 | 1 | +| 2022-10-15 14:16 | [#7 整数反转](https://leetcode.cn/problems/reverse-integer) | MEDIUM | 4 | 1 | +| 2022-10-15 10:09 | [#1441 用栈操作构建数组](https://leetcode.cn/problems/build-an-array-with-stack-operations) | MEDIUM | 4 | 1 | +| 2022-10-14 16:07 | [#940 不同的子序列 II](https://leetcode.cn/problems/distinct-subsequences-ii) | HARD | 6 | 1 | +| 2022-10-13 20:08 | [#769 最多能完成排序的块](https://leetcode.cn/problems/max-chunks-to-make-sorted) | MEDIUM | 2 | 1 | +| 2022-10-12 10:03 | [#817 链表组件](https://leetcode.cn/problems/linked-list-components) | MEDIUM | 6 | 1 | +| 2022-10-11 10:02 | [#1790 仅执行一次字符串交换能否使两个字符串相等](https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal) | EASY | 3 | 1 | +| 2022-10-10 12:24 | [#856 括号的分数](https://leetcode.cn/problems/score-of-parentheses) | MEDIUM | 2 | 1 | +| 2022-10-08 10:54 | [#870 优势洗牌](https://leetcode.cn/problems/advantage-shuffle) | MEDIUM | 2 | 1 | +| 2022-10-07 12:41 | [#1694 重新格式化电话号码](https://leetcode.cn/problems/reformat-phone-number) | EASY | 2 | 1 | +| 2022-10-07 12:16 | [#1800 最大升序子数组和](https://leetcode.cn/problems/maximum-ascending-subarray-sum) | EASY | 3 | 1 | +| 2022-10-05 12:22 | [#811 子域名访问计数](https://leetcode.cn/problems/subdomain-visit-count) | MEDIUM | 1 | 1 | +| 2022-10-04 22:20 | [#921 使括号有效的最少添加](https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid) | MEDIUM | 4 | 1 | +| 2022-09-30 15:12 | [#73 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes) | MEDIUM | 1 | 1 | +| 2022-09-30 14:44 | [#面试题 01.08 零矩阵](https://leetcode.cn/problems/zero-matrix-lcci) | MEDIUM | 2 | 1 | +| 2022-09-29 23:57 | [#面试题 17.09 第 k 个数](https://leetcode.cn/problems/get-kth-magic-number-lcci) | MEDIUM | 3 | 1 | +| 2022-09-29 10:16 | [#面试题 01.09 字符串轮转](https://leetcode.cn/problems/string-rotation-lcci) | EASY | 1 | 1 | +| 2022-09-27 22:47 | [#面试题 01.02 判定是否互为字符重排](https://leetcode.cn/problems/check-permutation-lcci) | EASY | 1 | 1 | +| 2022-09-27 11:35 | [#面试题 17.19 消失的两个数字](https://leetcode.cn/problems/missing-two-lcci) | HARD | 3 | 1 | +| 2022-09-26 15:21 | [#788 旋转数字](https://leetcode.cn/problems/rotated-digits) | MEDIUM | 1 | 1 | +| 2022-09-22 09:45 | [#1640 能否连接形成数组](https://leetcode.cn/problems/check-array-formation-through-concatenation) | EASY | 3 | 1 | +| 2022-09-13 15:55 | [#1608 特殊数组的特征值](https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x) | EASY | 7 | 1 | +| 2022-09-13 15:06 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 7 | 1 | +| 2022-09-09 15:29 | [#1598 文件夹操作日志搜集器](https://leetcode.cn/problems/crawler-log-folder) | EASY | 3 | 1 | +| 2022-09-01 13:48 | [#1475 商品折扣后的最终价格](https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop) | EASY | 1 | 1 | +| 2022-08-31 13:22 | [#946 验证栈序列](https://leetcode.cn/problems/validate-stack-sequences) | MEDIUM | 2 | 1 | +| 2022-08-19 12:44 | [#1450 在既定时间做作业的学生人数](https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time) | EASY | 1 | 1 | +| 2022-08-17 12:14 | [#1302 层数最深叶子节点的和](https://leetcode.cn/problems/deepest-leaves-sum) | MEDIUM | 1 | 1 | +| 2022-08-10 18:34 | [#640 求解方程](https://leetcode.cn/problems/solve-the-equation) | MEDIUM | 4 | 1 | +| 2022-08-01 12:42 | [#1374 生成每种字符都是奇数个的字符串](https://leetcode.cn/problems/generate-a-string-with-characters-that-have-odd-counts) | EASY | 1 | 1 | +| 2022-07-25 14:34 | [#919 完全二叉树插入器](https://leetcode.cn/problems/complete-binary-tree-inserter) | MEDIUM | 1 | 1 | +| 2022-07-23 14:13 | [#LCR 115 序列重建](https://leetcode.cn/problems/ur2n8P) | MEDIUM | 7 | 1 | +| 2022-07-17 11:09 | [#565 数组嵌套](https://leetcode.cn/problems/array-nesting) | MEDIUM | 1 | 1 | +| 2022-07-14 13:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | +| 2022-07-13 19:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | +| 2022-07-11 13:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | +| 2022-07-08 14:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | +| 2022-07-08 13:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | +| 2022-07-07 15:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | +| 2022-07-05 14:13 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 3 | **2** | +| 2022-07-05 11:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | +| 2022-07-04 10:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | +| 2022-07-03 20:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | +| 2022-06-24 13:38 | [#515 在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row) | MEDIUM | 1 | 1 | +| 2022-06-22 14:33 | [#513 找树左下角的值](https://leetcode.cn/problems/find-bottom-left-tree-value) | MEDIUM | 4 | 1 | +| 2022-06-21 19:28 | [#1108 IP 地址无效化](https://leetcode.cn/problems/defanging-an-ip-address) | EASY | 2 | 1 | +| 2022-06-19 23:06 | [#98 验证二叉搜索树](https://leetcode.cn/problems/validate-binary-search-tree) | MEDIUM | 13 | 1 | +| 2022-06-19 15:20 | [#508 出现次数最多的子树元素和](https://leetcode.cn/problems/most-frequent-subtree-sum) | MEDIUM | 2 | 1 | +| 2022-06-18 14:19 | [#LCR 029 循环有序列表的插入](https://leetcode.cn/problems/4ueAj6) | MEDIUM | 15 | 1 | +| 2022-06-17 15:48 | [#1089 复写零](https://leetcode.cn/problems/duplicate-zeros) | EASY | 2 | 1 | +| 2022-06-13 23:05 | [#1051 高度检查器](https://leetcode.cn/problems/height-checker) | EASY | 2 | 1 | +| 2022-06-12 23:05 | [#890 查找和替换模式](https://leetcode.cn/problems/find-and-replace-pattern) | MEDIUM | 1 | 1 | +| 2022-06-05 14:59 | [#478 在圆内随机生成点](https://leetcode.cn/problems/generate-random-point-in-a-circle) | MEDIUM | 8 | 1 | +| 2022-06-04 12:34 | [#929 独特的电子邮件地址](https://leetcode.cn/problems/unique-email-addresses) | EASY | 5 | 1 | +| 2022-05-30 20:32 | [#1022 从根到叶的二进制数之和](https://leetcode.cn/problems/sum-of-root-to-leaf-binary-numbers) | EASY | 3 | 1 | +| 2022-05-28 12:21 | [#1021 删除最外层的括号](https://leetcode.cn/problems/remove-outermost-parentheses) | EASY | 1 | 1 | +| 2022-05-27 17:40 | [#面试题 17.11 单词距离](https://leetcode.cn/problems/find-closest-lcci) | MEDIUM | 2 | 1 | +| 2022-05-24 12:35 | [#965 单值二叉树](https://leetcode.cn/problems/univalued-binary-tree) | EASY | 2 | 1 | +| 2022-05-21 17:47 | [#961 在长度 2N 的数组中找出重复 N 次的元素](https://leetcode.cn/problems/n-repeated-element-in-size-2n-array) | EASY | 2 | 1 | +| 2022-05-20 14:55 | [#436 寻找右区间](https://leetcode.cn/problems/find-right-interval) | MEDIUM | 3 | 1 | +| 2022-05-19 13:50 | [#462 最小操作次数使数组元素相等 II](https://leetcode.cn/problems/minimum-moves-to-equal-array-elements-ii) | MEDIUM | 1 | 1 | +| 2022-05-18 13:08 | [#668 乘法表中第k小的数](https://leetcode.cn/problems/kth-smallest-number-in-multiplication-table) | HARD | 3 | 1 | +| 2022-05-17 11:08 | [#953 验证外星语词典](https://leetcode.cn/problems/verifying-an-alien-dictionary) | EASY | 2 | 1 | +| 2022-05-16 16:08 | [#面试题 04.06 后继者](https://leetcode.cn/problems/successor-lcci) | MEDIUM | 5 | 1 | +| 2022-05-15 14:35 | [#812 最大三角形面积](https://leetcode.cn/problems/largest-triangle-area) | EASY | 4 | 1 | +| 2022-05-13 22:09 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 3 | 1 | +| 2022-05-13 13:28 | [#面试题 01.05 一次编辑](https://leetcode.cn/problems/one-away-lcci) | MEDIUM | 3 | 1 | +| 2022-05-12 21:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | +| 2022-05-10 15:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | +| 2022-05-09 14:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | +| 2022-05-09 14:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | +| 2022-05-09 14:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | +| 2022-05-09 13:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | +| 2022-05-08 10:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | +| 2022-05-07 20:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | +| 2022-05-07 16:37 | [#433 最小基因变化](https://leetcode.cn/problems/minimum-genetic-mutation) | MEDIUM | 3 | 1 | +| 2022-05-06 15:00 | [#113 路径总和 II](https://leetcode.cn/problems/path-sum-ii) | MEDIUM | 1 | 1 | +| 2022-05-06 14:46 | [#933 最近的请求次数](https://leetcode.cn/problems/number-of-recent-calls) | EASY | 1 | 1 | +| 2022-05-05 11:07 | [#713 乘积小于 K 的子数组](https://leetcode.cn/problems/subarray-product-less-than-k) | MEDIUM | 3 | 1 | +| 2022-05-04 12:31 | [#1823 找出游戏的获胜者](https://leetcode.cn/problems/find-the-winner-of-the-circular-game) | MEDIUM | 2 | 1 | +| 2022-05-03 12:37 | [#937 重新排列日志文件](https://leetcode.cn/problems/reorder-data-in-log-files) | MEDIUM | 2 | 1 | +| 2022-05-02 15:00 | [#591 标签验证器](https://leetcode.cn/problems/tag-validator) | HARD | 8 | 1 | +| 2022-05-02 14:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | +| 2022-05-01 17:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | +| 2022-04-30 14:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | +| 2022-04-29 15:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | +| 2022-04-28 12:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | +| 2022-04-26 19:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | +| 2022-04-25 12:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | +| 2022-04-24 13:08 | [#868 二进制间距](https://leetcode.cn/problems/binary-gap) | EASY | 1 | 1 | +| 2022-04-22 15:01 | [#396 旋转函数](https://leetcode.cn/problems/rotate-function) | MEDIUM | 2 | 1 | +| 2022-04-21 13:01 | [#824 山羊拉丁文](https://leetcode.cn/problems/goat-latin) | EASY | 1 | 1 | +| 2022-04-20 14:44 | [#388 文件的最长绝对路径](https://leetcode.cn/problems/longest-absolute-file-path) | MEDIUM | 2 | 1 | +| 2022-04-19 12:26 | [#821 字符的最短距离](https://leetcode.cn/problems/shortest-distance-to-a-character) | EASY | 1 | 1 | +| 2022-04-18 15:36 | [#386 字典序排数](https://leetcode.cn/problems/lexicographical-numbers) | MEDIUM | 2 | 1 | +| 2022-04-17 13:28 | [#819 最常见的单词](https://leetcode.cn/problems/most-common-word) | EASY | 3 | 1 | +| 2022-04-16 12:46 | [#479 最大回文数乘积](https://leetcode.cn/problems/largest-palindrome-product) | HARD | 2 | 1 | +| 2022-04-15 15:05 | [#385 迷你语法分析器](https://leetcode.cn/problems/mini-parser) | MEDIUM | 4 | 1 | +| 2022-04-14 10:21 | [#1672 最富有客户的资产总量](https://leetcode.cn/problems/richest-customer-wealth) | EASY | 1 | 1 | +| 2022-04-13 18:53 | [#380 O(1) 时间插入、删除和获取随机元素](https://leetcode.cn/problems/insert-delete-getrandom-o1) | MEDIUM | 5 | 1 | +| 2022-04-12 10:06 | [#806 写字符串需要的行数](https://leetcode.cn/problems/number-of-lines-to-write-string) | EASY | 1 | 1 | +| 2022-04-11 15:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | +| 2022-04-10 12:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | +| 2022-04-09 18:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | +| 2022-04-08 11:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | +| 2022-04-06 14:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | +| 2022-04-05 15:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | +| 2022-04-03 20:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | +| 2022-04-02 18:50 | [#132 分割回文串 II](https://leetcode.cn/problems/palindrome-partitioning-ii) | HARD | 4 | 1 | +| 2022-04-01 11:41 | [#954 二倍数对数组](https://leetcode.cn/problems/array-of-doubled-pairs) | MEDIUM | 10 | 1 | +| 2022-03-31 12:57 | [#728 自除数](https://leetcode.cn/problems/self-dividing-numbers) | EASY | 1 | 1 | +| 2022-03-30 17:45 | [#1606 找到处理最多请求的服务器](https://leetcode.cn/problems/find-servers-that-handled-most-number-of-requests) | HARD | 6 | 1 | +| 2022-03-29 13:49 | [#2024 考试的最大困扰度](https://leetcode.cn/problems/maximize-the-confusion-of-an-exam) | MEDIUM | 1 | 1 | +| 2022-03-28 14:22 | [#693 交替位二进制数](https://leetcode.cn/problems/binary-number-with-alternating-bits) | EASY | 1 | 1 | +| 2022-03-27 12:46 | [#2028 找出缺失的观测数据](https://leetcode.cn/problems/find-missing-observations) | MEDIUM | 7 | 1 | +| 2022-03-26 15:02 | [#682 棒球比赛](https://leetcode.cn/problems/baseball-game) | EASY | 1 | 1 | +| 2022-03-25 13:23 | [#172 阶乘后的零](https://leetcode.cn/problems/factorial-trailing-zeroes) | MEDIUM | 4 | 1 | +| 2022-03-24 10:20 | [#661 图片平滑器](https://leetcode.cn/problems/image-smoother) | EASY | 1 | 1 | +| 2022-03-23 18:40 | [#440 字典序的第K小数字](https://leetcode.cn/problems/k-th-smallest-in-lexicographical-order) | HARD | 6 | 1 | +| 2022-03-22 12:43 | [#2038 如果相邻两个颜色均相同则删除当前颜色](https://leetcode.cn/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color) | MEDIUM | 3 | 1 | +| 2022-03-21 15:27 | [#653 两数之和 IV - 输入二叉搜索树](https://leetcode.cn/problems/two-sum-iv-input-is-a-bst) | EASY | 1 | 1 | +| 2022-03-20 15:10 | [#2039 网络空闲的时刻](https://leetcode.cn/problems/the-time-when-the-network-becomes-idle) | MEDIUM | 1 | 1 | +| 2022-03-19 15:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | EASY | 3 | 1 | +| 2022-03-18 12:11 | [#2043 简易银行系统](https://leetcode.cn/problems/simple-bank-system) | MEDIUM | 1 | 1 | +| 2022-03-17 14:57 | [#720 词典中最长的单词](https://leetcode.cn/problems/longest-word-in-dictionary) | MEDIUM | 8 | 1 | +| 2022-03-16 19:29 | [#432 全 O(1) 的数据结构](https://leetcode.cn/problems/all-oone-data-structure) | HARD | 4 | 1 | +| 2022-03-15 15:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | +| 2022-03-14 11:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | +| 2022-03-13 16:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | +| 2022-03-12 13:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | +| 2021-09-14 15:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | +| 2021-08-03 13:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | +| 2021-07-30 19:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | +| 2021-07-13 09:53 | [#40 组合总和 II](https://leetcode.cn/problems/combination-sum-ii) | MEDIUM | 3 | 1 | +| 2021-07-13 09:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | +| 2021-07-12 19:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | +| 2021-07-12 18:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | +| 2021-07-06 16:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | +| 2021-07-06 16:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | +| 2021-07-05 15:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | +| 2021-07-05 14:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | +| 2021-07-05 13:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | +| 2021-07-05 13:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | +| 2021-07-05 12:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | +| 2021-07-05 12:30 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 1 | 1 | +| 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | +| 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | +| 2021-06-13 15:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | +| 2021-06-07 19:49 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 1 | 1 | +| 2021-06-04 09:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | +| 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | +| 2021-05-24 11:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | +| 2021-05-22 00:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | +| 2021-05-21 14:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | +| 2021-05-10 15:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | +| 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | +| 2021-05-05 10:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | +| 2021-04-13 18:39 | [#783 二叉搜索树节点最小距离](https://leetcode.cn/problems/minimum-distance-between-bst-nodes) | EASY | 1 | 1 | +| 2021-03-30 13:37 | [#74 搜索二维矩阵](https://leetcode.cn/problems/search-a-2d-matrix) | MEDIUM | 1 | 1 | +| 2021-03-27 22:24 | [#61 旋转链表](https://leetcode.cn/problems/rotate-list) | MEDIUM | 3 | 1 | +| 2021-03-22 18:57 | [#191 位1的个数](https://leetcode.cn/problems/number-of-1-bits) | EASY | 1 | 1 | +| 2020-11-27 20:12 | [#454 四数相加 II](https://leetcode.cn/problems/4sum-ii) | MEDIUM | 5 | 1 | +| 2020-11-25 22:35 | [#1370 上升下降字符串](https://leetcode.cn/problems/increasing-decreasing-string) | EASY | 1 | 1 | +| 2020-10-25 19:58 | [#845 数组中的最长山脉](https://leetcode.cn/problems/longest-mountain-in-array) | MEDIUM | 1 | 1 | +| 2020-10-15 20:52 | [#9 回文数](https://leetcode.cn/problems/palindrome-number) | EASY | 1 | 1 | +| 2020-09-04 13:05 | [#257 二叉树的所有路径](https://leetcode.cn/problems/binary-tree-paths) | EASY | 1 | 1 | +| 2020-08-16 15:28 | [#733 图像渲染](https://leetcode.cn/problems/flood-fill) | EASY | 2 | 1 | +| 2020-08-14 23:14 | [#20 有效的括号](https://leetcode.cn/problems/valid-parentheses) | EASY | 6 | 1 | +| 2020-08-10 14:09 | [#696 计数二进制子串](https://leetcode.cn/problems/count-binary-substrings) | EASY | 4 | 1 | +| 2020-08-08 09:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | +| 2020-08-06 16:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | +| 2020-08-03 20:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | +| 2020-08-02 19:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | +| 2020-07-31 13:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | +| 2020-07-31 13:05 | [#面试题 08.03 魔术索引](https://leetcode.cn/problems/magic-index-lcci) | EASY | 2 | 1 | +| 2020-07-29 10:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | +| 2020-07-28 18:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | +| 2020-07-27 10:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | +| 2020-07-23 15:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | +| 2020-07-23 14:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | +| 2020-07-23 14:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | +| 2020-07-22 21:24 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 4 | 1 | +| 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | +| 2020-07-18 23:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | +| 2020-07-17 16:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | +| 2020-04-22 22:11 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 3 | 1 | From 3a5732636f748dcb8537a0a7eebc0190cc66207f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 21 Sep 2023 15:19:50 +0800 Subject: [PATCH 138/373] =?UTF-8?q?Create=20155.=20=E6=9C=80=E5=B0=8F?= =?UTF-8?q?=E6=A0=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \346\234\200\345\260\217\346\240\210.md" | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 "Stack/155. \346\234\200\345\260\217\346\240\210.md" diff --git "a/Stack/155. \346\234\200\345\260\217\346\240\210.md" "b/Stack/155. \346\234\200\345\260\217\346\240\210.md" new file mode 100644 index 0000000..7b3ae7e --- /dev/null +++ "b/Stack/155. \346\234\200\345\260\217\346\240\210.md" @@ -0,0 +1,88 @@ +#### 155. 最小栈 + +难度：中等 + +--- + +设计一个支持 `push` ，`pop` ，`top` 操作，并能在常数时间内检索到最小元素的栈。 + +实现 `MinStack` 类: + +* `MinStack()` 初始化堆栈对象。 +* `void push(int val)` 将元素val推入堆栈。 +* `void pop()` 删除堆栈顶部的元素。 +* `int top()` 获取堆栈顶部的元素。 +* `int getMin()` 获取堆栈中的最小元素。 + + **示例 1:** + +``` +输入： +["MinStack","push","push","push","getMin","pop","top","getMin"] +[[],[-2],[0],[-3],[],[],[],[]] + +输出： +[null,null,null,null,-3,null,0,-2] + +解释： +MinStack minStack = new MinStack(); +minStack.push(-2); +minStack.push(0); +minStack.push(-3); +minStack.getMin(); --> 返回 -3. +minStack.pop(); +minStack.top(); --> 返回 0. +minStack.getMin(); --> 返回 -2. +``` + + **提示：** + +* `-2^31 <= val <= 2^31 - 1` +* `pop`、`top` 和 `getMin` 操作总是在 **非空栈** 上调用 +* `push`, `pop`, `top`, and `getMin`最多被调用 `3 * 10^4` 次 + +--- + +栈： + +使用辅助栈，其元素的值为原栈中的最小值。在初始化阶段向辅助栈中注入最大值元素，以便空栈情况下的判断。 + +```Java +class MinStack { + + ArrayDeque stack, minStack; + + public MinStack() { + stack = new ArrayDeque<>(); + minStack = new ArrayDeque<>(); + minStack.push(Integer.MAX_VALUE); + } + + public void push(int val) { + stack.push(val); + minStack.push(Math.min(minStack.peek(), val)); + } + + public void pop() { + stack.pop(); + minStack.pop(); + } + + public int top() { + return stack.peek(); + } + + public int getMin() { + return minStack.peek(); + } +} + +/** + * Your MinStack object will be instantiated and called as such: + * MinStack obj = new MinStack(); + * obj.push(val); + * obj.pop(); + * int param_3 = obj.top(); + * int param_4 = obj.getMin(); + */ +``` \ No newline at end of file From e424892483532e9a58caa908c0b37513cf5e7a2f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 21 Sep 2023 15:21:57 +0800 Subject: [PATCH 139/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 63623f3..b21952c 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | | 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | | 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | | 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | @@ -161,7 +162,7 @@ | 2022-11-15 19:11 | [#1710 卡车上的最大单元数](https://leetcode.cn/problems/maximum-units-on-a-truck) | EASY | 2 | 1 | | 2022-11-14 00:19 | [#704 二分查找](https://leetcode.cn/problems/binary-search) | EASY | 10 | **2** | | 2022-11-13 17:37 | [#916 单词子集](https://leetcode.cn/problems/word-subsets) | MEDIUM | 4 | 1 | -| 2022-11-13 15:18 | [#剑指 Offer 51 数组中的逆序对](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | +| 2022-11-13 15:18 | [#LCR 170 交易逆序对的总数](https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof) | HARD | 3 | **3** | | 2022-11-13 13:33 | [#791 自定义字符串排序](https://leetcode.cn/problems/custom-sort-string) | MEDIUM | 2 | 1 | | 2022-11-12 20:54 | [#1339 分裂二叉树的最大乘积](https://leetcode.cn/problems/maximum-product-of-splitted-binary-tree) | MEDIUM | 3 | 1 | | 2022-11-12 14:18 | [#790 多米诺和托米诺平铺](https://leetcode.cn/problems/domino-and-tromino-tiling) | MEDIUM | 4 | 1 | From 27d0813ca044770d55ee4c90c8a96060e94d8c44 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 22 Sep 2023 20:16:17 +0800 Subject: [PATCH 140/373] =?UTF-8?q?Create=2056.=20=E5=90=88=E5=B9=B6?= =?UTF-8?q?=E5=8C=BA=E9=97=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...10\345\271\266\345\214\272\351\227\264.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Methodology/56. \345\220\210\345\271\266\345\214\272\351\227\264.md" diff --git "a/Methodology/56. \345\220\210\345\271\266\345\214\272\351\227\264.md" "b/Methodology/56. \345\220\210\345\271\266\345\214\272\351\227\264.md" new file mode 100644 index 0000000..18795d2 --- /dev/null +++ "b/Methodology/56. \345\220\210\345\271\266\345\214\272\351\227\264.md" @@ -0,0 +1,61 @@ +#### 56. 合并区间 + +难度：中等 + +--- + +以数组 `intervals` 表示若干个区间的集合，其中单个区间为 `intervals[i] = [starti, endi]` 。请你合并所有重叠的区间，并返回 _一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间_ 。 + + **示例 1：** + +``` +输入：intervals = [[1,3],[2,6],[8,10],[15,18]] +输出：[[1,6],[8,10],[15,18]] +解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. +``` + + **示例 2：** + +``` +输入：intervals = [[1,4],[4,5]] +输出：[[1,5]] +解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。 +``` + + **提示：** + +* `1 <= intervals.length <= 10^4` +* `intervals[i].length == 2` +* `0 <= starti <= endi <= 10^4` + +--- + +类似贪心： + +先按左区间排序，接着分三种情况讨论： + +1. 当前的右区间在下一个元素的左区间之前 +2. 当前的右区间在下一个元素的左右区间之间 +3. 当前的右区间在下一个元素的右区间之后 + +更简化的方案是将 List 中最后一个元素的右值与当前元素的左值比较。 + +```Java +class Solution { + public int[][] merge(int[][] intervals) { + Arrays.sort(intervals, (int[] a, int[] b) -> (a[0] - b[0])); + List res = new ArrayList<>(); + int index = 0, n = intervals.length; + while(index < n){ + int start = intervals[index][0], end = intervals[index][1]; + if(res.size() == 0 || res.get(res.size() - 1)[1] < start){ + res.add(new int[]{start, end}); + } else { + res.get(res.size() - 1)[1] = Math.max(res.get(res.size() - 1)[1], end); + } + index++; + } + return res.toArray(new int[res.size()][2]); + } +} +``` \ No newline at end of file From 8e75adb8eecf62dfa2383e02f8ef909e301e04da Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 22 Sep 2023 20:18:37 +0800 Subject: [PATCH 141/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b21952c..f8545a7 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-22 19:56 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 2 | 1 | | 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | | 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | | 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | From e92423e2f2d6b1aa2525e53d0c0a1be636973a46 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 26 Sep 2023 08:57:47 +0800 Subject: [PATCH 142/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index f8545a7..45f74b1 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | | 2023-09-22 19:56 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 2 | 1 | | 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | | 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | From 4450206ea1af7f85c12ad4d7fd2168d598c582e1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Oct 2023 18:22:45 +0800 Subject: [PATCH 143/373] =?UTF-8?q?Create=20121.=20=E4=B9=B0=E5=8D=96?= =?UTF-8?q?=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BA?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\275\263\346\227\266\346\234\272.md" | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 "Dynamic Programming/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" diff --git "a/Dynamic Programming/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/Dynamic Programming/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" new file mode 100644 index 0000000..2f9a130 --- /dev/null +++ "b/Dynamic Programming/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" @@ -0,0 +1,53 @@ +#### 121. 买卖股票的最佳时机 + +难度：简单 + +--- + +给定一个数组 `prices` ，它的第 `i` 个元素 `prices[i]` 表示一支给定股票第 `i` 天的价格。 + +你只能选择 **某一天** 买入这只股票，并选择在 **未来的某一个不同的日子** 卖出该股票。设计一个算法来计算你所能获取的最大利润。 + +返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 `0` 。 + + **示例 1：** + +``` +输入：[7,1,5,3,6,4] +输出：5 +解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 + 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 +``` + + **示例 2：** + +``` +输入：prices = [7,6,4,3,1] +输出：0 +解释：在这种情况下, 没有交易完成, 所以最大利润为 0。 +``` + + **提示：** + +* `1 <= prices.length <= 10^5` +* `0 <= prices[i] <= 10^4` + +--- + +动态规划： + +一次遍历。遍历的过程中更新最小值，`dp[i]` 表示第 `i` 天卖出股票的利润，值为当前价格减去最小值，最后取最小值的最大值即可。 + +```Java +class Solution { + public int maxProfit(int[] prices) { + int n = prices.length, minn = prices[0]; + int[] dp = new int[n]; + for(int i = 0; i < n; i++){ + minn = Math.min(minn, prices[i]); + dp[i] = prices[i] - minn; + } + return Arrays.stream(dp).max().getAsInt(); + } +} +``` \ No newline at end of file From 210286fb34a91053a78fbd297bef4ecdf3a7b60d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Oct 2023 18:22:49 +0800 Subject: [PATCH 144/373] =?UTF-8?q?Create=20122.=20=E4=B9=B0=E5=8D=96?= =?UTF-8?q?=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BA?= =?UTF-8?q?=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...344\275\263\346\227\266\346\234\272 II.md" | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 "Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" diff --git "a/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" "b/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" new file mode 100644 index 0000000..0326111 --- /dev/null +++ "b/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" @@ -0,0 +1,62 @@ +#### 122. 买卖股票的最佳时机 II + +难度：中等 + +--- + +给你一个整数数组 `prices` ，其中 `prices[i]` 表示某支股票第 `i` 天的价格。 + +在每一天，你可以决定是否购买和/或出售股票。你在任何时候  **最多**  只能持有 **一股** 股票。你也可以先购买，然后在 **同一天** 出售。 + +返回 _你能获得的 **最大** 利润_ 。 + + **示例 1：** + +``` +输入：prices = [7,1,5,3,6,4] +输出：7 +解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 +  随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。 + 总利润为 4 + 3 = 7 。 +``` + + **示例 2：** + +``` +输入：prices = [1,2,3,4,5] +输出：4 +解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 +  总利润为 4 。 +``` + + **示例 3：** + +``` +输入：prices = [7,6,4,3,1] +输出：0 +解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。 +``` + + **提示：** + +* `1 <= prices.length <= 3 * 10^4` +* `0 <= prices[i] <= 10^4` + +--- + +动态规划： + +一次遍历。`dp[i]` 表示从第一天到第 `i + 1` 天内的最大利润（并不意味着第 `i + 1` 天卖出股票），其值要么是上一个值，要么是上一个值加上**当前价格与昨天价格的差**（这样做的原因是题目中允许当天购买和出售），最后返回数组最后一位值即可。 + +```Java +class Solution { + public int maxProfit(int[] prices) { + int n = prices.length; + int[] dp = new int[n]; + for(int i = 1; i < n; i++){ + dp[i] = Math.max(dp[i - 1], dp[i - 1] + prices[i] - prices[i - 1]); // 状态转移方程 + } + return dp[n - 1]; + } +} +``` \ No newline at end of file From b0eb76ecd8a8dc4b8218d7a65e39bd85e2540abd Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Oct 2023 20:05:48 +0800 Subject: [PATCH 145/373] Update README.md --- Dynamic Programming/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Dynamic Programming/README.md b/Dynamic Programming/README.md index 9585582..8c28c5a 100644 --- a/Dynamic Programming/README.md +++ b/Dynamic Programming/README.md @@ -2,6 +2,6 @@ 一维状态转移函数分以下两种情况： -- `dp[i]` 表示以第 i 个数组结尾的最大/小情况。一定是包含当前第 i 个数组的情况。而求解 `dp[i]` 往往需要向前遍历查找符合情况的 `dp` 数组，数组长度一般为 `n`，最后的结果是遍历 `dp` 数组，取数组的最大/小值。 +- `dp[i]` 表示以第 i 个数组结尾的最大/小情况。一定是包含当前第 i 个数组的情况。而求解 `dp[i]` 往往需要向前遍历查找符合情况的 `dp` 数组，数组长度一般为 `n`，最后的结果是遍历 `dp` 数组，取数组的最大/小值。例如，[121. 买卖股票的最佳时机](./121.%20买卖股票的最佳时机.md)。 -- `dp[i]` 表示前 i 个数组的最大/小情况。不一定是包含当前第 i 个数组的情况。数组长度一般为 `n + 1`，最后的结果一定是 `dp[n]` \ No newline at end of file +- `dp[i]` 表示前 i 个数组的最大/小情况。不一定是包含当前第 i 个数组的情况。数组长度一般为 `n + 1`，最后的结果一定是 `dp[n]`。例如，[122. 买卖股票的最佳时机 II.md](./122.%20买卖股票的最佳时机%20II.md)。 \ No newline at end of file From a86dedf8658cfc313adb0fcd79bd52d131a2305f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Oct 2023 20:05:50 +0800 Subject: [PATCH 146/373] =?UTF-8?q?Create=20309.=20=E4=B9=B0=E5=8D=96?= =?UTF-8?q?=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BA?= =?UTF-8?q?=E5=90=AB=E5=86=B7=E5=86=BB=E6=9C=9F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...53\345\206\267\345\206\273\346\234\237.md" | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 "Dynamic Programming/309. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" diff --git "a/Dynamic Programming/309. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" "b/Dynamic Programming/309. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" new file mode 100644 index 0000000..d5315fc --- /dev/null +++ "b/Dynamic Programming/309. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" @@ -0,0 +1,87 @@ +#### 309. 买卖股票的最佳时机含冷冻期 + +难度：中等 + +--- + +给定一个整数数组`prices`，其中第  `prices[i]` 表示第 `_i_` 天的股票价格 。​ + +设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: + +* 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 + + **注意：** 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 + + **示例 1:** + +``` +输入: prices = [1,2,3,0,2] +输出: 3 +解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出] +``` + + **示例 2:** + +``` +输入: prices = [1] +输出: 0 +``` + + **提示：** + +* `1 <= prices.length <= 5000` +* `0 <= prices[i] <= 1000` + +--- + +多维动态规划： + +一共有三种状态： + +- `dp[i][0]`: 不持股且当天不卖出，若要达到这种状态，则有两种情况，前一天的股票**不卖出或者卖出**，即 `dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1])`。 +- `dp[i][1]`: 不持股且当天卖出，若要达到这种状态，只有一种情况，就是前一天股票持有的情况下的最大收益加上今天股票的价格，即 `dp[i][1] = dp[i - 1][2] + prices[i]`。 +- `dp[i][2]`: 持股，若要达到这种状态，有可能是**前一天持股的最大收益或者今天买入**，即 `dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][0] - prices[i])`。 + +```Java +// 思路： +// 考虑有多少种状态，每种状态有哪些选择，或者是做了哪些选择后得到哪种状态。 +// 注意：到底是先选择了才有状态，还是先由状态才能选择。这里是先选择了，才有状态 + +// 状态类型有2种：天数和是否持有。 +// 天数：一共为1-n天 +// 是否持有：分为持有状态、没持有状态1、没持有状态2。 +// 持有状态：选择 无处理 和 买入 都有可能达到该状态 +// 没持有状态1：选择 无处理 后达到该状态。 +// 没持有状态2：选择 卖出 后达到该状态。注意，卖出后进入一天的冻结期。 +// 注意：这里为什么要分两种没持有状态，这是为了便于后续状态转移，如果不区分这两种状态，状态转移没法确定当天是否可以进行买入操作。 + +// dp表示的含义： +// dp[i][2] : 第i天为没持有状态2时，此时的最大利润 +// dp[i][1] : 第i天为没持有状态1时，此时的最大利润 +// dp[i][0] ： 第i天为持有状态时，此时的最大利润 +// 状态转移方程： +// dp[i][0]: 第i天为持有状态时，此时的最大利润 +// 无处理后达到该状态： dp[i][0] = dp[i-1][0] // 第i天没有处理就持有股票，证明上一天也持有 +// 买入后达到该状态： dp[i][0] = dp[i-1][1]-prices[n] // 第i天能买入股票，证明上一天没持有股票，且没进行卖出操作 +// 所以dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[n]); // 这里思考个问题，两种情况都能到达这个状态的话，那如何选择？为什么是取他们的max？ +// dp[i][1]: 第i天为没持有状态1时，此时的最大利润 +// 无处理后达到该状态： dp[i][1] = max(dp[i-1][1], dp[i-1][2]) // 有两种到达该状态的情况，取最大那个 +// dp[i][2]: 第i天为没持有状态2时，此时的最大利润 +// 卖出后达到该状态： dp[i][2] = dp[i-1][0]+prices[i] + +// 最后max(dp[n-1][1], dp[n-1][2])就是题目所需答案。即第n-1天没持有股票时的最大收益 +//======================================================================================= +class Solution { + public int maxProfit(int[] prices) { + int n = prices.length; + int[][] dp = new int[n][3]; + dp[0][2] = -1 * prices[0]; // dp[i][0]: 不持股且当天不卖出; dp[i][1]: 不持股且当天卖出; dp[i][2]: 持股 + for(int i = 1; i < n; i++){ + dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]); + dp[i][1] = dp[i - 1][2] + prices[i]; + dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][0] - prices[i]); + } + return Math.max(dp[n - 1][0], dp[n - 1][1]); + } +} +``` \ No newline at end of file From 56eb3773570db85dceb7356b45d6d01bee0b1e98 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Oct 2023 20:09:19 +0800 Subject: [PATCH 147/373] Update changes --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 45f74b1..55ac154 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | +| 2023-10-05 18:14 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 1 | 1 | +| 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | | 2023-09-22 19:56 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 2 | 1 | | 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | From 675c7f7eb4d117a9bbaf50584e029857e8ffd6ed Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 11 Oct 2023 10:15:55 +0800 Subject: [PATCH 148/373] =?UTF-8?q?Create=202512.=20=E5=A5=96=E5=8A=B1?= =?UTF-8?q?=E6=9C=80=E9=A1=B6=E5=B0=96=E7=9A=84=20K=20=E5=90=8D=E5=AD=A6?= =?UTF-8?q?=E7=94=9F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...K \345\220\215\345\255\246\347\224\237.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Hash Table/2512. \345\245\226\345\212\261\346\234\200\351\241\266\345\260\226\347\232\204 K \345\220\215\345\255\246\347\224\237.md" diff --git "a/Hash Table/2512. \345\245\226\345\212\261\346\234\200\351\241\266\345\260\226\347\232\204 K \345\220\215\345\255\246\347\224\237.md" "b/Hash Table/2512. \345\245\226\345\212\261\346\234\200\351\241\266\345\260\226\347\232\204 K \345\220\215\345\255\246\347\224\237.md" new file mode 100644 index 0000000..f24d27c --- /dev/null +++ "b/Hash Table/2512. \345\245\226\345\212\261\346\234\200\351\241\266\345\260\226\347\232\204 K \345\220\215\345\255\246\347\224\237.md" @@ -0,0 +1,82 @@ +#### 2512. 奖励最顶尖的 K 名学生 + +难度：中等 + +--- + +给你两个字符串数组 `positive_feedback` 和 `negative_feedback` ，分别包含表示正面的和负面的词汇。 **不会**  有单词同时是正面的和负面的。 + +一开始，每位学生分数为 `0` 。每个正面的单词会给学生的分数 **加**  `3` 分，每个负面的词会给学生的分数 **减**   `1` 分。 + +给你 `n` 个学生的评语，用一个下标从 **0**  开始的字符串数组 `report` 和一个下标从 **0**  开始的整数数组 `student_id` 表示，其中 `student_id[i]` 表示这名学生的 ID ，这名学生的评语是 `report[i]` 。每名学生的 ID **互不相同** 。 + +给你一个整数 `k` ，请你返回按照得分  **从高到低**  最顶尖的 `k` 名学生。如果有多名学生分数相同，ID 越小排名越前。 + + **示例 1：** + +``` +输入：positive_feedback = ["smart","brilliant","studious"], negative_feedback = ["not"], report = ["this student is studious","the student is smart"], student_id = [1,2], k = 2 +输出：[1,2] +解释： +两名学生都有 1 个正面词汇，都得到 3 分，学生 1 的 ID 更小所以排名更前。 +``` + + **示例 2：** + +``` +输入：positive_feedback = ["smart","brilliant","studious"], negative_feedback = ["not"], report = ["this student is not studious","the student is smart"], student_id = [1,2], k = 2 +输出：[2,1] +解释： +- ID 为 1 的学生有 1 个正面词汇和 1 个负面词汇，所以得分为 3-1=2 分。 +- ID 为 2 的学生有 1 个正面词汇，得分为 3 分。 +学生 2 分数更高，所以返回 [2,1] 。 +``` + + **提示：** + +* `1 <= positive_feedback.length, negative_feedback.length <= 10^4` +* `1 <= positive_feedback[i].length, negative_feedback[j].length <= 100` +* `positive_feedback[i]` 和 `negative_feedback[j]` 都只包含小写英文字母。 +* `positive_feedback` 和 `negative_feedback` 中不会有相同单词。 +* `n == report.length == student_id.length` +* `1 <= n <= 10^4` +* `report[i]` 只包含小写英文字母和空格 `' '` 。 +* `report[i]` 中连续单词之间有单个空格隔开。 +* `1 <= report[i].length <= 100` +* `1 <= student_id[i] <= 10^9` +* `student_id[i]` 的值 **互不相同**  。 +* `1 <= k <= n` + +--- + +哈希表 + 排序： + +将每个正面单词和负面单词存入**哈希表**中并分别赋予 `3` 和 `-1` 的分数，将每个同学的报告用 `split()` 方法拆分成单词并计算分数，最后排序选取前 `k` 个即可。 + +```Java +class Solution { + public List topStudents(String[] positive_feedback, String[] negative_feedback, String[] report, int[] student_id, int k) { + HashMap hashmap = new HashMap<>(); + for(String word: positive_feedback){ + hashmap.put(word, 3); + } + for(String word: negative_feedback){ + hashmap.put(word, -1); + } + int n = report.length; + int[][] array = new int[n][2]; + for(int i = 0; i < n; i++){ + for(String word: report[i].split(" ")){ + array[i][0] += hashmap.getOrDefault(word, 0); + array[i][1] = student_id[i]; + } + } + Arrays.sort(array, (int[] a, int[] b) -> (a[0] == b[0] ? a[1] - b[1] : b[0] - a[0])); + List ans = new ArrayList<>(); + for(int i = 0; i < k; i++){ + ans.add(array[i][1]); + } + return ans; + } +} +``` \ No newline at end of file From 55426f6f8c5ffcff29858791b2b27c5e102e6b86 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 11 Oct 2023 10:18:32 +0800 Subject: [PATCH 149/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 55ac154..25fe31c 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 18:14 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | From be262af4eff424b699a214a9f94dde319a290bf8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 23 Oct 2023 20:26:36 +0800 Subject: [PATCH 150/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 25fe31c..7ad74a1 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 18:14 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 1 | 1 | From c306e4d348e862ce8106d15064a8b9ef7b5ac110 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 23 Oct 2023 23:03:44 +0800 Subject: [PATCH 151/373] =?UTF-8?q?Create=20141.=20=E7=8E=AF=E5=BD=A2?= =?UTF-8?q?=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...57\345\275\242\351\223\276\350\241\250.md" | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 "Linked List/141. \347\216\257\345\275\242\351\223\276\350\241\250.md" diff --git "a/Linked List/141. \347\216\257\345\275\242\351\223\276\350\241\250.md" "b/Linked List/141. \347\216\257\345\275\242\351\223\276\350\241\250.md" new file mode 100644 index 0000000..c11f9dd --- /dev/null +++ "b/Linked List/141. \347\216\257\345\275\242\351\223\276\350\241\250.md" @@ -0,0 +1,83 @@ +#### 141. 环形链表 + +难度：简单 + +--- + +给你一个链表的头节点 `head` ，判断链表中是否有环。 + +如果链表中有某个节点，可以通过连续跟踪 `next` 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置（索引从 0 开始）。 **注意：`pos` 不作为参数进行传递**  。仅仅是为了标识链表的实际情况。 + +_如果链表中存在环_ ，则返回 `true` 。 否则，返回 `false` 。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist.png) + +``` +输入：head = [3,2,0,-4], pos = 1 +输出：true +解释：链表中有一个环，其尾部连接到第二个节点。 +``` + + **示例 2：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png) + +``` +输入：head = [1,2], pos = 0 +输出：true +解释：链表中有一个环，其尾部连接到第一个节点。 +``` + + **示例 3：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png) + +``` +输入：head = [1], pos = -1 +输出：false +解释：链表中没有环。 +``` + + **提示：** + +* 链表中节点的数目范围是 `[0, 10^4]` +* `-10^5 <= Node.val <= 10^5` +* `pos` 为 `-1` 或者链表中的一个 **有效索引** 。 + + **进阶：** 你能用 `O(1)`（即，常量）内存解决此问题吗？ + +--- + +快慢指针： + +慢指针每次移动一个节点，快指针每次移动两个节点。 + +快指针总是先于慢指针的遍历。因此在循环中只需要判断快指针及其下一节点是否为空即可，否则如果存在环，快指针总会遇到慢指针。 + +```Java +/** + * Definition for singly-linked list. + * class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { + * val = x; + * next = null; + * } + * } + */ +public class Solution { + public boolean hasCycle(ListNode head) { + if(head == null || head.next == null) return false; + ListNode slow = head, fast = head.next; + while(slow != fast){ + if(fast == null || fast.next == null) return false; + slow = slow.next; + fast = fast.next.next; + } + return true; + } +} +``` \ No newline at end of file From 94d1fa17af5b94a88bb883bf297ba4ebace3a847 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 23 Oct 2023 23:03:46 +0800 Subject: [PATCH 152/373] =?UTF-8?q?Create=20142.=20=E7=8E=AF=E5=BD=A2?= =?UTF-8?q?=E9=93=BE=E8=A1=A8=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...345\275\242\351\223\276\350\241\250 II.md" | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 "Linked List/142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md" diff --git "a/Linked List/142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md" "b/Linked List/142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md" new file mode 100644 index 0000000..93ce2c1 --- /dev/null +++ "b/Linked List/142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md" @@ -0,0 +1,99 @@ +#### 142. 环形链表 II + +难度：中等 + +--- + +给定一个链表的头节点  `head` ，返回链表开始入环的第一个节点。 _如果链表无环，则返回 `null`。_ + +如果链表中有某个节点，可以通过连续跟踪 `next` 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 `pos` 来表示链表尾连接到链表中的位置（ **索引从 0 开始** ）。如果 `pos` 是 `-1`，则在该链表中没有环。 **注意：`pos` 不作为参数进行传递** ，仅仅是为了标识链表的实际情况。 + + **不允许修改** 链表。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png) + +``` +输入：head = [3,2,0,-4], pos = 1 +输出：返回索引为 1 的链表节点 +解释：链表中有一个环，其尾部连接到第二个节点。 +``` + + **示例 2：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png) + +``` +输入：head = [1,2], pos = 0 +输出：返回索引为 0 的链表节点 +解释：链表中有一个环，其尾部连接到第一个节点。 +``` + + **示例 3：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png) + +``` +输入：head = [1], pos = -1 +输出：返回 null +解释：链表中没有环。 +``` + + **提示：** + +* 链表中节点的数目范围在范围 `[0, 10^4]` 内 +* `-10^5 <= Node.val <= 10^5` +* `pos` 的值为 `-1` 或者链表中的一个有效索引 + + **进阶：** 你是否可以使用 `O(1)` 空间解决此题？ + +--- + +快慢指针： + +![](https://raw.githubusercontent.com/CompetitiveLin/ImageHostingService/picgo/imgs/202310232256747.png) + +快指针走过的路程永远是慢指针的两倍，根据这个性质得到以下公式： +$$ +a + n * (b + c) + b = 2 * (a + b) +$$ +化简后为 +$$ +a = (n - 1) * (b + c) + c +$$ +可以发现 $(b + c)$ 恰好为环的长度，那么意味着从链表头部到入环的距离（$a$）恰好等于从相遇点到入环点的距离（$c$）再加上 $n-1$ 圈个环的长度。**当快慢指针相遇后，再定义一个指针指向链表起点，一次走一步，`slow` 指针也同步继续往后走，那么这两个指针就一定会在链表的入口位置相遇。** + +```Java +/** + * Definition for singly-linked list. + * class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { + * val = x; + * next = null; + * } + * } + */ +public class Solution { + public ListNode detectCycle(ListNode head) { + if(head == null || head.next == null) return null; + ListNode slow = head, fast = head; + while(fast != null && fast.next != null){ + slow = slow.next; + fast = fast.next.next; + if(slow == fast){ + ListNode ans = head; + while(slow != ans){ + slow = slow.next; + ans = ans.next; + } + return ans; + } + + } + return null; + } +} +``` \ No newline at end of file From 325148ab22284f1820dd7117a87e84f39c9e42b8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 23 Oct 2023 23:06:40 +0800 Subject: [PATCH 153/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7ad74a1..9dc63cd 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-10-23 22:55 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 2 | **2** | | 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | @@ -69,7 +70,6 @@ | 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | | 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | | 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | -| 2023-05-12 22:56 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 1 | 1 | | 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | | 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | | 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | From 62ec0bb53955a294a50bbfecfa3df345773ca450 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 27 Oct 2023 10:28:20 +0800 Subject: [PATCH 154/373] =?UTF-8?q?Create=201465.=20=E5=88=87=E5=89=B2?= =?UTF-8?q?=E5=90=8E=E9=9D=A2=E7=A7=AF=E6=9C=80=E5=A4=A7=E7=9A=84=E8=9B=8B?= =?UTF-8?q?=E7=B3=95.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...47\347\232\204\350\233\213\347\263\225.md" | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 "Greedy/1465. \345\210\207\345\211\262\345\220\216\351\235\242\347\247\257\346\234\200\345\244\247\347\232\204\350\233\213\347\263\225.md" diff --git "a/Greedy/1465. \345\210\207\345\211\262\345\220\216\351\235\242\347\247\257\346\234\200\345\244\247\347\232\204\350\233\213\347\263\225.md" "b/Greedy/1465. \345\210\207\345\211\262\345\220\216\351\235\242\347\247\257\346\234\200\345\244\247\347\232\204\350\233\213\347\263\225.md" new file mode 100644 index 0000000..64981f6 --- /dev/null +++ "b/Greedy/1465. \345\210\207\345\211\262\345\220\216\351\235\242\347\247\257\346\234\200\345\244\247\347\232\204\350\233\213\347\263\225.md" @@ -0,0 +1,74 @@ +#### 1465. 切割后面积最大的蛋糕 + +难度：中等 + +--- + +矩形蛋糕的高度为 `h` 且宽度为 `w`，给你两个整数数组 `horizontalCuts` 和 `verticalCuts`，其中： + +*  `horizontalCuts[i]` 是从矩形蛋糕顶部到第  `i` 个水平切口的距离 +* `verticalCuts[j]` 是从矩形蛋糕的左侧到第 `j` 个竖直切口的距离 + +请你按数组 _`horizontalCuts`_ 和 _`verticalCuts`_ 中提供的水平和竖直位置切割后，请你找出 **面积最大** 的那份蛋糕，并返回其 **面积** 。由于答案可能是一个很大的数字，因此需要将结果  **对**  `10^9 + 7`  **取余** 后返回。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/leetcode_max_area_2.png) + +``` +输入：h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3] +输出：4 +解释：上图所示的矩阵蛋糕中，红色线表示水平和竖直方向上的切口。切割蛋糕后，绿色的那份蛋糕面积最大。 +``` + + **示例 2：** + + **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/05/30/leetcode_max_area_3.png)** + +``` +输入：h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1] +输出：6 +解释：上图所示的矩阵蛋糕中，红色线表示水平和竖直方向上的切口。切割蛋糕后，绿色和黄色的两份蛋糕面积最大。 +``` + + **示例 3：** + +``` +输入：h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3] +输出：9 +``` + + **提示：** + +* `2 <= h, w <= 10^9` +* `1 <= horizontalCuts.length <= min(h - 1, 10^5)` +* `1 <= verticalCuts.length <= min(w - 1, 10^5)` +* `1 <= horizontalCuts[i] < h` +* `1 <= verticalCuts[i] < w` +* 题目数据保证 `horizontalCuts` 中的所有元素各不相同 +* 题目数据保证 `verticalCuts` 中的所有元素各不相同 + +--- + +贪心： + +取横轴和纵轴的最大值并相乘即可，注意相乘后的结果可能越界，所以先转换为 `long` 类型再取余。 + +```Java +class Solution { + public int maxArea(int h, int w, int[] horizontalCuts, int[] verticalCuts) { + Arrays.sort(horizontalCuts); + Arrays.sort(verticalCuts); + return (int) ((long) calculate(horizontalCuts, h) * calculate(verticalCuts, w) % 1000000007); + } + + private int calculate(int[] cuts, int length){ + int pre = 0, res = 0; + for(int cut: cuts){ + res = Math.max(res, cut - pre); + pre = cut; + } + return Math.max(res, length - pre); + } +} +``` \ No newline at end of file From 0d9ca3611ee75b18350d3dcad8de58a860a2db94 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 27 Oct 2023 10:30:34 +0800 Subject: [PATCH 155/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9dc63cd..c8bb47b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-10-27 10:26 | [#1465 切割后面积最大的蛋糕](https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts) | MEDIUM | 2 | 1 | | 2023-10-23 22:55 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 2 | **2** | | 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | From f57cd88fda2cc06a85de8a9365666adafc193d65 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Thu, 2 Nov 2023 10:34:36 +0800 Subject: [PATCH 156/373] =?UTF-8?q?Create=20153.=20=E5=AF=BB=E6=89=BE?= =?UTF-8?q?=E6=97=8B=E8=BD=AC=E6=8E=92=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=B0=8F=E5=80=BC.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\346\234\200\345\260\217\345\200\274.md" | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 "Dichotomy/153. \345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.md" diff --git "a/Dichotomy/153. \345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.md" "b/Dichotomy/153. \345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.md" new file mode 100644 index 0000000..38bada2 --- /dev/null +++ "b/Dichotomy/153. \345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.md" @@ -0,0 +1,77 @@ +#### 153. 寻找旋转排序数组中的最小值 + +难度：中等 + +--- + +已知一个长度为 `n` 的数组，预先按照升序排列，经由 `1` 到 `n` 次 **旋转** 后，得到输入数组。例如，原数组 `nums = [0,1,2,4,5,6,7]` 在变化后可能得到： + +* 若旋转 `4` 次，则可以得到 `[4,5,6,7,0,1,2]` +* 若旋转 `7` 次，则可以得到 `[0,1,2,4,5,6,7]` + +注意，数组 `[a[0], a[1], a[2], ..., a[n-1]]` **旋转一次** 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]` 。 + +给你一个元素值 **互不相同** 的数组 `nums` ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 **最小元素** 。 + +你必须设计一个时间复杂度为 `O(log n)` 的算法解决此问题。 + + **示例 1：** + +``` +输入：nums = [3,4,5,1,2] +输出：1 +解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。 +``` + + **示例 2：** + +``` +输入：nums = [4,5,6,7,0,1,2] +输出：0 +解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。 +``` + + **示例 3：** + +``` +输入：nums = [11,13,15,17] +输出：11 +解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。 +``` + + **提示：** + +* `n == nums.length` +* `1 <= n <= 5000` +* `-5000 <= nums[i] <= 5000` +* `nums` 中的所有整数 **互不相同** +* `nums` 原来是一个升序排序的数组，并进行了 `1` 至 `n` 次旋转 + +--- + +二分查找： + +考虑以下三种情况 + +1. 左值 < 中值, 中值 < 右值 ：没有旋转，最小值在最左边，可以收缩右边界 +2. 左值 > 中值, 中值 < 右值 ：有旋转，最小值在左半边，可以收缩右边界 +3. 左值 < 中值, 中值 > 右值 ：有旋转，最小值在右半边，可以收缩左边界 + +因此选择中值与右值比较。 + +```Java +class Solution { + public int findMin(int[] nums) { + int left = 0, right = nums.length - 1; + while(left < right){ + int mid = (right + left) / 2; + if(nums[mid] < nums[right]){ + right = mid; + } else { + left = mid + 1; + } + } + return nums[left]; + } +} +``` \ No newline at end of file From 04abb17944283c42f57f892ecc4ddca6910961d1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 2 Nov 2023 11:57:05 +0800 Subject: [PATCH 157/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c8bb47b..361befc 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-02 10:23 | [#153 寻找旋转排序数组中的最小值](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2023-10-27 10:26 | [#1465 切割后面积最大的蛋糕](https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts) | MEDIUM | 2 | 1 | | 2023-10-23 22:55 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 2 | **2** | | 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | From be6aa15271f7d6adc450e58b4703bc66d002d0c5 Mon Sep 17 00:00:00 2001 From: survive Date: Thu, 2 Nov 2023 12:30:34 +0800 Subject: [PATCH 158/373] Update leetcode.py --- leetcode.py | 26 +++++++++++--------------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/leetcode.py b/leetcode.py index c33da60..cf028e6 100644 --- a/leetcode.py +++ b/leetcode.py @@ -24,14 +24,8 @@ def login(LEETCODE_SESSION): session.mount('http://', HTTPAdapter(max_retries=6)) # 超时重试次数 session.mount('https://', HTTPAdapter(max_retries=6)) # 超时重试次数 session.encoding = "utf-8" # 编码格式 - session.cookies.set('LEETCODE_SESSION', LEETCODE_SESSION) - is_login = session.cookies.get('LEETCODE_SESSION') != None - if is_login: - print("登录成功!") - return session - else: - raise Exception("登录失败, 请检查COOKIE是否正确或过期!") + return session # 获取某个题目的提交记录 @@ -90,16 +84,16 @@ def get_accepted_problems(session): r = session.post(url, data=payload, headers=headers, verify=False) response_data = json.loads(r.text) - return response_data + return response_data['data']['userProfileQuestions'] # 生成Markdown文本 def generate_markdown_text(response_data, session): - + response_data = response_data['questions'] + # 相关介绍 - response_data = response_data['data']['userProfileQuestions']['questions'] markdown_text = "## 相关介绍\n\n" markdown_text += "这是一个 [LeetCode](https://leetcode.cn/problemset/all/) 题目自动统计及分析程序，可自动统计所有提交通过的题目，并以 Markdown 的形式展示。\n\n" markdown_text += "根据个人需求，目前只考虑获取**提交次数**和**重刷次数**这两个指标，以便更好地进行刷题。\n\n" @@ -168,8 +162,10 @@ def generate_markdown_text(response_data, session): if __name__ == '__main__': session = login(sys.argv[1]) # 登录，参数为已登录 LeetCode 账号的浏览器中 Cookie 名为 LEETCODE_SESSION 的值 response_data = get_accepted_problems(session) # 获取所有通过的题目列表 - markdown_text = generate_markdown_text(response_data, session) # 生成Markdown文本 - - # 更新README.md文件 - with open("README.md", "w") as f: - f.write(markdown_text) + if response_data: + markdown_text = generate_markdown_text(response_data, session) # 生成Markdown文本 + # 更新README.md文件 + with open("README.md", "w") as f: + f.write(markdown_text) + else: + raise Exception("Cookies 已过期，请更新 LEETCODE_SESSION") From 5778905a4d4c599f80a35961bf16e370cb2a21d7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 4 Nov 2023 16:09:35 +0800 Subject: [PATCH 159/373] =?UTF-8?q?Update=2047.=20=E5=85=A8=E6=8E=92?= =?UTF-8?q?=E5=88=97=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" "b/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" index 36671d6..48f8d8a 100644 --- "a/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" +++ "b/Backtrace/47. \345\205\250\346\216\222\345\210\227 II.md" @@ -49,7 +49,7 @@ class Solution { return; } for(int i = 0; i < nums.length; i++){ - if(visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1])){ // 去重 + if(visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i] && visited[i - 1])){ // 去重 continue; } visited[i] = true; From a0aec62578dd375003a7ada9213ca28f1f47c100 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 4 Nov 2023 16:13:03 +0800 Subject: [PATCH 160/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 361befc..84ecdfa 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-04 16:08 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 5 | **4** | +| 2023-11-04 15:45 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 7 | **5** | | 2023-11-02 10:23 | [#153 寻找旋转排序数组中的最小值](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2023-10-27 10:26 | [#1465 切割后面积最大的蛋糕](https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts) | MEDIUM | 2 | 1 | | 2023-10-23 22:55 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 2 | **2** | @@ -47,11 +49,9 @@ | 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | -| 2023-09-01 17:41 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 6 | **4** | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | | 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | -| 2023-08-13 13:24 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 3 | **3** | | 2023-08-10 20:25 | [#784 字母大小写全排列](https://leetcode.cn/problems/letter-case-permutation) | MEDIUM | 7 | **3** | | 2023-07-16 12:33 | [#1679 K 和数对的最大数目](https://leetcode.cn/problems/max-number-of-k-sum-pairs) | MEDIUM | 1 | 1 | | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | From 5b65253862c321a39bd21c16dab039b8cab37f79 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 9 Nov 2023 20:14:45 +0800 Subject: [PATCH 161/373] =?UTF-8?q?Create=20151.=20=E5=8F=8D=E8=BD=AC?= =?UTF-8?q?=E5=AD=97=E7=AC=A6=E4=B8=B2=E4=B8=AD=E7=9A=84=E5=8D=95=E8=AF=8D?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...55\347\232\204\345\215\225\350\257\215.md" | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 "Two Pointers/151. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" diff --git "a/Two Pointers/151. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" "b/Two Pointers/151. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" new file mode 100644 index 0000000..d0cdd5b --- /dev/null +++ "b/Two Pointers/151. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" @@ -0,0 +1,70 @@ +#### 151. 反转字符串中的单词 + +难度：中等 + +--- + +给你一个字符串 `s` ，请你反转字符串中 **单词** 的顺序。 + + **单词** 是由非空格字符组成的字符串。`s` 中使用至少一个空格将字符串中的 **单词** 分隔开。 + +返回 **单词** 顺序颠倒且 **单词** 之间用单个空格连接的结果字符串。 + + **注意：** 输入字符串 `s`中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。 + + **示例 1：** + +``` +输入：s = "the sky is blue" +输出："blue is sky the" +``` + + **示例 2：** + +``` +输入：s = "  hello world  " +输出："world hello" +解释：反转后的字符串中不能存在前导空格和尾随空格。 +``` + + **示例 3：** + +``` +输入：s = "a good   example" +输出："example good a" +解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。 +``` + + **提示：** + +* `1 <= s.length <= 10^4` +* `s` 包含英文大小写字母、数字和空格 `' '` +* `s` 中 **至少存在一个** 单词 + + **进阶：** 如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 `O(1)` 额外空间复杂度的 **原地** 解法。 + +--- + +双指针： + +第一个指针指向单词**首字母的前一位**，第二个指向**单词尾字母**。两个指针分别是在空格和非空格时移动。 + +```Java +class Solution { + public String reverseWords(String s) { + int i = s.length() - 1, j = i; + StringBuilder sb = new StringBuilder(); + while(i >= 0){ + while(i >= 0 && s.charAt(i) == ' '){ + i--; + j = i; + } + while(i >= 0 && s.charAt(i) != ' '){ + i--; + } + sb.append(s.substring(i + 1, j + 1) + " "); + } + return sb.toString().trim(); + } +} +``` \ No newline at end of file From 0a4a034a21e9b90ee98575bf091421a8f8657849 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 9 Nov 2023 20:17:58 +0800 Subject: [PATCH 162/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 84ecdfa..946be5d 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-09 15:01 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 2 | 1 | | 2023-11-04 16:08 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 5 | **4** | | 2023-11-04 15:45 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 7 | **5** | | 2023-11-02 10:23 | [#153 寻找旋转排序数组中的最小值](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array) | MEDIUM | 1 | 1 | From f8e7836c108df0593ff8a6e32f1c094951ac9399 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 10 Nov 2023 22:13:51 +0800 Subject: [PATCH 163/373] =?UTF-8?q?Create=20114.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E5=B1=95=E5=BC=80=E4=B8=BA=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\270\272\351\223\276\350\241\250.md" | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 "Linked List/114. \344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.md" diff --git "a/Linked List/114. \344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.md" "b/Linked List/114. \344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.md" new file mode 100644 index 0000000..e740ee9 --- /dev/null +++ "b/Linked List/114. \344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.md" @@ -0,0 +1,83 @@ +#### 114. 二叉树展开为链表 + +难度：中等 + +--- + +给你二叉树的根结点 `root` ，请你将它展开为一个单链表： + +* 展开后的单链表应该同样使用 `TreeNode` ，其中 `right` 子指针指向链表中下一个结点，而左子指针始终为 `null` 。 +* 展开后的单链表应该与二叉树 [ **先序遍历** ](https://baike.baidu.com/item/%E5%85%88%E5%BA%8F%E9%81%8D%E5%8E%86/6442839?fr=aladdin) 顺序相同。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg) +``` +输入：root = [1,2,5,3,4,null,6] +输出：[1,null,2,null,3,null,4,null,5,null,6] +``` + + **示例 2：** + +``` +输入：root = [] +输出：[] +``` + + **示例 3：** + +``` +输入：root = [0] +输出：[0] +``` + + **提示：** + +* 树中结点数在范围 `[0, 2000]` 内 +* `-100 <= Node.val <= 100` + + **进阶：** 你可以使用原地算法（`O(1)` 额外空间）展开这棵树吗？ + +--- + +链表的先序遍历：主要分为以下几步 + +1. 左子树插入到右子树 +2. 将原来的右子树接到左子树的最右边节点 +3. 考虑新的右子树的根节点，重复步骤 1，直到新的右子树为 null + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public void flatten(TreeNode root) { + while(root != null){ + if(root.left == null){ + root = root.right; + } else { + TreeNode temp = root.left; + while(temp.right != null){ + temp = temp.right; + } + temp.right = root.right; + root.right = root.left; + root.left = null; + root = root.right; + } + } + } +} +``` \ No newline at end of file From 0b3b63e48d99081d70e4ecf22fce8c926cac7d8e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 10 Nov 2023 22:23:26 +0800 Subject: [PATCH 164/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 946be5d..986cc42 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | | 2023-11-09 15:01 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 2 | 1 | | 2023-11-04 16:08 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 5 | **4** | | 2023-11-04 15:45 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 7 | **5** | @@ -367,7 +368,6 @@ | 2020-08-08 09:45 | [#99 恢复二叉搜索树](https://leetcode.cn/problems/recover-binary-search-tree) | MEDIUM | 1 | 1 | | 2020-08-06 16:44 | [#495 提莫攻击](https://leetcode.cn/problems/teemo-attacking) | EASY | 2 | 1 | | 2020-08-03 20:36 | [#415 字符串相加](https://leetcode.cn/problems/add-strings) | EASY | 6 | 1 | -| 2020-08-02 19:45 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 1 | 1 | | 2020-07-31 13:43 | [#面试题 17.01 不用加号的加法](https://leetcode.cn/problems/add-without-plus-lcci) | EASY | 1 | 1 | | 2020-07-31 13:05 | [#面试题 08.03 魔术索引](https://leetcode.cn/problems/magic-index-lcci) | EASY | 2 | 1 | | 2020-07-29 10:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | From b7621463fc7d3dba08ef837679da9d1c137bd6c1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 13 Nov 2023 19:27:30 +0800 Subject: [PATCH 165/373] =?UTF-8?q?Create=201234.=20=E6=9B=BF=E6=8D=A2?= =?UTF-8?q?=E5=AD=90=E4=B8=B2=E5=BE=97=E5=88=B0=E5=B9=B3=E8=A1=A1=E5=AD=97?= =?UTF-8?q?=E7=AC=A6=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...41\345\255\227\347\254\246\344\270\262.md" | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 "Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" diff --git "a/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" "b/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" new file mode 100644 index 0000000..72da5a6 --- /dev/null +++ "b/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" @@ -0,0 +1,94 @@ +#### 1234. 替换子串得到平衡字符串 + +难度：中等 + +--- + +有一个只含有 `'Q', 'W', 'E', 'R'` 四种字符，且长度为 `n` 的字符串。 + +假如在该字符串中，这四个字符都恰好出现 `n/4` 次，那么它就是一个「平衡字符串」。 + +给你一个这样的字符串 `s`，请通过「替换一个子串」的方式，使原字符串 `s` 变成一个「平衡字符串」。 + +你可以用和「待替换子串」长度相同的  **任何** 其他字符串来完成替换。 + +请返回待替换子串的最小可能长度。 + +如果原字符串自身就是一个平衡字符串，则返回 `0`。 + + **示例 1：** + +``` +输入：s = "QWER" +输出：0 +解释：s 已经是平衡的了。 +``` + + **示例 2：** + +``` +输入：s = "QQWE" +输出：1 +解释：我们需要把一个 'Q' 替换成 'R'，这样得到的 "RQWE" (或 "QRWE") 是平衡的。 +``` + + **示例 3：** + +``` +输入：s = "QQQW" +输出：2 +解释：我们可以把前面的 "QQ" 替换成 "ER"。 +``` + + **示例 4：** + +``` +输入：s = "QQQQ" +输出：3 +解释：我们可以替换后 3 个 'Q'，使 s = "QWER"。 +``` + + **提示：** + +* `1 <= s.length <= 10^5` +* `s.length` 是 `4` 的倍数 +* `s` 中只含有 `'Q'`, `'W'`, `'E'`, `'R'` 四种字符 + +--- + +滑动窗口： + +滑动窗口范围为 `[left, right]`，搜索**待替换子串**的步骤： + +1. 如果窗口内的子串不是“合法”子串，移动右边界扩大范围 +2. 如果窗口内的子串是“合法”子串，移动左边界缩小范围 + +此处的“合法”定义为**存在一个字符出现的次数大于 `n/4`**。相反，“不合法”为**所有字符出现的次数均小于 `n/4`**。 + +```Java +class Solution { + public int balancedString(String s) { + int n = s.length(), m = n >> 2, ans = n; + int[] count = new int['Z']; + for(int i = 0; i < n; i++){ + count[s.charAt(i)]++; + } + if(check(count, m)) return 0; + int left = 0, right = 0; + while(right < n){ + count[s.charAt(right)]--; + while(check(count, m)){ + ans = Math.min(ans, right - left + 1); + count[s.charAt(left++)]++; + } + right++; + } + return ans; + } + + public boolean check(int[] count, int m){ + return count['Q'] <= m && count['W'] <= m && count['E'] <= m && count['R'] <= m; + } + +} +``` \ No newline at end of file From fcc5494895c80250620ce7251b4fca1bc55e6263 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 13 Nov 2023 19:30:06 +0800 Subject: [PATCH 166/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 986cc42..3018251 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | | 2023-11-09 15:01 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 2 | 1 | | 2023-11-04 16:08 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 5 | **4** | From 38c11063de3b3666bfb363d0372370148d4d553c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 13 Nov 2023 20:27:02 +0800 Subject: [PATCH 167/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3018251..d49da08 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | | 2023-11-09 15:01 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 2 | 1 | @@ -236,7 +237,6 @@ | 2022-07-08 14:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | | 2022-07-08 13:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | | 2022-07-07 15:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | -| 2022-07-05 14:13 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 3 | **2** | | 2022-07-05 11:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | | 2022-07-04 10:40 | [#1200 最小绝对差](https://leetcode.cn/problems/minimum-absolute-difference) | EASY | 2 | 1 | | 2022-07-03 20:08 | [#556 下一个更大元素 III](https://leetcode.cn/problems/next-greater-element-iii) | MEDIUM | 1 | 1 | From 7e9bd7100cb988f7ee6878b61e7b2d8a2667f663 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 14 Nov 2023 20:26:04 +0800 Subject: [PATCH 168/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d49da08..46a463b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-14 19:54 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 1 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | From 93efa46f2522973ad61ced831cb44c93078d6655 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 25 Nov 2023 15:36:35 +0800 Subject: [PATCH 169/373] =?UTF-8?q?Create=20138.=20=E9=9A=8F=E6=9C=BA?= =?UTF-8?q?=E9=93=BE=E8=A1=A8=E7=9A=84=E5=A4=8D=E5=88=B6.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...50\347\232\204\345\244\215\345\210\266.md" | 115 ++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 "Hash Table/138. \351\232\217\346\234\272\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" diff --git "a/Hash Table/138. \351\232\217\346\234\272\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" "b/Hash Table/138. \351\232\217\346\234\272\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" new file mode 100644 index 0000000..7082102 --- /dev/null +++ "b/Hash Table/138. \351\232\217\346\234\272\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" @@ -0,0 +1,115 @@ +#### 138. 随机链表的复制 + +难度：中等 + +--- + +给你一个长度为 `n` 的链表，每个节点包含一个额外增加的随机指针 `random` ，该指针可以指向链表中的任何节点或空节点。 + +构造这个链表的  **[深拷贝](https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin)** 。 深拷贝应该正好由 `n` 个 **全新** 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。 **复制链表中的指针都不应指向原链表中的节点** 。 + +例如，如果原链表中有 `X` 和 `Y` 两个节点，其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ，同样有 `x.random --> y` 。 + +返回复制链表的头节点。 + +用一个由 `n` 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 `[val, random_index]` 表示： + +* `val`：一个表示 `Node.val` 的整数。 +* `random_index`：随机指针指向的节点索引（范围从 `0` 到 `n-1`）；如果不指向任何节点，则为  `null` 。 + +你的代码 **只** 接受原链表的头节点 `head` 作为传入参数。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e1.png) + +``` +输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]] +输出：[[7,null],[13,0],[11,4],[10,2],[1,0]] +``` + + **示例 2：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e2.png) + +``` +输入：head = [[1,1],[2,1]] +输出：[[1,1],[2,1]] +``` + + **示例 3：** + + **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/01/09/e3.png)** + +``` +输入：head = [[3,null],[3,0],[3,null]] +输出：[[3,null],[3,0],[3,null]] +``` + + **提示：** + +* `0 <= n <= 1000` +* `-10^4 <= Node.val <= 10^4` +* `Node.random` 为 `null` 或指向链表中的节点。 + +--- + +哈希表： + +利用哈希表的查询特点，考虑构建 **原链表节点** 和 **新链表对应节点** 的键值对映射关系，再遍历构建新链表各节点的 `next` 和 `random` 引用指向即可。共两次遍历。 + +```java +/* +// Definition for a Node. +class Node { + int val; + Node next; + Node random; + + public Node(int val) { + this.val = val; + this.next = null; + this.random = null; + } +} +*/ +// 迭代 +class Solution { + + public Node copyRandomList(Node head) { + if(head == null) return null; + HashMap hashmap = new HashMap<>(); + Node temp = head; + while(temp != null){ + hashmap.put(temp, new Node(temp.val)); + temp = temp.next; + } + temp = head; + while(temp != null){ + hashmap.get(temp).next = hashmap.get(temp.next); + hashmap.get(temp).random = hashmap.get(temp.random); + temp = temp.next; + } + return hashmap.get(head); + } +} + +// 递归 +class Solution { + + HashMap hashmap = new HashMap<>(); + + public Node copyRandomList(Node head) { + if(head == null){ + return null; + } + if(!hashmap.containsKey(head)){ + Node node = new Node(head.val); + hashmap.put(head, node); + node.next = copyRandomList(head.next); + node.random = copyRandomList(head.random); + } + return hashmap.get(head); + } +} +``` \ No newline at end of file From cbc521a91864b5d3b590bc004c1e6287c11dd457 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 25 Nov 2023 15:39:11 +0800 Subject: [PATCH 170/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 46a463b..c82ab7e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-14 19:54 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 1 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | From 157baaebe91c704942d126553a46e153f916fd35 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 25 Nov 2023 16:33:30 +0800 Subject: [PATCH 171/373] =?UTF-8?q?Create=2092.=20=E5=8F=8D=E8=BD=AC?= =?UTF-8?q?=E9=93=BE=E8=A1=A8=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...350\275\254\351\223\276\350\241\250 II.md" | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 "Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" diff --git "a/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" "b/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" new file mode 100644 index 0000000..c66714b --- /dev/null +++ "b/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" @@ -0,0 +1,121 @@ +#### 92. 反转链表 II + +难度：中等 + +--- + +给你单链表的头指针 `head` 和两个整数 `left` 和 `right` ，其中 `left <= right` 。请你反转从位置 `left` 到位置 `right` 的链表节点，返回 **反转后的链表** 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg) +``` +输入：head = [1,2,3,4,5], left = 2, right = 4 +输出：[1,4,3,2,5] +``` + + **示例 2：** + +``` +输入：head = [5], left = 1, right = 1 +输出：[5] +``` + + **提示：** + +* 链表中节点数目为 `n` +* `1 <= n <= 500` +* `-500 <= Node.val <= 500` +* `1 <= left <= right <= n` + + **进阶：** 你可以使用一趟扫描完成反转吗？ + +--- + +法一：确定反转的窗口后再使用最普通的反转链表的方法。 + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode reverseBetween(ListNode head, int left, int right) { + + ListNode dummy = new ListNode(-1), pre = dummy; + dummy.next = head; + for(int i = 0; i < left - 1; i++){ + pre = pre.next; + } + ListNode rightNode = pre; + for(int i = 0; i < right - left + 1; i++){ + rightNode = rightNode.next; + } + ListNode leftNode = pre.next; + pre.next = null; + ListNode post = rightNode.next; + rightNode.next = null; + + reverse(leftNode); + + pre.next = rightNode; + leftNode.next = post; + return dummy.next; + } + + public void reverse(ListNode head){ + ListNode pre = null; + while(head != null){ + ListNode nextNode = head.next; + head.next = pre; + pre = head; + head = nextNode; + } + } + +} +``` + +--- + +法二：一遍遍历，固定 `pre` 节点，移动 `right - left` 次 `curr` 和 `next` 节点。 + +![image.png](https://pic.leetcode-cn.com/1615105296-bmiPxl-image.png) + +```java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode reverseBetween(ListNode head, int left, int right) { + ListNode dummy = new ListNode(-1); + dummy.next = head; + ListNode pre = dummy; + for(int i = 0; i < left - 1; i++){ + pre = pre.next; + } + ListNode cur = pre.next, next; + for(int i = 0; i < right - left; i++){ + next = cur.next; + cur.next = next.next; + next.next = pre.next; + pre.next = next; + } + return dummy.next; + } +} +``` + From 34eb69cc55baf5a06210212afc3a790c26a72e14 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 25 Nov 2023 16:36:01 +0800 Subject: [PATCH 172/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c82ab7e..89ea2eb 100644 --- a/README.md +++ b/README.md @@ -26,8 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | | 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | -| 2023-11-14 19:54 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 1 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | From 24e964af0bf6185c77b121d0c0ee9917ccbe2149 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 1 Dec 2023 20:26:37 +0800 Subject: [PATCH 173/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 89ea2eb..d04f49b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | +| 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | | 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | | 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | From 843fe2f51ea65d934b54c6ee7870ce74191ad8a4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 2 Dec 2023 09:41:53 +0800 Subject: [PATCH 174/373] =?UTF-8?q?Create=20287.=20=E5=AF=BB=E6=89=BE?= =?UTF-8?q?=E9=87=8D=E5=A4=8D=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...76\351\207\215\345\244\215\346\225\260.md" | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 "Methodology/287. \345\257\273\346\211\276\351\207\215\345\244\215\346\225\260.md" diff --git "a/Methodology/287. \345\257\273\346\211\276\351\207\215\345\244\215\346\225\260.md" "b/Methodology/287. \345\257\273\346\211\276\351\207\215\345\244\215\346\225\260.md" new file mode 100644 index 0000000..5b24ef8 --- /dev/null +++ "b/Methodology/287. \345\257\273\346\211\276\351\207\215\345\244\215\346\225\260.md" @@ -0,0 +1,67 @@ +#### 287. 寻找重复数 + +难度：中等 + +--- + +给定一个包含 `n + 1` 个整数的数组 `nums` ，其数字都在 `[1, n]` 范围内（包括 `1` 和 `n`），可知至少存在一个重复的整数。 + +假设 `nums` 只有 **一个重复的整数** ，返回  **这个重复的数** 。 + +你设计的解决方案必须 **不修改** 数组 `nums` 且只用常量级 `O(1)` 的额外空间。 + + **示例 1：** + +``` +输入：nums = [1,3,4,2,2] +输出：2 +``` + + **示例 2：** + +``` +输入：nums = [3,1,3,4,2] +输出：3 +``` + + **提示：** + +* `1 <= n <= 10^5` +* `nums.length == n + 1` +* `1 <= nums[i] <= n` +* `nums` 中 **只有一个整数** 出现 **两次或多次** ，其余整数均只出现 **一次** + +**进阶：** + +* 如何证明 `nums` 中至少存在一个重复的数字? +* 你可以设计一个线性级时间复杂度 `O(n)` 的解决方案吗？ + +--- + +类似于环形链表找环的入口： + +以 `[1, 3, 4, 2, 2]` 为例，由下标对应到值有一层映射关系，即 `0 -> 1, 1 -> 3, 2 ->4, 3 -> 2, 4 -> 2`，将其串成一串得到下图： + + + +![](https://pic.leetcode-cn.com/999e055b41e499d9ac704abada4a1b8e6697374fdfedc17d06b0e8aa10a8f8f6-287.png) + +再利用快慢指针遍历该链表，可以得到快慢指针交界处，再初始化第三个指针为头位置，该指针与交界处的指针移动同样的距离即可得到环形链表入口处。 + +```Java +class Solution { + public int findDuplicate(int[] nums) { + int slow = 0, fast = 0; + do{ + slow = nums[slow]; + fast = nums[nums[fast]]; + }while(slow != fast); + int cur = 0; + while(cur != slow){ + cur = nums[cur]; + slow = nums[slow]; + } + return cur; + } +} +``` \ No newline at end of file From e5ed8ae53912ae599f3a33db17d672ed946b5daf Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Sat, 2 Dec 2023 11:22:25 +0800 Subject: [PATCH 175/373] =?UTF-8?q?Create=202661.=20=E6=89=BE=E5=87=BA?= =?UTF-8?q?=E5=8F=A0=E6=B6=82=E5=85=83=E7=B4=A0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\346\266\202\345\205\203\347\264\240.md" | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 "Hash Table/2661. \346\211\276\345\207\272\345\217\240\346\266\202\345\205\203\347\264\240.md" diff --git "a/Hash Table/2661. \346\211\276\345\207\272\345\217\240\346\266\202\345\205\203\347\264\240.md" "b/Hash Table/2661. \346\211\276\345\207\272\345\217\240\346\266\202\345\205\203\347\264\240.md" new file mode 100644 index 0000000..1a1843e --- /dev/null +++ "b/Hash Table/2661. \346\211\276\345\207\272\345\217\240\346\266\202\345\205\203\347\264\240.md" @@ -0,0 +1,68 @@ +#### 2661. 找出叠涂元素 + +难度：中等 + +--- + +给你一个下标从 **0** 开始的整数数组 `arr` 和一个 `m x n` 的整数 **矩阵** `mat` 。`arr` 和 `mat` 都包含范围 `[1，m * n]` 内的 **所有** 整数。 + +从下标 `0` 开始遍历 `arr` 中的每个下标 `i` ，并将包含整数 `arr[i]` 的 `mat` 单元格涂色。 + +请你找出 `arr` 中在 `mat` 的某一行或某一列上都被涂色且下标最小的元素，并返回其下标 `i` 。 + + **示例 1：** + +![image explanation for example 1](https://assets.leetcode.com/uploads/2023/01/18/grid1.jpg) +``` +输入：arr = [1,3,4,2], mat = [[1,4],[2,3]] +输出：2 +解释：遍历如上图所示，arr[2] 在矩阵中的第一行或第二列上都被涂色。 +``` + + **示例 2：** + +![image explanation for example 2](https://assets.leetcode.com/uploads/2023/01/18/grid2.jpg) +``` +输入：arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]] +输出：3 +解释：遍历如上图所示，arr[3] 在矩阵中的第二列上都被涂色。 +``` + + **提示：** + +* `m == mat.length` +* `n = mat[i].length` +* `arr.length == m * n` +* `1 <= m, n <= 10^5` +* `1 <= m * n <= 10^5` +* `1 <= arr[i], mat[r][c] <= m * n` +* `arr` 中的所有整数 **互不相同** +* `mat` 中的所有整数 **互不相同** + +--- + +哈希表： + +因为矩阵中的每个数都不一样，因此用哈希表记录每个数的坐标。接着遍历涂色的数组，从哈希表中取出当前值的坐标。用一个长度为 `m` 的数组记录每一行被涂色的个数，长度为 `n` 的数组记录每一列被涂色的个数。若当前行被涂色的个数为 `n` 或当前列被涂色的个数为 `m` 时，意味着已经涂满当前行或列。 + +```Java +class Solution { + public int firstCompleteIndex(int[] arr, int[][] mat) { + int m = mat.length, n = mat[0].length; + HashMap hashmap = new HashMap<>(); + for(int i = 0; i < m; i++){ + for(int j = 0; j < n; j++){ + hashmap.put(mat[i][j], new int[]{i, j}); + } + } + int[] rowCount = new int[m], columnCount = new int[n]; + for(int i = 0; i < m * n; i++){ + int[] temp = hashmap.get(arr[i]); + if(++rowCount[temp[0]] == n || ++columnCount[temp[1]] == m){ + return i; + } + } + return -1; + } +} +``` \ No newline at end of file From 419bfe99e9fb73377899e8735c816c6c92e1c0d0 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Sat, 2 Dec 2023 12:03:01 +0800 Subject: [PATCH 176/373] =?UTF-8?q?Create=201094.=20=E6=8B=BC=E8=BD=A6.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../1094. \346\213\274\350\275\246.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Methodology/1094. \346\213\274\350\275\246.md" diff --git "a/Methodology/1094. \346\213\274\350\275\246.md" "b/Methodology/1094. \346\213\274\350\275\246.md" new file mode 100644 index 0000000..d59f26b --- /dev/null +++ "b/Methodology/1094. \346\213\274\350\275\246.md" @@ -0,0 +1,61 @@ +#### 1094. 拼车 + +难度：中等 + +--- + +车上最初有 `capacity` 个空座位。车  **只能**  向一个方向行驶（也就是说， **不允许掉头或改变方向** ） + +给定整数 `capacity` 和一个数组 `trips` ,  `trip[i] = [numPassengersi, fromi, toi]` 表示第 `i` 次旅行有 `numPassengersi` 乘客，接他们和放他们的位置分别是 `fromi` 和 `toi` 。这些位置是从汽车的初始位置向东的公里数。 + +当且仅当你可以在所有给定的行程中接送所有乘客时，返回 `true`，否则请返回 `false`。 + + **示例 1：** + +``` +输入：trips = [[2,1,5],[3,3,7]], capacity = 4 +输出：false +``` + + **示例 2：** + +``` +输入：trips = [[2,1,5],[3,3,7]], capacity = 5 +输出：true +``` + + **提示：** + +* `1 <= trips.length <= 1000` +* `trips[i].length == 3` +* `1 <= numPassengersi <= 100` +* `0 <= fromi < toi <= 1000` +* `1 <= capacity <= 10^5` + +--- + +差分数组： + +初始化一个长度为 `1001` 的差分数组，遍历 `trips` 数组并确定最大长度，上车位置处增加 `numPassengers_i` ，下车位置处减少 `numPassengers_i`，再遍历一遍该差分数组，遍历的过程中如果数组和大于 `capacity`，证明超载，返回 `false`，否则遍历完成后返回` true`。 + +```Java +class Solution { + public boolean carPooling(int[][] trips, int capacity) { + int maxLength = 1001; + int[] arrays = new int[maxLength]; + for(int i = 0; i < trips.length; i++){ + arrays[trips[i][1]] += trips[i][0]; + arrays[trips[i][2]] -= trips[i][0]; + maxLength = Math.max(maxLength, trips[i][2]); + } + int count = 0; + for(int i = 0; i < maxLength; i++){ + count += arrays[i]; + if(count > capacity){ + return false; + } + } + return true; + } +} +``` \ No newline at end of file From ed931d6a3693715b6602dd8bfaf717d6d3b532b2 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 2 Dec 2023 12:05:06 +0800 Subject: [PATCH 177/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d04f49b..3d386a4 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | | 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | From 732ef90c86ad93a9ffd8f71ab2510eff860de8a5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 2 Dec 2023 20:23:29 +0800 Subject: [PATCH 178/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3d386a4..ca4f0bf 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | @@ -129,7 +130,6 @@ | 2023-01-05 20:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | | 2023-01-05 19:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | | 2023-01-03 15:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | -| 2023-01-01 19:08 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 2 | 1 | | 2022-12-31 10:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | | 2022-12-19 14:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | | 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | From 69d2f45317732617a675542bbbd4adcf0f70996f Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Sun, 3 Dec 2023 10:51:33 +0800 Subject: [PATCH 179/373] =?UTF-8?q?Create=201423.=20=E5=8F=AF=E8=8E=B7?= =?UTF-8?q?=E5=BE=97=E7=9A=84=E6=9C=80=E5=A4=A7=E7=82=B9=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\244\247\347\202\271\346\225\260.md" | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 "Sliding Window/1423. \345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\347\202\271\346\225\260.md" diff --git "a/Sliding Window/1423. \345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\347\202\271\346\225\260.md" "b/Sliding Window/1423. \345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\347\202\271\346\225\260.md" new file mode 100644 index 0000000..dc86ac5 --- /dev/null +++ "b/Sliding Window/1423. \345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\347\202\271\346\225\260.md" @@ -0,0 +1,87 @@ +#### 1423. 可获得的最大点数 + +难度：中等 + +--- + +几张卡牌 **排成一行** ，每张卡牌都有一个对应的点数。点数由整数数组 `cardPoints` 给出。 + +每次行动，你可以从行的开头或者末尾拿一张卡牌，最终你必须正好拿 `k` 张卡牌。 + +你的点数就是你拿到手中的所有卡牌的点数之和。 + +给你一个整数数组 `cardPoints` 和整数 `k`，请你返回可以获得的最大点数。 + + **示例 1：** + +``` +输入：cardPoints = [1,2,3,4,5,6,1], k = 3 +输出：12 +解释：第一次行动，不管拿哪张牌，你的点数总是 1 。但是，先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌，最终点数为 1 + 6 + 5 = 12 。 +``` + + **示例 2：** + +``` +输入：cardPoints = [2,2,2], k = 2 +输出：4 +解释：无论你拿起哪两张卡牌，可获得的点数总是 4 。 +``` + + **示例 3：** + +``` +输入：cardPoints = [9,7,7,9,7,7,9], k = 7 +输出：55 +解释：你必须拿起所有卡牌，可以获得的点数为所有卡牌的点数之和。 +``` + + **示例 4：** + +``` +输入：cardPoints = [1,1000,1], k = 1 +输出：1 +解释：你无法拿到中间那张卡牌，所以可以获得的最大点数为 1 。 +``` + + **示例 5：** + +``` +输入：cardPoints = [1,79,80,1,1,1,200,1], k = 3 +输出：202 +``` + + **提示：** + +* `1 <= cardPoints.length <= 10^5` +* `1 <= cardPoints[i] <= 10^4` +* `1 <= k <= cardPoints.length` + +--- + +滑动窗口： + +两种做法，第一种是求中间**连续的** `n-k` 张卡牌的最小值；第二种是扩展原数组使其头尾拼接，求中间**连续** `k` 张卡牌的最大值。 + +无论是哪种做法，都需要求滑动窗口的最值（最小或最大）。**滑动窗口在移动时，每向右移动一格，增加从右侧进入窗口的元素值，并减少从左侧离开窗口的元素值。** + +```Java +class Solution { + public int maxScore(int[] cardPoints, int k) { + int n = cardPoints.length; + int[] temp = new int[2 * n]; + System.arraycopy(cardPoints, 0, temp, 0, n); + System.arraycopy(cardPoints, 0, temp, n, n); + int cur = 0; + for(int i = 0; i < k; i++){ + cur += temp[n - k + i]; + } + int res = cur; + for(int i = 0; i < k; i++){ + cur += temp[n + i] - temp[n - k + i]; + res = Math.max(res, cur); + } + return res; + } +} +``` \ No newline at end of file From 37e010d27a3b8f4b068516eaf99deec567004798 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 3 Dec 2023 10:54:00 +0800 Subject: [PATCH 180/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ca4f0bf..d0a86d1 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | | 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | From b7aaaa562614ad68dcd9af53561092577155899d Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Tue, 5 Dec 2023 20:04:22 +0800 Subject: [PATCH 181/373] =?UTF-8?q?Create=2053.=20=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E5=AD=90=E6=95=B0=E7=BB=84=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...20\346\225\260\347\273\204\345\222\214.md" | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 "Dynamic Programming/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" diff --git "a/Dynamic Programming/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" "b/Dynamic Programming/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" new file mode 100644 index 0000000..4131ccc --- /dev/null +++ "b/Dynamic Programming/53. \346\234\200\345\244\247\345\255\220\346\225\260\347\273\204\345\222\214.md" @@ -0,0 +1,68 @@ +#### 53. 最大子数组和 + +难度：中等 + +--- + +给你一个整数数组 `nums` ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 + + **子数组** 是数组中的一个连续部分。 + + **示例 1：** + +``` +输入：nums = [-2,1,-3,4,-1,2,1,-5,4] +输出：6 +解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 +``` + + **示例 2：** + +``` +输入：nums = [1] +输出：1 +``` + + **示例 3：** + +``` +输入：nums = [5,4,-1,7,8] +输出：23 +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `-10^4 <= nums[i] <= 10^4` + + **进阶：** 如果你已经实现复杂度为 `O(n)` 的解法，尝试使用更为精妙的 **分治法** 求解。 + +--- + +动态规划： + +本次可直接在原数组上做修改。 + +状态定义：`dp[i]` 表示以 `nums[i]` 为结尾的连续子数组最大和。 + +状态转移方程为： +$$ +dp[i] = \left\{ \begin{array}{rcl} +&dp[i - 1] + nums[i],& dp[i - 1]>0 \\ +&nums[i], & dp[i - 1]\le0 +\end{array}\right. +$$ +类似多次求前缀和。当某一项的前缀和小于零时，下一项开始重新求前缀和。 + +```Java +class Solution { + public int maxSubArray(int[] nums) { + int res = nums[0]; + for(int i = 1; i < nums.length; i++){ + nums[i] += Math.max(nums[i - 1], 0); + res = Math.max(res, nums[i]); + } + return res; + } +} +``` \ No newline at end of file From 39c9fc92c125481e6020727fe3a816ba89be9129 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 5 Dec 2023 20:15:32 +0800 Subject: [PATCH 182/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d0a86d1..41b91bb 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-05 19:53 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 3 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | | 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | @@ -59,7 +60,6 @@ | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | -| 2023-09-10 10:57 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 2 | 1 | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | | 2023-08-25 09:49 | [#83 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list) | EASY | 3 | 1 | From be0e261348021b120abd403638672f8767864577 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 6 Dec 2023 11:28:29 +0800 Subject: [PATCH 183/373] =?UTF-8?q?Create=203.=20=E6=97=A0=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E5=AD=97=E7=AC=A6=E7=9A=84=E6=9C=80=E9=95=BF=E5=AD=90?= =?UTF-8?q?=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\351\225\277\345\255\220\344\270\262.md" | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 "Sliding Window/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" diff --git "a/Sliding Window/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/Sliding Window/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" new file mode 100644 index 0000000..55517f8 --- /dev/null +++ "b/Sliding Window/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" @@ -0,0 +1,59 @@ +#### 3. 无重复字符的最长子串 + +难度：中等 + +--- + +给定一个字符串 `s` ，请你找出其中不含有重复字符的  **最长子串**  的长度。 + + **示例 1:** + +``` +输入: s = "abcabcbb" +输出: 3 +解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。 +``` + + **示例 2:** + +``` +输入: s = "bbbbb" +输出: 1 +解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。 +``` + + **示例 3:** + +``` +输入: s = "pwwkew" +输出: 3 +解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 +  请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。 +``` + + **提示：** + +* `0 <= s.length <= 5 * 10^4` +* `s` 由英文字母、数字、符号和空格组成 + +--- + +滑动窗口 + 哈希表： + +使用哈希表记录当前字符最后一次出现的下标，并且用一个变量记录遍历过程中最后一次出现下标的最大值，最后再将当前下标与该最大值取差值。 + +```Java +class Solution { + public int lengthOfLongestSubstring(String s) { + HashMap hashmap = new HashMap<>(); + int res = 0, left = -1; + for(int i = 0; i < s.length(); i++){ + char c = s.charAt(i); + left = Math.max(left, hashmap.getOrDefault(c, -1)); + hashmap.put(c, i); + res = Math.max(res, i - left); + } + return res; + } +} +``` \ No newline at end of file From 62648f16e834227e607ba8b7698be108c8d86c7f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 6 Dec 2023 11:31:13 +0800 Subject: [PATCH 184/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 41b91bb..275700f 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | | 2023-12-05 19:53 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 3 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | | 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | @@ -240,7 +241,6 @@ | 2022-07-14 13:12 | [#745 前缀和后缀搜索](https://leetcode.cn/problems/prefix-and-suffix-search) | HARD | 2 | 1 | | 2022-07-13 19:22 | [#735 小行星碰撞](https://leetcode.cn/problems/asteroid-collision) | MEDIUM | 11 | 1 | | 2022-07-11 13:05 | [#676 实现一个魔法字典](https://leetcode.cn/problems/implement-magic-dictionary) | MEDIUM | 2 | 1 | -| 2022-07-08 14:39 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 5 | 1 | | 2022-07-08 13:51 | [#1217 玩筹码](https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position) | EASY | 1 | 1 | | 2022-07-07 15:38 | [#648 单词替换](https://leetcode.cn/problems/replace-words) | MEDIUM | 3 | 1 | | 2022-07-05 11:23 | [#729 我的日程安排表 I](https://leetcode.cn/problems/my-calendar-i) | MEDIUM | 8 | 1 | From 7d2f87ebdb10eed124b252b80e265c2eed78b433 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Dec 2023 20:24:21 +0800 Subject: [PATCH 185/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 275700f..ec9626d 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | +| 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | | 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | | 2023-12-05 19:53 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 3 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | @@ -341,13 +343,11 @@ | 2021-07-12 19:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | | 2021-07-12 18:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | | 2021-07-06 16:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | -| 2021-07-06 16:03 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 2 | 1 | | 2021-07-05 15:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | | 2021-07-05 14:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | | 2021-07-05 13:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | | 2021-07-05 13:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | | 2021-07-05 12:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | -| 2021-07-05 12:30 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 1 | 1 | | 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | | 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2021-06-13 15:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | From 019059d3d3a2af511307c5dedd051c89c58eab92 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 14 Dec 2023 20:28:11 +0800 Subject: [PATCH 186/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ec9626d..0179b93 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | | 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | From 0ad84ae5a7ddbe3412f61e9853ca1f4fb08ebdda Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 20 Dec 2023 20:05:32 +0800 Subject: [PATCH 187/373] =?UTF-8?q?Create=2011.=20=E7=9B=9B=E6=9C=80?= =?UTF-8?q?=E5=A4=9A=E6=B0=B4=E7=9A=84=E5=AE=B9=E5=99=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...64\347\232\204\345\256\271\345\231\250.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Two Pointers/11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" diff --git "a/Two Pointers/11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" "b/Two Pointers/11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" new file mode 100644 index 0000000..d32a893 --- /dev/null +++ "b/Two Pointers/11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" @@ -0,0 +1,61 @@ +#### 11. 盛最多水的容器 + +难度：中等 + +--- + +给定一个长度为 `n` 的整数数组 `height` 。有 `n` 条垂线，第 `i` 条线的两个端点是 `(i, 0)` 和 `(i, height[i])` 。 + +找出其中的两条线，使得它们与 `x` 轴共同构成的容器可以容纳最多的水。 + +返回容器可以储存的最大水量。 + + **说明：** 你不能倾斜容器。 + + **示例 1：** + +![](https://aliyun-lc-upload.oss-cn-hangzhou.aliyuncs.com/aliyun-lc-upload/uploads/2018/07/25/question_11.jpg) + +``` +输入：[1,8,6,2,5,4,8,3,7] +输出：49 +解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。 +``` + + **示例 2：** + +``` +输入：height = [1,1] +输出：1 +``` + + **提示：** + +* `n == height.length` +* `2 <= n <= 10^5` +* `0 <= height[i] <= 10^4` + +--- + +双指针： + +1. 左指针指向左边界，右指针指向右边界 +2. 不断的收紧左右边界，选定**两边界中相对短的边界并向内移动一格** +3. 返回最大面积 + +```Java +class Solution { + public int maxArea(int[] height) { + int left = 0, right = height.length - 1, res = 0; + while(left < right){ + res = Math.max(res, Math.min(height[left], height[right]) * (right - left)); + if(height[left] < height[right]){ + left++; + } else { + right--; + } + } + return res; + } +} +``` \ No newline at end of file From 7f590e59b37f31abae950f1d6b2898716c6f2ac7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 20 Dec 2023 20:08:07 +0800 Subject: [PATCH 188/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0179b93..5327210 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-20 20:00 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 5 | **2** | | 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | @@ -384,7 +385,6 @@ | 2020-07-23 15:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | | 2020-07-23 14:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | | 2020-07-23 14:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | -| 2020-07-22 21:24 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 4 | 1 | | 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | | 2020-07-18 23:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | | 2020-07-17 16:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | From 0001bfb185d37949817fd9e69c5eb8b6a62b059c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 20 Dec 2023 20:19:55 +0800 Subject: [PATCH 189/373] =?UTF-8?q?Create=2094.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E4=B8=AD=E5=BA=8F=E9=81=8D=E5=8E=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...55\345\272\217\351\201\215\345\216\206.md" | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 "Linked List/94. \344\272\214\345\217\211\346\240\221\347\232\204\344\270\255\345\272\217\351\201\215\345\216\206.md" diff --git "a/Linked List/94. \344\272\214\345\217\211\346\240\221\347\232\204\344\270\255\345\272\217\351\201\215\345\216\206.md" "b/Linked List/94. \344\272\214\345\217\211\346\240\221\347\232\204\344\270\255\345\272\217\351\201\215\345\216\206.md" new file mode 100644 index 0000000..b9128f2 --- /dev/null +++ "b/Linked List/94. \344\272\214\345\217\211\346\240\221\347\232\204\344\270\255\345\272\217\351\201\215\345\216\206.md" @@ -0,0 +1,117 @@ +#### 94. 二叉树的中序遍历 + +难度：简单 + +--- + +给定一个二叉树的根节点 `root` ，返回 _它的 **中序**  遍历_ 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg) +``` +输入：root = [1,null,2,3] +输出：[1,3,2] +``` + + **示例 2：** + +``` +输入：root = [] +输出：[] +``` + + **示例 3：** + +``` +输入：root = [1] +输出：[1] +``` + + **提示：** + +* 树中节点数目在范围 `[0, 100]` 内 +* `-100 <= Node.val <= 100` + + **进阶:**  递归算法很简单，你可以通过迭代算法完成吗？ + +--- + +递归： + +`res.add(root.val);` 若位于 `dfs(root.left, res)` 上方，是前序遍历；若位于下方，则是后序遍历。 + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public List inorderTraversal(TreeNode root) { + List res = new ArrayList<>(); + dfs(root, res); + return res; + } + + private void dfs(TreeNode root, List res){ + if(root == null){ + return; + } + dfs(root.left, res); + res.add(root.val); + dfs(root.right, res); + } +} +``` + + + +迭代： + +借助栈 + +```java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public List inorderTraversal(TreeNode root) { + List res = new ArrayList<>(); + ArrayDeque stack = new ArrayDeque<>(); + while(root != null || !stack.isEmpty()){ + while(root != null){ + stack.push(root); + root = root.left; + } + root = stack.pop(); + res.add(root.val); + root = root.right; + } + return res; + } +} +``` + From 9a7b62451c3dd471b4833b065d10413b59f09427 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 20 Dec 2023 20:22:18 +0800 Subject: [PATCH 190/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5327210..02827dd 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | | 2023-12-20 20:00 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 5 | **2** | | 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | From 213bf3a5ab1dc4c751802ea028f6b084dba25df7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 23 Dec 2023 10:40:00 +0800 Subject: [PATCH 191/373] =?UTF-8?q?Create=201962.=20=E7=A7=BB=E9=99=A4?= =?UTF-8?q?=E7=9F=B3=E5=AD=90=E4=BD=BF=E6=80=BB=E6=95=B0=E6=9C=80=E5=B0=8F?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...73\346\225\260\346\234\200\345\260\217.md" | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 "Priority Queue/1962. \347\247\273\351\231\244\347\237\263\345\255\220\344\275\277\346\200\273\346\225\260\346\234\200\345\260\217.md" diff --git "a/Priority Queue/1962. \347\247\273\351\231\244\347\237\263\345\255\220\344\275\277\346\200\273\346\225\260\346\234\200\345\260\217.md" "b/Priority Queue/1962. \347\247\273\351\231\244\347\237\263\345\255\220\344\275\277\346\200\273\346\225\260\346\234\200\345\260\217.md" new file mode 100644 index 0000000..e930b7b --- /dev/null +++ "b/Priority Queue/1962. \347\247\273\351\231\244\347\237\263\345\255\220\344\275\277\346\200\273\346\225\260\346\234\200\345\260\217.md" @@ -0,0 +1,70 @@ +#### 1962. 移除石子使总数最小 + +难度：中等 + +--- + +给你一个整数数组 `piles` ，数组 **下标从 0 开始** ，其中 `piles[i]` 表示第 `i` 堆石子中的石子数量。另给你一个整数 `k` ，请你执行下述操作 **恰好** `k` 次： + +* 选出任一石子堆 `piles[i]` ，并从中 **移除** `floor(piles[i] / 2)` 颗石子。 + + **注意：** 你可以对 **同一堆** 石子多次执行此操作。 + +返回执行 `k` 次操作后，剩下石子的 **最小** 总数。 + +`floor(x)` 为 **小于** 或 **等于** `x` 的 **最大** 整数。（即，对 `x` 向下取整）。 + + **示例 1：** + +``` +输入：piles = [5,4,9], k = 2 +输出：12 +解释：可能的执行情景如下： +- 对第 2 堆石子执行移除操作，石子分布情况变成 [5,4,5] 。 +- 对第 0 堆石子执行移除操作，石子分布情况变成 [3,4,5] 。 +剩下石子的总数为 12 。 +``` + + **示例 2：** + +``` +输入：piles = [4,3,6,7], k = 3 +输出：12 +解释：可能的执行情景如下： +- 对第 2 堆石子执行移除操作，石子分布情况变成 [4,3,3,7] 。 +- 对第 3 堆石子执行移除操作，石子分布情况变成 [4,3,3,4] 。 +- 对第 0 堆石子执行移除操作，石子分布情况变成 [2,3,3,4] 。 +剩下石子的总数为 12 。 +``` + + **提示：** + +* `1 <= piles.length <= 10^5` +* `1 <= piles[i] <= 10^4` +* `1 <= k <= 10^5` + +--- + +优先队列（最大堆）： + +简单来说，就是**每次取数组中的最大值然后向下取整，重复 `k` 次**。显然借助**最大堆**的数据结构。 + +```Java +class Solution { + public int minStoneSum(int[] piles, int k) { + PriorityQueue heap = new PriorityQueue<>((a, b) -> (b - a)); + for(int pile: piles){ + heap.add(pile); + } + while(k-- != 0){ + int temp = heap.poll(); + heap.add(temp - temp / 2); + } + int res = 0; + while(!heap.isEmpty()){ + res += heap.poll(); + } + return res; + } +} +``` \ No newline at end of file From 9623b3ce0bba50e23b7af0e1bea8bf68341a5291 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 23 Dec 2023 10:42:29 +0800 Subject: [PATCH 192/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 02827dd..919c366 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | | 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | | 2023-12-20 20:00 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 5 | **2** | | 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | From 15a6e85aa6adbd90c8a659da0ab8fbbb1e8ac455 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 23 Dec 2023 14:17:59 +0800 Subject: [PATCH 193/373] =?UTF-8?q?Create=20=E6=89=8B=E5=86=99=E5=A4=A7?= =?UTF-8?q?=E9=A1=B6=E5=A0=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...31\345\244\247\351\241\266\345\240\206.md" | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 "Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" diff --git "a/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" "b/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" new file mode 100644 index 0000000..d42baaa --- /dev/null +++ "b/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" @@ -0,0 +1,73 @@ + + +手写大顶堆： + +从第一个非叶子节点（若数组长度为 `size`，那么第一个非叶子节点的下标则为 `size / 2` ）倒序遍历至第一个节点，每个循环中都与自身子节点中较大的子节点交换。 + +```java +package src.DataStructure; + +public class Heap { + + private int[] arrays = new int[1000]; + + private int size; + + public Heap(int[] arrays){ + this.size = arrays.length; + System.arraycopy(arrays, 0, this.arrays, 0, size); + heapify(size); + } + + public void add(int value){ + arrays[size++] = value; + heapify(size); + } + + + public void heapify(int size){ + for(int i = size / 2; i >= 0; i--){ + sink(i); + } + } + + public void sink(int index){ + while(2 * index + 1 < size){ + int temp = 2 * index + 1; + if(temp + 1 < size && arrays[temp] < arrays[temp + 1]){ + temp = temp + 1; + } + if(arrays[temp] <= arrays[index]){ + break; + } + swap(arrays, index, temp); + index = temp; + } + } + + public int poll(){ + int ans = arrays[0]; + swap(arrays, 0, --size); + heapify(size); + return ans; + } + + public void swap(int[] nums, int left, int right){ + int temp = nums[left]; + nums[left] = nums[right]; + nums[right] = temp; + } + + + public static void main(String[] args) { + int[] arrays = new int[]{6, 8, 10, 2, 4, 11, 13, 9, 1, 5, 7, 3}; + Heap heap = new Heap(arrays); + heap.add(200); + while(heap.size != 0){ + System.out.println(heap.poll()); + } + } +} + +``` + From 8a74f156cd1b741a4f1676d6e9e164b08094a6e4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 23 Dec 2023 15:48:18 +0800 Subject: [PATCH 194/373] =?UTF-8?q?Update=201234.=20=E6=9B=BF=E6=8D=A2?= =?UTF-8?q?=E5=AD=90=E4=B8=B2=E5=BE=97=E5=88=B0=E5=B9=B3=E8=A1=A1=E5=AD=97?= =?UTF-8?q?=E7=AC=A6=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...63\350\241\241\345\255\227\347\254\246\344\270\262.md" | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git "a/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" "b/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" index 72da5a6..c015167 100644 --- "a/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" +++ "b/Sliding Window/1234. \346\233\277\346\215\242\345\255\220\344\270\262\345\276\227\345\210\260\345\271\263\350\241\241\345\255\227\347\254\246\344\270\262.md" @@ -58,12 +58,14 @@ 滑动窗口： +首先明白一点，直接替换原子串也是可以得到平衡字符串的。 + 滑动窗口范围为 `[left, right]`，搜索**待替换子串**的步骤： -1. 如果窗口内的子串不是“合法”子串，移动右边界扩大范围 -2. 如果窗口内的子串是“合法”子串，移动左边界缩小范围 +1. 移动右边界扩大范围，使其范围外的子串尽可能合法 +2. 如果窗口外的子串是“合法”子串，移动左边界缩小范围，使其尽可能缩小待替换子串的长度 -此处的“合法”定义为**存在一个字符出现的次数大于 `n/4`**。相反，“不合法”为**所有字符出现的次数均小于 `n/4`**。 +此处的“不合法”定义为**存在一个字符出现的次数大于 `n/4`**。相反，“合法”为**所有字符出现的次数均小于或等于 `n/4`**。并且需要特殊判断原子串是否是平衡子串。 ```Java class Solution { From 846730650c351be8ccb434f88c299e39c69b1392 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 24 Dec 2023 12:45:32 +0800 Subject: [PATCH 195/373] =?UTF-8?q?Create=20567.=20=E5=AD=97=E7=AC=A6?= =?UTF-8?q?=E4=B8=B2=E7=9A=84=E6=8E=92=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...62\347\232\204\346\216\222\345\210\227.md" | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 "Sliding Window/567. \345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" diff --git "a/Sliding Window/567. \345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" "b/Sliding Window/567. \345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" new file mode 100644 index 0000000..ccf0864 --- /dev/null +++ "b/Sliding Window/567. \345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" @@ -0,0 +1,55 @@ +#### 567. 字符串的排列 + +难度：中等 + +--- + +给你两个字符串 `s1` 和 `s2` ，写一个函数来判断 `s2` 是否包含 `s1` 的排列。如果是，返回 `true` ；否则，返回 `false` 。 + +换句话说，`s1` 的排列之一是 `s2` 的 **子串** 。 + + **示例 1：** + +``` +输入：s1 = "ab" s2 = "eidbaooo" +输出：true +解释：s2 包含 s1 的排列之一 ("ba"). +``` + + **示例 2：** + +``` +输入：s1= "ab" s2 = "eidboaoo" +输出：false +``` + + **提示：** + +* `1 <= s1.length, s2.length <= 10^4` +* `s1` 和 `s2` 仅包含小写字母 + +--- + +滑动窗口（固定窗口大小）： + +以 `s1` 字符串长度为固定窗口大小，在 `s2` 字符串中滑动。用两个数组记录两个字符串中字母出现的次数，当两数组的计数器完全相同时，返回 `true`，否则遍历结束后返回 `false`。 + +```Java +class Solution { + public boolean checkInclusion(String s1, String s2) { + if(s1.length() > s2.length()) return false; + int[] cnt1 = new int[26], cnt2 = new int[26]; + for(int i = 0; i < s1.length(); i++){ + cnt1[s1.charAt(i) - 'a']++; + cnt2[s2.charAt(i) - 'a']++; + } + if(Arrays.equals(cnt1, cnt2)) return true; + for(int i = s1.length(); i < s2.length(); i++){ + cnt2[s2.charAt(i) - 'a']++; + cnt2[s2.charAt(i - s1.length()) - 'a']--; + if(Arrays.equals(cnt1, cnt2)) return true; + } + return false; + } +} +``` \ No newline at end of file From 3edd827667fcd68c423279fca90f3529e8fba9b9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 24 Dec 2023 12:48:03 +0800 Subject: [PATCH 196/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 919c366..ff11d9e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | | 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | | 2023-12-20 20:00 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 5 | **2** | From ba2209e861eb7a099f8bb3a8f6ca33535a8571cb Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Tue, 26 Dec 2023 22:36:47 +0800 Subject: [PATCH 197/373] =?UTF-8?q?Create=201143.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E5=85=AC=E5=85=B1=E5=AD=90=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...61\345\255\220\345\272\217\345\210\227.md" | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 "Dynamic Programming/1143. \346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" diff --git "a/Dynamic Programming/1143. \346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" "b/Dynamic Programming/1143. \346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" new file mode 100644 index 0000000..ce69758 --- /dev/null +++ "b/Dynamic Programming/1143. \346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" @@ -0,0 +1,66 @@ +#### 1143. 最长公共子序列 + +难度：中等 + +--- + +给定两个字符串 `text1` 和 `text2`，返回这两个字符串的最长 **公共子序列** 的长度。如果不存在 **公共子序列** ，返回 `0` 。 + +一个字符串的  **子序列**  是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 + +* 例如，`"ace"` 是 `"abcde"` 的子序列，但 `"aec"` 不是 `"abcde"` 的子序列。 + +两个字符串的 **公共子序列** 是这两个字符串所共同拥有的子序列。 + + **示例 1：** + +``` +输入：text1 = "abcde", text2 = "ace" +输出：3 +解释：最长公共子序列是 "ace" ，它的长度为 3 。 +``` + + **示例 2：** + +``` +输入：text1 = "abc", text2 = "abc" +输出：3 +解释：最长公共子序列是 "abc" ，它的长度为 3 。 +``` + + **示例 3：** + +``` +输入：text1 = "abc", text2 = "def" +输出：0 +解释：两个字符串没有公共子序列，返回 0 。 +``` + + **提示：** + +* `1 <= text1.length, text2.length <= 1000` +* `text1` 和 `text2` 仅由小写英文字符组成。 + +--- + +动态规划： + +定义 `dp[i][j]` 为 `text1[0:i]` 和 `text2[0:j]` 的最长公共子序列的长度。 + +状态转移方程为：当 `text1[i] == text2[j]` 时，`dp[i][j] = dp[i - 1][j - 1] + 1`；当 `text1[i] != text2[j]` 时，`dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])`。 + +```Java +class Solution { + public int longestCommonSubsequence(String text1, String text2) { + int m = text1.length(), n = text2.length(); + int[][] dp = new int[m + 1][n + 1]; + for(int i = 1; i <= m; i++){ + for(int j = 1; j <= n; j++){ + if(text1.charAt(i - 1) == text2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + 1; + else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); + } + } + return dp[m][n]; + } +} +``` \ No newline at end of file From 4ba946344165961de775dc7aec2374351d61f8c5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 26 Dec 2023 22:39:34 +0800 Subject: [PATCH 198/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ff11d9e..13b3515 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | | 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | From a3f8674c933e48fb691737df43e82900b4b812d6 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 28 Dec 2023 20:25:26 +0800 Subject: [PATCH 199/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 13b3515..af69590 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-28 17:12 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 2 | 1 | +| 2023-12-28 13:30 | [#5 最长回文子串](https://leetcode.cn/problems/longest-palindromic-substring) | MEDIUM | 2 | 1 | | 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | From c9b1f8481dc6f3e1e63b9a1897f61941723f04d6 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Fri, 29 Dec 2023 16:54:14 +0800 Subject: [PATCH 200/373] =?UTF-8?q?Create=20322.=20=E9=9B=B6=E9=92=B1?= =?UTF-8?q?=E5=85=91=E6=8D=A2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...66\351\222\261\345\205\221\346\215\242.md" | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 "Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" diff --git "a/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" "b/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" new file mode 100644 index 0000000..b82b27a --- /dev/null +++ "b/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" @@ -0,0 +1,70 @@ +#### 322. 零钱兑换 + +难度：中等 + +--- + +给你一个整数数组 `coins` ，表示不同面额的硬币；以及一个整数 `amount` ，表示总金额。 + +计算并返回可以凑成总金额所需的 **最少的硬币个数** 。如果没有任何一种硬币组合能组成总金额，返回 `-1` 。 + +你可以认为每种硬币的数量是无限的。 + + **示例 1：** + +``` +输入：coins = [1, 2, 5], amount = 11 +输出：3 +解释：11 = 5 + 5 + 1 +``` + + **示例 2：** + +``` +输入：coins = [2], amount = 3 +输出：-1 +``` + + **示例 3：** + +``` +输入：coins = [1], amount = 0 +输出：0 +``` + + **提示：** + +* `1 <= coins.length <= 12` +* `1 <= coins[i] <= 2^31 - 1` +* `0 <= amount <= 10^4` + +--- + +动态规划： + +`dp[i]` 指凑成总金额为 `i` 的最少硬币数量。状态转移方程为 $dp[i] = \min_{j = 0, .., n - 1}dp[i - coins[j]] + 1$。简而言之，取所有当前金额与 `coins` 数组之差最少硬币数量的最小值并加一。 + +假设 `coins = [1, 2, 5], amount = 11`，当 `i = 11` 时，取 ` coins` 数组中所有比 `11` 小的值，即 `dp[11 - 1], dp[11 - 2], dp[11 - 5]` 的最小值，最后加一即可。 + +与 [279. 完全平方数](https://leetcode.cn/problems/perfect-squares/) 类似，列举所有比当前值小的平方数，取其中 `dp` 数组的最小值。 + +```Java +class Solution { + public int coinChange(int[] coins, int amount) { + int[] dp = new int[amount + 1]; + dp[0] = 0; + for(int i = 0; i < coins.length; i++){ + if(coins[i] <= amount) dp[coins[i]] = 1; + } + for(int i = 1; i <= amount; i++){ + int minn = Integer.MAX_VALUE; + for(int j = 0; j < coins.length; j++){ + if(i - coins[j] >= 0 && dp[i - coins[j]] != -1) minn = Math.min(minn, dp[i - coins[j]]); + } + if(minn != Integer.MAX_VALUE) dp[i] = minn + 1; + else dp[i] = -1; + } + return dp[amount]; + } +} +``` \ No newline at end of file From 4a06782db5c37b6b69ae947c78cb9fee7550d4d4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 29 Dec 2023 16:56:52 +0800 Subject: [PATCH 201/373] Update changes --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index af69590..51cd2e2 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | +| 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | +| 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | | 2023-12-28 17:12 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 2 | 1 | | 2023-12-28 13:30 | [#5 最长回文子串](https://leetcode.cn/problems/longest-palindromic-substring) | MEDIUM | 2 | 1 | | 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | From 6bfbaa029592d4aeea3e8044b4f69b7a390fe8e7 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Fri, 29 Dec 2023 16:59:35 +0800 Subject: [PATCH 202/373] =?UTF-8?q?Create=20279.=20=E5=AE=8C=E5=85=A8?= =?UTF-8?q?=E5=B9=B3=E6=96=B9=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...50\345\271\263\346\226\271\346\225\260.md" | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 "Dynamic Programming/279. \345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md" diff --git "a/Dynamic Programming/279. \345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md" "b/Dynamic Programming/279. \345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md" new file mode 100644 index 0000000..51c97cc --- /dev/null +++ "b/Dynamic Programming/279. \345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md" @@ -0,0 +1,55 @@ +#### 279. 完全平方数 + +难度：中等 + +--- + +给你一个整数 `n` ，返回 _和为 `n` 的完全平方数的最少数量_ 。 + + **完全平方数** 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，`1`、`4`、`9` 和 `16` 都是完全平方数，而 `3` 和 `11` 不是。 + + **示例 1：** + +``` +输入：n = 12 +输出：3 +解释：12 = 4 + 4 + 4 +``` + + **示例 2：** + +``` +输入：n = 13 +输出：2 +解释：13 = 4 + 9 +``` + +  + + **提示：** + +* `1 <= n <= 10^4` + +--- + +动态规划： + +`dp[i]` 指和为 `i` 的完全平方数的最少数量。状态转移方程为 $dp[i] = \min_{j = 1, .., \sqrt i}dp[i - j * j] + 1$。最少数量肯定是当前值减去一个完全平方数得到的，但是具体哪个完全平方数，需要遍历得到。 + +与 [322. 零钱兑换](https://leetcode.cn/problems/coin-change/solutions/132979/322-ling-qian-dui-huan-by-leetcode-solution/) 类似！ + +```Java +class Solution { + public int numSquares(int n) { + int[] dp = new int[n + 1]; + for(int i = 1; i <= n; i++){ + int minn = Integer.MAX_VALUE; + for(int j = 1; j * j <= i; j++){ + minn = Math.min(minn, dp[i - j * j]); + } + dp[i] += minn + 1; + } + return dp[n]; + } +} +``` \ No newline at end of file From ba7d77e8d34ecf77d85255f76e33bbc70c4a3587 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 2 Jan 2024 19:40:37 +0800 Subject: [PATCH 203/373] =?UTF-8?q?Create=2078.=20=E5=AD=90=E9=9B=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "Enumerate/78. \345\255\220\351\233\206.md" | 53 +++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 "Enumerate/78. \345\255\220\351\233\206.md" diff --git "a/Enumerate/78. \345\255\220\351\233\206.md" "b/Enumerate/78. \345\255\220\351\233\206.md" new file mode 100644 index 0000000..89e2acb --- /dev/null +++ "b/Enumerate/78. \345\255\220\351\233\206.md" @@ -0,0 +1,53 @@ +#### 78. 子集 + +难度：中等 + +--- + +给你一个整数数组 `nums` ，数组中的元素 **互不相同** 。返回该数组所有可能的子集（幂集）。 + +解集 **不能** 包含重复的子集。你可以按 **任意顺序** 返回解集。 + + **示例 1：** + +``` +输入：nums = [1,2,3] +输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] +``` + + **示例 2：** + +``` +输入：nums = [0] +输出：[[],[0]] +``` + + **提示：** + +* `1 <= nums.length <= 10` +* `-10 <= nums[i] <= 10` +* `nums` 中的所有元素 **互不相同** + +--- + +循环枚举： + +规律：空集的幂集只有空集，每增加一个元素，让之前幂集中的每个集合，追加这个元素，就是新增的子集。 + +```Java +class Solution { + public List> subsets(int[] nums) { + List> res = new ArrayList<>(); + res.add(new ArrayList()); + for(int num: nums){ + int sz = res.size(); + for(int i = 0; i < sz; i++){ + List temp = new ArrayList<>(res.get(i)); + temp.add(num); + res.add(temp); + } + } + return res; + } +} +``` \ No newline at end of file From cdd58de339d517e0497e8e857243cdb9af178b4d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 2 Jan 2024 19:55:14 +0800 Subject: [PATCH 204/373] =?UTF-8?q?Create=205.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E5=9B=9E=E6=96=87=E5=AD=90=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\346\226\207\345\255\220\344\270\262.md" | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 "Enumerate/5. \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md" diff --git "a/Enumerate/5. \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md" "b/Enumerate/5. \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md" new file mode 100644 index 0000000..f2ad6aa --- /dev/null +++ "b/Enumerate/5. \346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md" @@ -0,0 +1,63 @@ +#### 5. 最长回文子串 + +难度：中等 + +--- + +给你一个字符串 `s`，找到 `s` 中最长的回文子串。 + +如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。 + + **示例 1：** + +``` +输入：s = "babad" +输出："bab" +解释："aba" 同样是符合题意的答案。 +``` + + **示例 2：** + +``` +输入：s = "cbbd" +输出："bb" +``` + + **提示：** + +* `1 <= s.length <= 1000` +* `s` 仅由数字和英文字母组成 + +--- + +二维动态规划： + +`dp[i][j]` 表示从下标 `i` 到下标 `j` 范围内的字符串是否是回文。状态转移方程为 $dp[i][j] = (dp[i + 1][j - 1] ~\&~ s[i] == s[j]) ~\|~ j - i == 1$，初始化 `dp[i][i] = true`。所以外循环是从 `j` 开始，内循环是 `i`。 + +```Java +class Solution { + public String longestPalindrome(String s) { + int n = s.length(), index = 0, maxn = 1; + boolean[][] dp = new boolean[n][n]; + for(int i = 0; i < n; i++){ + dp[i][i] = true; + } + for(int j = 1; j < n; j++){ + for(int i = 0; i < j; i++){ + if(s.charAt(i) != s.charAt(j)){ + dp[i][j] = false; + } else if(j - i == 1){ + dp[i][j] = true; + } else { + dp[i][j] = dp[i + 1][j - 1]; + } + if(dp[i][j] && j - i + 1 > maxn){ + maxn = j - i + 1; + index = i; + } + } + } + return s.substring(index, index + maxn); + } +} +``` \ No newline at end of file From f96a25f16899d6117fadac8dc3f2f3fa8b3a4b6c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 09:40:31 +0800 Subject: [PATCH 205/373] =?UTF-8?q?Update=2015.=20=E4=B8=89=E6=95=B0?= =?UTF-8?q?=E4=B9=8B=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...344\270\211\346\225\260\344\271\213\345\222\214.md" | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git "a/Two Pointers/15. \344\270\211\346\225\260\344\271\213\345\222\214.md" "b/Two Pointers/15. \344\270\211\346\225\260\344\271\213\345\222\214.md" index 3d90f15..ace9e3e 100644 --- "a/Two Pointers/15. \344\270\211\346\225\260\344\271\213\345\222\214.md" +++ "b/Two Pointers/15. \344\270\211\346\225\260\344\271\213\345\222\214.md" @@ -72,8 +72,14 @@ class Solution { left++; right--; } - else if(sum < 0) left++; - else right--; + else if(sum < 0){ + while(left < right && nums[left] == nums[left + 1]) left++; + left++; + } + else { + while(left < right && nums[right] == nums[right - 1]) right--; + right--; + } } } return ans; From 2c00a86d6508713af210ac5d8dca35188886d874 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 09:43:15 +0800 Subject: [PATCH 206/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 51cd2e2..def49f0 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | | 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | @@ -183,7 +184,6 @@ | 2022-11-21 20:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | | 2022-11-21 19:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | | 2022-11-21 18:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | -| 2022-11-21 16:43 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 5 | **2** | | 2022-11-21 14:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | | 2022-11-21 11:04 | [#799 香槟塔](https://leetcode.cn/problems/champagne-tower) | MEDIUM | 2 | 1 | | 2022-11-19 20:48 | [#139 单词拆分](https://leetcode.cn/problems/word-break) | MEDIUM | 3 | 1 | From 110621e2c6b8c4a22867869aa2ae48057e3a92e4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 10:06:54 +0800 Subject: [PATCH 207/373] =?UTF-8?q?Create=20209.=20=E9=95=BF=E5=BA=A6?= =?UTF-8?q?=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\255\220\346\225\260\347\273\204.md" | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 "Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" diff --git "a/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" new file mode 100644 index 0000000..24e9522 --- /dev/null +++ "b/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -0,0 +1,64 @@ +#### 209. 长度最小的子数组 + +难度：中等 + +--- + +给定一个含有 `n` 个正整数的数组和一个正整数 `target` **。** + +找出该数组中满足其总和大于等于 `target` 的长度最小的 **连续子数组**  `[numsl, numsl+1, ..., numsr-1, numsr]` ，并返回其长度 **。** 如果不存在符合条件的子数组，返回 `0` 。 + + **示例 1：** + +``` +输入：target = 7, nums = [2,3,1,2,4,3] +输出：2 +解释：子数组 [4,3] 是该条件下的长度最小的子数组。 +``` + + **示例 2：** + +``` +输入：target = 4, nums = [1,4,4] +输出：1 +``` + + **示例 3：** + +``` +输入：target = 11, nums = [1,1,1,1,1,1,1,1] +输出：0 +``` + + **提示：** + +* `1 <= target <= 10^9` +* `1 <= nums.length <= 10^5` +* `1 <= nums[i] <= 10^5` + + **进阶：** + +* 如果你已经实现 `O(n)` 时间复杂度的解法, 请尝试设计一个 `O(n log(n))` 时间复杂度的解法。 + +--- + +滑动窗口： + +滑动窗口也是一个特殊的**双指针**方法。滑动窗口的左右边界都从零开始，直到右边界到达数组最右侧为止。窗口内的子数组和大于等于 `target` 则循环向右移动左边界，否则向右移动右边界。 + +```Java +class Solution { + public int minSubArrayLen(int target, int[] nums) { + int n = nums.length, left = 0, right = 0, sum = 0, res = Integer.MAX_VALUE; + while(right < n){ + sum += nums[right]; + while(sum >= target){ + res = Math.min(res, right - left + 1); + sum -= nums[left++]; + } + right++; + } + return res == Integer.MAX_VALUE ? 0 : res; + } +} +``` \ No newline at end of file From 71a2cb5fcd741629436b9ed5e8359f8f20452da1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 10:09:35 +0800 Subject: [PATCH 208/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index def49f0..91bbc2e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | | 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | From a2d1f2153c5abccf8076acee0c11256712833ad7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 10:41:20 +0800 Subject: [PATCH 209/373] =?UTF-8?q?Create=20150.=20=E9=80=86=E6=B3=A2?= =?UTF-8?q?=E5=85=B0=E8=A1=A8=E8=BE=BE=E5=BC=8F=E6=B1=82=E5=80=BC.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...76\345\274\217\346\261\202\345\200\274.md" | 103 ++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 "Stack/150. \351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" diff --git "a/Stack/150. \351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" "b/Stack/150. \351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" new file mode 100644 index 0000000..e2c62a2 --- /dev/null +++ "b/Stack/150. \351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" @@ -0,0 +1,103 @@ +#### 150. 逆波兰表达式求值 + +难度：中等 + +--- + +给你一个字符串数组 `tokens` ，表示一个根据 [逆波兰表示法](https://baike.baidu.com/item/%E9%80%86%E6%B3%A2%E5%85%B0%E5%BC%8F/128437) 表示的算术表达式。 + +请你计算该表达式。返回一个表示表达式值的整数。 + + **注意：** + +* 有效的算符为 `'+'`、`'-'`、`'*'` 和 `'/'` 。 +* 每个操作数（运算对象）都可以是一个整数或者另一个表达式。 +* 两个整数之间的除法总是 **向零截断** 。 +* 表达式中不含除零运算。 +* 输入是一个根据逆波兰表示法表示的算术表达式。 +* 答案及所有中间计算结果可以用 **32 位** 整数表示。 + + **示例 1：** + +``` +输入：tokens = ["2","1","+","3","*"] +输出：9 +解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 +``` + + **示例 2：** + +``` +输入：tokens = ["4","13","5","/","+"] +输出：6 +解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6 +``` + + **示例 3：** + +``` +输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"] +输出：22 +解释：该算式转化为常见的中缀算术表达式为： + ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 += ((10 * (6 / (12 * -11))) + 17) + 5 += ((10 * (6 / -132)) + 17) + 5 += ((10 * 0) + 17) + 5 += (0 + 17) + 5 += 17 + 5 += 22 +``` + + **提示：** + +* `1 <= tokens.length <= 10^4` +* `tokens[i]` 是一个算符（`"+"`、`"-"`、`"*"` 或 `"/"`），或是在范围 `[-200, 200]` 内的一个整数 + + **逆波兰表达式：** + +逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。 + +* 平常使用的算式则是一种中缀表达式，如 `( 1 + 2 ) * ( 3 + 4 )` 。 +* 该算式的逆波兰表达式写法为 `( ( 1 2 + ) ( 3 4 + ) * )` 。 + +逆波兰表达式主要有以下两个优点： + +* 去掉括号后表达式无歧义，上式即便写成 `1 2 + 3 4 + *` 也可以依据次序计算出正确结果。 +* 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中 + +--- + +栈： + +遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。注意字符相等的判断需要用 `s.equals("+")`，而**不能直接用等于号**。 + +```Java +class Solution { + public int evalRPN(String[] tokens) { + int res = 0; + Deque stack = new ArrayDeque(); + for(String token: tokens){ + if(isNumber(token)){ + stack.push(Integer.parseInt(token)); + } else { + int num1 = stack.pop(); + int num2 = stack.pop(); + if(token.equals("+")){ + stack.push(num2 + num1); + } else if(token.equals("-")){ + stack.push(num2 - num1); + } else if(token.equals("*")){ + stack.push(num2 * num1); + } else if(token.equals("/")){ + stack.push(num2 / num1); + } + } + } + return stack.pop(); + } + + private boolean isNumber(String s){ + return !(s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")); + } +} +``` \ No newline at end of file From d88ea74e18680bd55ce6b0f654b138af973c4db7 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 3 Jan 2024 10:44:07 +0800 Subject: [PATCH 210/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 91bbc2e..546f644 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | From 2fe56bddf40fce74bd9fbc710d8480ebe797c6ac Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 4 Jan 2024 20:25:50 +0800 Subject: [PATCH 211/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 546f644..909b6b4 100644 --- a/README.md +++ b/README.md @@ -114,7 +114,7 @@ | 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | | 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | | 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | -| 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | MEDIUM | 2 | 1 | +| 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | EASY | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | | 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | From 8822e5e7da51574328bfd0d8a0324212951ef8cf Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 9 Jan 2024 09:02:26 +0800 Subject: [PATCH 212/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 909b6b4..d2a1f85 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-08 20:52 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | From ac0e68356506b3a10453b2bba1a5b31e2419e972 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 11 Jan 2024 20:27:06 +0800 Subject: [PATCH 213/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d2a1f85..18d0d37 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-11 14:02 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 1 | 1 | | 2024-01-08 20:52 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | From 5e0587d08d9a5ecc39fc97fb1cf6b3ba9e86bce3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 18 Jan 2024 20:29:36 +0800 Subject: [PATCH 214/373] Update changes --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 18d0d37..0aad1ce 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,10 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | +| 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | +| 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | +| 2024-01-18 10:12 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 1 | 1 | | 2024-01-11 14:02 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 1 | 1 | | 2024-01-08 20:52 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | @@ -366,7 +370,6 @@ | 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | | 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2021-06-13 15:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | -| 2021-06-07 19:49 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 1 | 1 | | 2021-06-04 09:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | | 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | | 2021-05-24 11:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | From bb7b3673781bc01a421e7e6fa3bd422691f41443 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 19 Jan 2024 20:27:32 +0800 Subject: [PATCH 215/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0aad1ce..66cf812 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | @@ -72,7 +73,6 @@ | 2023-10-05 18:14 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | -| 2023-09-22 19:56 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 2 | 1 | | 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | | 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | | 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | From 7b9fe0c94c50e1aefee633e6620c95a647580bd8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 13:37:45 +0800 Subject: [PATCH 216/373] =?UTF-8?q?Create=20373.=20=E6=9F=A5=E6=89=BE?= =?UTF-8?q?=E5=92=8C=E6=9C=80=E5=B0=8F=E7=9A=84=20K=20=E5=AF=B9=E6=95=B0?= =?UTF-8?q?=E5=AD=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...K \345\257\271\346\225\260\345\255\227.md" | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 "Priority Queue/373. \346\237\245\346\211\276\345\222\214\346\234\200\345\260\217\347\232\204 K \345\257\271\346\225\260\345\255\227.md" diff --git "a/Priority Queue/373. \346\237\245\346\211\276\345\222\214\346\234\200\345\260\217\347\232\204 K \345\257\271\346\225\260\345\255\227.md" "b/Priority Queue/373. \346\237\245\346\211\276\345\222\214\346\234\200\345\260\217\347\232\204 K \345\257\271\346\225\260\345\255\227.md" new file mode 100644 index 0000000..d015d35 --- /dev/null +++ "b/Priority Queue/373. \346\237\245\346\211\276\345\222\214\346\234\200\345\260\217\347\232\204 K \345\257\271\346\225\260\345\255\227.md" @@ -0,0 +1,73 @@ +#### 373. 查找和最小的 K 对数字 + +难度：中等 + +--- + +给定两个以 **非递减顺序排列** 的整数数组 `nums1` 和 `nums2` , 以及一个整数 `k` 。 + +定义一对值 `(u,v)`，其中第一个元素来自 `nums1`，第二个元素来自 `nums2` 。 + +请找到和最小的 `k` 个数对 `(u1,v1)`,  `(u2,v2)`  ...  `(uk,vk)` 。 + + **示例 1:** + +``` +输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3 +输出: [1,2],[1,4],[1,6] +解释: 返回序列中的前 3 对数： + [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6] +``` + + **示例 2:** + +``` +输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2 +输出: [1,1],[1,1] +解释: 返回序列中的前 2 对数： +  [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3] +``` + + **示例 3:** + +``` +输入: nums1 = [1,2], nums2 = [3], k = 3 +输出: [1,3],[2,3] +解释: 也可能序列中所有的数对都被返回:[1,3],[2,3] +``` + + **提示:** + +* `1 <= nums1.length, nums2.length <= 10^5` +* `-10^9 <= nums1[i], nums2[i] <= 10^9` +* `nums1` 和 `nums2` 均为 **升序排列** +* `1 <= k <= 10^4` +* `k <= nums1.length * nums2.length` + +--- + +优先队列： + +题干给出两个数组都是**非递减顺序排序**，借助优先队列，先默认放入 `nums1` 的所有索引，每次弹出的都是和最小的索引 `(i, j)`，再放入索引 `(i, j + 1)`。 + +```Java +class Solution { + public List> kSmallestPairs(int[] nums1, int[] nums2, int k) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> (nums1[a[0]] + nums2[a[1]] - nums1[b[0]] - nums2[b[1]])); + int n = nums1.length, m = nums2.length; + for(int i = 0; i < Math.min(n, k); i++){ + pq.offer(new int[]{i, 0}); + } + List> res = new ArrayList<>(); + while(k-- != 0 && !pq.isEmpty()){ + int[] temp = pq.poll(); + res.add(Arrays.asList(nums1[temp[0]], nums2[temp[1]])); + if(temp[1] < m - 1){ + temp[1] += 1; + pq.offer(temp); + } + } + return res; + } +} +``` \ No newline at end of file From c47bd4d27b607db197cc2f4178c18f399230a02e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 13:40:38 +0800 Subject: [PATCH 217/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 66cf812..966a31a 100644 --- a/README.md +++ b/README.md @@ -26,12 +26,12 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-18 10:12 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 1 | 1 | -| 2024-01-11 14:02 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 1 | 1 | | 2024-01-08 20:52 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | From 5f58494aa6cbe0ef81f6204c92f80eb24684b6ee Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 13:45:29 +0800 Subject: [PATCH 218/373] =?UTF-8?q?Create=20189.=20=E8=BD=AE=E8=BD=AC?= =?UTF-8?q?=E6=95=B0=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...56\350\275\254\346\225\260\347\273\204.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" diff --git "a/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" "b/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" new file mode 100644 index 0000000..5383d3f --- /dev/null +++ "b/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" @@ -0,0 +1,69 @@ +#### 189. 轮转数组 + +难度：中等 + +--- + +给定一个整数数组 `nums`，将数组中的元素向右轮转 `k` 个位置，其中 `k` 是非负数。 + + **示例 1:** + +``` +输入: nums = [1,2,3,4,5,6,7], k = 3 +输出: [5,6,7,1,2,3,4] +解释: +向右轮转 1 步: [7,1,2,3,4,5,6] +向右轮转 2 步: [6,7,1,2,3,4,5] +向右轮转 3 步: [5,6,7,1,2,3,4] +``` + + **示例 2:** + +``` +输入：nums = [-1,-100,3,99], k = 2 +输出：[3,99,-1,-100] +解释: +向右轮转 1 步: [99,-1,-100,3] +向右轮转 2 步: [3,99,-1,-100] +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `-2^31 <= nums[i] <= 2^31 - 1` +* `0 <= k <= 10^5` + + **进阶：** + +* 尽可能想出更多的解决方案，至少有 **三种** 不同的方法可以解决这个问题。 +* 你可以使用空间复杂度为 `O(1)` 的  **原地**  算法解决这个问题吗？ + +--- + +技巧： + +**向右轮转 **的解决办法是先翻转整个数组，再各自反转 `[0, (k mod n) - 1]` 和 `[k mod n, n - 1]`。 + +另外，如果是 **向左轮转**，则是先反转整个数组，再各自反转 `[0, n - 1 - (k mod n)]` 和 `[n - (k mod n), n - 1]`。 + +```Java +class Solution { + public void rotate(int[] nums, int k) { + int n = nums.length; + k = k % n; + reverse(nums, 0, n - 1); + reverse(nums, 0, k - 1); + reverse(nums, k, n - 1); + } + + private void reverse(int[] nums, int left, int right){ + while(left < right){ + int temp = nums[left]; + nums[left] = nums[right]; + nums[right] = temp; + left++; + right--; + } + } +} +``` \ No newline at end of file From f9b0e4e798b284ba8c2ec19a7158ad53bd538aed Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 14:44:25 +0800 Subject: [PATCH 219/373] =?UTF-8?q?Create=20416.=20=E5=88=86=E5=89=B2?= =?UTF-8?q?=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...11\345\222\214\345\255\220\351\233\206.md" | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 "Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" diff --git "a/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" new file mode 100644 index 0000000..0f8b5f2 --- /dev/null +++ "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" @@ -0,0 +1,63 @@ +#### 416. 分割等和子集 + +难度：中等 + +--- + +给你一个 **只包含正整数** 的 **非空** 数组 `nums` 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 + + **示例 1：** + +``` +输入：nums = [1,5,11,5] +输出：true +解释：数组可以分割成 [1, 5, 5] 和 [11] 。 +``` + + **示例 2：** + +``` +输入：nums = [1,2,3,5] +输出：false +解释：数组不能分割成两个元素和相等的子集。 +``` + + **提示：** + +* `1 <= nums.length <= 200` +* `1 <= nums[i] <= 100` + +--- + +二维动态规划： + +`dp[i][j]` 是指从 `[0, i]` 范围内选取若干个数，其和为 `j` 的可行性。 + +初始状态 `dp[i][0] = true, dp[0][nums[0]] = true`。 + +状态转移方程：当 `nums[i] <= j` 时，`dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]`，即第一种情况不包含 `nums[i]`，第二种情况包含 `nums[i]`，两种情况用 **或** 相连接；当 `nums[i] > j` 时，`dp[i][j] = dp[i - 1][j]`，如果加了 `nums[i]` 之后大于 `j`，那只能不包含 `nums[i]`。 + +```Java +class Solution { + public boolean canPartition(int[] nums) { + int n = nums.length, sum = 0; + for(int num: nums){ + sum += num; + } + if(sum % 2 == 1) return false; + int target = sum / 2; + boolean[][] dp = new boolean[n][target + 1]; + dp[0][0] = true; + if(nums[0] <= target) dp[0][nums[0]] = true; + for(int i = 1; i < n; i++){ + for(int j = 0; j <= target; j++){ + dp[i][j] = dp[i - 1][j]; + if(nums[i] <= j){ + dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]; + } + } + } + return dp[n - 1][target]; + } +} +``` \ No newline at end of file From b348f9e29a335cd09ef9e2d7f6c233a326cc0aaf Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 15:29:37 +0800 Subject: [PATCH 220/373] =?UTF-8?q?Create=2082.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E6=8E=92=E5=BA=8F=E9=93=BE=E8=A1=A8=E4=B8=AD=E7=9A=84=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E5=85=83=E7=B4=A0=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...345\244\215\345\205\203\347\264\240 II.md" | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 "Linked List/82. \345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240 II.md" diff --git "a/Linked List/82. \345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240 II.md" "b/Linked List/82. \345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240 II.md" new file mode 100644 index 0000000..9fc5d5b --- /dev/null +++ "b/Linked List/82. \345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240 II.md" @@ -0,0 +1,65 @@ +#### 82. 删除排序链表中的重复元素 II + +难度：中等 + +--- + +给定一个已排序的链表的头 `head` ， _删除原始链表中所有重复数字的节点，只留下不同的数字_ 。返回 _已排序的链表_ 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg) +``` +输入：head = [1,2,3,3,4,4,5] +输出：[1,2,5] +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg) +``` +输入：head = [1,1,1,2,3] +输出：[2,3] +``` + + **提示：** + +* 链表中节点数目在范围 `[0, 300]` 内 +* `-100 <= Node.val <= 100` +* 题目数据保证链表已经按升序 **排列** + +--- + +用两个节点分别表示 **当前节点** 和 **当前节点的前一个节点**。 + +如果当前节点值等于下一个节点值，一直遍历至不等为止，再判断当前节点是否移动过（通过前一个节点的下一个节点是否是当前节点），如果移动过，则两个节点同时移动，否则，前一个节点的下一个节点指向当前节点的下一个节点。 + +另外，当头节点有可能发送变化时，此时需要一个 `dummy` 节点指向头节点，最后再返回 `dummy.next`。 + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode deleteDuplicates(ListNode head) { + ListNode pre = new ListNode(-1, head), dummy = pre, cur = head; + while(cur != null){ + while(cur.next != null && cur.val == cur.next.val) cur = cur.next; + if(pre.next == cur){ + pre = pre.next; + } else { + pre.next = cur.next; + } + cur = cur.next; + } + return dummy.next; + } +} +``` \ No newline at end of file From 0128d05fcb7534db94754a95a70c33dd59c75a9e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 20 Jan 2024 15:32:21 +0800 Subject: [PATCH 221/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 966a31a..7543d9c 100644 --- a/README.md +++ b/README.md @@ -26,13 +26,13 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-18 10:12 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 1 | 1 | -| 2024-01-08 20:52 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | From aba1ca19f6f763ff2e06457f42df7ce3e344613c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 21 Jan 2024 20:02:01 +0800 Subject: [PATCH 222/373] =?UTF-8?q?Create=20236.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC=E5=85=B1=E7=A5=96?= =?UTF-8?q?=E5=85=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...54\345\205\261\347\245\226\345\205\210.md" | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 "Linked List/236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" diff --git "a/Linked List/236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" "b/Linked List/236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" new file mode 100644 index 0000000..68cb3df --- /dev/null +++ "b/Linked List/236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" @@ -0,0 +1,73 @@ +#### 236. 二叉树的最近公共祖先 + +难度：中等 + +--- + +给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 + +[百度百科](https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin)中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（ **一个节点也可以是它自己的祖先** ）。” + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png) +``` +输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 +输出：3 +解释：节点 5 和节点 1 的最近公共祖先是节点 3 。 +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2018/12/14/binarytree.png) +``` +输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 +输出：5 +解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。 +``` + + **示例 3：** + +``` +输入：root = [1,2], p = 1, q = 2 +输出：1 +``` + + **提示：** + +* 树中节点数目在范围 `[2, 10^5]` 内。 +* `-10^9 <= Node.val <= 10^9` +* 所有 `Node.val` `互不相同` 。 +* `p != q` +* `p` 和 `q` 均存在于给定的二叉树中。 + +--- + +深度优先搜索： + +核心在于根据返回空节点还是非空节点判断是否找到了 `p` 或 `q` 节点。这道题得靠背诵。。 + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +class Solution { + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if(root == null || root == p || root == q){ + return root; + } + TreeNode left = lowestCommonAncestor(root.left, p, q); + TreeNode right = lowestCommonAncestor(root.right, p, q); + if(left != null && right != null){ + return root; + } + return left != null ? left : right; + } +} +``` \ No newline at end of file From b547c94acf4c4a51fb854331436afaef7947a0b3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 22 Jan 2024 19:45:04 +0800 Subject: [PATCH 223/373] =?UTF-8?q?Create=20670.=20=E6=9C=80=E5=A4=A7?= =?UTF-8?q?=E4=BA=A4=E6=8D=A2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\244\247\344\272\244\346\215\242.md" | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 "Methodology/670. \346\234\200\345\244\247\344\272\244\346\215\242.md" diff --git "a/Methodology/670. \346\234\200\345\244\247\344\272\244\346\215\242.md" "b/Methodology/670. \346\234\200\345\244\247\344\272\244\346\215\242.md" new file mode 100644 index 0000000..fbcf4cd --- /dev/null +++ "b/Methodology/670. \346\234\200\345\244\247\344\272\244\346\215\242.md" @@ -0,0 +1,121 @@ +#### 670. 最大交换 + +难度：中等 + +--- + +给定一个非负整数，你 **至多** 可以交换一次数字中的任意两位。返回你能得到的最大值。 + + **示例 1 :** + +``` +输入: 2736 +输出: 7236 +解释: 交换数字2和数字7。 +``` + + **示例 2 :** + +``` +输入: 9973 +输出: 9973 +解释: 不需要交换。 +``` + + **注意:** + +1. 给定数字的范围是 \[0, 10^8\] + +--- + +方法一，方法论： + +从左向右遍历，找到第一次升序的下标，先尽可能地向后找到最大值，再尽可能向前找小于该最大值的最小值，然后交换两者位置。 + +```java +class Solution { + public int maximumSwap(int num) { + String s = "" + num; + int n = s.length(), flag = -1, index = 0; + while(index < n - 1){ + if(s.charAt(index) < s.charAt(index + 1)){ + flag = index; + int temp = index + 1, maxn = s.charAt(temp) - '0', maxn_index = temp; + while(temp < n){ + if(s.charAt(temp) - '0' >= maxn){ + maxn_index = temp; + maxn = s.charAt(temp) - '0'; + } + temp++; + } + while(index >= 0){ + if(s.charAt(index) < s.charAt(maxn_index)){ + flag = index; + } + index--; + } + return Integer.parseInt(swap(s, flag, maxn_index)); + } + index++; + } + return num; + } + + private String swap(String s, int index1, int index2){ + StringBuilder sb = new StringBuilder(); + for(int i = 0; i < s.length(); i++){ + if(i == index1){ + sb.append(s.charAt(index2)); + } else if(i == index2){ + sb.append(s.charAt(index1)); + } else { + sb.append(s.charAt(i)); + } + } + return sb.toString(); + } + +} +``` + + + +方法二，贪心： + +从右向左遍历，标记已扫描的数字的最大值，如果当前值大于最大值，则更新最大值下标；如果当前值小于最大值，记录两个数的下标。 + +```Java +class Solution { + public int maximumSwap(int num) { + String s = "" + num; + int n = s.length(), maxn_index = n - 1, index1 = -1, index2 = maxn_index; + for(int i = n - 1; i >= 0; i--){ + if(s.charAt(i) > s.charAt(maxn_index)){ + maxn_index = i; + } else if(s.charAt(i) < s.charAt(maxn_index)){ + index1 = i; + index2 = maxn_index; + } + } + if(index1 != -1){ + return Integer.parseInt(swap(s, index1, index2)); + } + return num; + } + + private String swap(String s, int index1, int index2){ + StringBuilder sb = new StringBuilder(); + for(int i = 0; i < s.length(); i++){ + if(i == index1){ + sb.append(s.charAt(index2)); + } else if(i == index2){ + sb.append(s.charAt(index1)); + } else { + sb.append(s.charAt(i)); + } + } + return sb.toString(); + } + +} +``` \ No newline at end of file From ba972e2e4f06e6f95ff3345989f67d9b60103c6b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 22 Jan 2024 19:47:34 +0800 Subject: [PATCH 224/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7543d9c..324f0d0 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | @@ -248,7 +249,6 @@ | 2022-09-26 15:21 | [#788 旋转数字](https://leetcode.cn/problems/rotated-digits) | MEDIUM | 1 | 1 | | 2022-09-22 09:45 | [#1640 能否连接形成数组](https://leetcode.cn/problems/check-array-formation-through-concatenation) | EASY | 3 | 1 | | 2022-09-13 15:55 | [#1608 特殊数组的特征值](https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x) | EASY | 7 | 1 | -| 2022-09-13 15:06 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 7 | 1 | | 2022-09-09 15:29 | [#1598 文件夹操作日志搜集器](https://leetcode.cn/problems/crawler-log-folder) | EASY | 3 | 1 | | 2022-09-01 13:48 | [#1475 商品折扣后的最终价格](https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop) | EASY | 1 | 1 | | 2022-08-31 13:22 | [#946 验证栈序列](https://leetcode.cn/problems/validate-stack-sequences) | MEDIUM | 2 | 1 | From 70b8aa9f5ebdeda246315af90bea2abc1b6905f4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 22 Jan 2024 20:30:20 +0800 Subject: [PATCH 225/373] =?UTF-8?q?Create=20=E6=B1=82=E5=B9=B3=E6=96=B9?= =?UTF-8?q?=E6=A0=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...02\345\271\263\346\226\271\346\240\271.md" | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 "Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" diff --git "a/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" "b/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" new file mode 100644 index 0000000..ea4d2fa --- /dev/null +++ "b/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" @@ -0,0 +1,33 @@ +#### 求平方根 + +二分查找： + +因为查找的过程中是线性增加的，所以应该想到二分。判断左右节点之差是否小于 `diff`，接着继续二分左右节点之和，再根据其平方是否大于给定数移动左节点或右节点。 + +```java +package src.Algorithm; + +public class SquareRoot { + + public static double squareRoot(int num){ + double diff = 1e-9; + double left = 1.0, right = num * 1.0; + while(right - left > diff){ + double mid = (right + left) / 2.0; + if(mid * mid > num){ + right = mid; + } else { + left = mid; + } + } + String s = left + ""; + return Double.parseDouble(s.substring(0, 11)); + } + + public static void main(String[] args) { + System.out.println(squareRoot(3)); + } +} + +``` + From f0618fa5de160eceed05fa183defa9b8f47f8505 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 09:35:46 +0800 Subject: [PATCH 226/373] =?UTF-8?q?Create=2077.=20=E7=BB=84=E5=90=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "Backtrace/77. \347\273\204\345\220\210.md" | 64 +++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 "Backtrace/77. \347\273\204\345\220\210.md" diff --git "a/Backtrace/77. \347\273\204\345\220\210.md" "b/Backtrace/77. \347\273\204\345\220\210.md" new file mode 100644 index 0000000..c870a70 --- /dev/null +++ "b/Backtrace/77. \347\273\204\345\220\210.md" @@ -0,0 +1,64 @@ +#### 77. 组合 + +难度：中等 + +--- + +给定两个整数 `n` 和 `k`，返回范围 `[1, n]` 中所有可能的 `k` 个数的组合。 + +你可以按 **任何顺序** 返回答案。 + + **示例 1：** + +``` +输入：n = 4, k = 2 +输出： +[ + [2,4], + [3,4], + [2,3], + [1,2], + [1,3], + [1,4], +] +``` + + **示例 2：** + +``` +输入：n = 1, k = 1 +输出：[[1]] +``` + + **提示：** + +* `1 <= n <= 20` +* `1 <= k <= n` + +--- + +回溯 + 记忆化搜索： + +使用一个 `temp` 数组记录搜索过的数字。简单回溯。注意 `res.add(new ArrayList<>(temp));`。 + +```Java +class Solution { + public List> combine(int n, int k) { + List> res = new ArrayList<>(); + backtrace(res, new ArrayList(), n, k, 1); + return res; + } + + private void backtrace(List> res, List temp, int n, int k, int index){ + if(temp.size() == k){ + res.add(new ArrayList<>(temp)); + return; + } + if(index > n) return; + temp.add(index); + backtrace(res, temp, n, k, index + 1); + temp.remove(temp.size() - 1); + backtrace(res, temp, n, k, index + 1); + } +} +``` \ No newline at end of file From cda0991c8cbd1ae46ed298ccf8aeee3307ea2d00 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 09:38:13 +0800 Subject: [PATCH 227/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 324f0d0..e987131 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | From 354db26dbe668026b8f0709c8f7a72f755f796ca Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 12:24:02 +0800 Subject: [PATCH 228/373] =?UTF-8?q?Create=2039.=20=E7=BB=84=E5=90=88?= =?UTF-8?q?=E6=80=BB=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\220\210\346\200\273\345\222\214.md" | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 "Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" diff --git "a/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" "b/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" new file mode 100644 index 0000000..5c0ebb6 --- /dev/null +++ "b/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" @@ -0,0 +1,80 @@ +#### 39. 组合总和 + +难度：中等 + +--- + +给你一个 **无重复元素** 的整数数组 `candidates` 和一个目标整数 `target` ，找出 `candidates` 中可以使数字和为目标数 `target` 的 所有  **不同组合** ，并以列表形式返回。你可以按 **任意顺序** 返回这些组合。 + +`candidates` 中的 **同一个** 数字可以 **无限制重复被选取** 。如果至少一个数字的被选数量不同，则两种组合是不同的。  + +对于给定的输入，保证和为 `target` 的不同组合数少于 `150` 个。 + + **示例 1：** + +``` +输入：candidates = [2,3,6,7], target = 7 +输出：[[2,2,3],[7]] +解释： +2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 +7 也是一个候选， 7 = 7 。 +仅有这两种组合。 +``` + + **示例 2：** + +``` +输入: candidates = [2,3,5], target = 8 +输出: [[2,2,2,2],[2,3,3],[3,5]] +``` + + **示例 3：** + +``` +输入: candidates = [2], target = 1 +输出: [] +``` + + **提示：** + +* `1 <= candidates.length <= 30` +* `2 <= candidates[i] <= 40` +* `candidates` 的所有元素 **互不相同** +* `1 <= target <= 40` + +--- + +回溯 + 剪枝： + +从 `target` 开始，每次回溯都减或不减当前下标的值。本题用到剪枝在于先将数组按升序排序，如果当前下标的值小于 `target` 了，那么后续也不需要遍历了。 + +但与全排列不同的是，本题并不需要用到 `visited` 数组，而是需要记录下标的 `index` 变量： + +- 排列问题，需要考虑顺序时，使用是否遍历过了的 `visited` 数组 +- 组合问题，不考虑顺序时，使用记录下标的 `index` 变量 + +```Java +class Solution { + public List> combinationSum(int[] candidates, int target) { + List> res = new ArrayList<>(); + Arrays.sort(candidates); + backtrace(res, new ArrayList<>(), candidates, 0, target); + return res; + } + + private void backtrace(List> res, List temp, int[] candidates, int index, int target){ + if(target == 0){ + res.add(new ArrayList<>(temp)); + return; + } + for(int i = index; i < candidates.length; i++){ + if(target - candidates[i] < 0) return; + temp.add(candidates[i]); + backtrace(res, temp, candidates, i, target - candidates[i]); + temp.remove(temp.size() - 1); + } + + } + +} +``` \ No newline at end of file From 2dea035113662c8781efcce89508ad044660d7d5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 12:26:39 +0800 Subject: [PATCH 229/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e987131..9c3b6ba 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | | 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | @@ -359,7 +360,6 @@ | 2021-08-03 13:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | | 2021-07-30 19:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | | 2021-07-13 09:53 | [#40 组合总和 II](https://leetcode.cn/problems/combination-sum-ii) | MEDIUM | 3 | 1 | -| 2021-07-13 09:16 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 1 | 1 | | 2021-07-12 19:52 | [#714 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | MEDIUM | 1 | 1 | | 2021-07-12 18:59 | [#740 删除并获得点数](https://leetcode.cn/problems/delete-and-earn) | MEDIUM | 1 | 1 | | 2021-07-06 16:21 | [#746 使用最小花费爬楼梯](https://leetcode.cn/problems/min-cost-climbing-stairs) | EASY | 1 | 1 | From 37b45cafec717a3dbe8e6ffa506d076055dff560 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 16:53:11 +0800 Subject: [PATCH 230/373] =?UTF-8?q?Create=2025.=20K=20=E4=B8=AA=E4=B8=80?= =?UTF-8?q?=E7=BB=84=E7=BF=BB=E8=BD=AC=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...73\350\275\254\351\223\276\350\241\250.md" | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 "Linked List/25. K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.md" diff --git "a/Linked List/25. K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.md" "b/Linked List/25. K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.md" new file mode 100644 index 0000000..4dca00f --- /dev/null +++ "b/Linked List/25. K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.md" @@ -0,0 +1,77 @@ +#### 25. K 个一组翻转链表 + +难度：困难 + +--- + +给你链表的头节点 `head` ，每 `k` 个节点一组进行翻转，请你返回修改后的链表。 + +`k` 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 `k` 的整数倍，那么请将最后剩余的节点保持原有顺序。 + +你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg) +``` +输入：head = [1,2,3,4,5], k = 2 +输出：[2,1,4,3,5] +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg) + +``` +输入：head = [1,2,3,4,5], k = 3 +输出：[3,2,1,4,5] +``` + + **提示：** + +* 链表中的节点数目为 `n` +* `1 <= k <= n <= 5000` +* `0 <= Node.val <= 1000` + + **进阶：** 你可以设计一个只用 `O(1)` 额外内存空间的算法解决此问题吗？ + +--- + +结合 [92. 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii/)，遍历 `k` 个节点后，原地反转链表。 + +![image.png](https://pic.leetcode-cn.com/1615105296-bmiPxl-image.png) + +```Java +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode reverseKGroup(ListNode head, int k) { + ListNode dummy = new ListNode(-1, head), pre = dummy; + while(true){ + ListNode tail = pre; + for(int i = 0; i < k; i++){ + tail = tail.next; + if(tail == null){ + return dummy.next; + } + } + ListNode cur = pre.next, next; + for(int i = 0; i < k - 1; i++){ + next = cur.next; + cur.next = next.next; + next.next = pre.next; + pre.next = next; + } + pre = cur; + } + } +} +``` \ No newline at end of file From ce8483f3cb4e59b5c1f89d51368ee3712e05f734 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 16:55:41 +0800 Subject: [PATCH 231/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 9c3b6ba..e47117b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | +| 2024-01-23 15:55 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 2 | 1 | | 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | | 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | From 35b80bdd64f4ca5c744f99a9774f1444d6b15639 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 21:06:54 +0800 Subject: [PATCH 232/373] =?UTF-8?q?Update=20300.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E9=80=92=E5=A2=9E=E5=AD=90=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\345\255\220\345\272\217\345\210\227.md" | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git "a/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" index 3b1813f..ef2b116 100644 --- "a/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" +++ "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" @@ -66,4 +66,29 @@ class Solution { return ans; } } -``` \ No newline at end of file +``` + + + +或者初始化 `dp` 数组都为 `1`，然后仍然是遍历比较大小。 + +```java +class Solution { + public int lengthOfLIS(int[] nums) { + int n = nums.length; + int[] dp = new int[n]; + for(int i = 0; i < n; i++) dp[i] = 1; + int res = 1; + for(int i = 1; i < nums.length; i++){ + for(int j = 0; j < i; j++){ + if(nums[i] > nums[j]){ + dp[i] = Math.max(dp[i], dp[j] + 1); + } + } + res = Math.max(res, dp[i]); + } + return res; + } +} +``` + From cf495e80a27c16eba38281b283a474f302ab5c21 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 21:10:18 +0800 Subject: [PATCH 233/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e47117b..0ab3ca8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-23 20:59 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 4 | **2** | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | | 2024-01-23 15:55 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 2 | 1 | | 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | @@ -127,7 +128,6 @@ | 2023-04-03 22:13 | [#1053 交换一次的先前排列](https://leetcode.cn/problems/previous-permutation-with-one-swap) | MEDIUM | 4 | 1 | | 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | EASY | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | -| 2023-03-22 20:57 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 3 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | | 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | | 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | From 4e1c582d31ac3381185a514a56000cd961a7fe56 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 22:24:06 +0800 Subject: [PATCH 234/373] =?UTF-8?q?Create=2026.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E6=9C=89=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD=E7=9A=84=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E9=A1=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\351\207\215\345\244\215\351\241\271.md" | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 "Two Pointers/26. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" diff --git "a/Two Pointers/26. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" "b/Two Pointers/26. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" new file mode 100644 index 0000000..fc8deff --- /dev/null +++ "b/Two Pointers/26. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" @@ -0,0 +1,76 @@ +#### 26. 删除有序数组中的重复项 + +难度：简单 + +--- + +给你一个 **非严格递增排列** 的数组 `nums` ，请你 **[原地](http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 删除重复出现的元素，使每个元素 **只出现一次** ，返回删除后数组的新长度。元素的 **相对顺序** 应该保持 **一致** 。然后返回 `nums` 中唯一元素的个数。 + +考虑 `nums` 的唯一元素的数量为 `k` ，你需要做以下事情确保你的题解可以被通过： + +* 更改数组 `nums` ，使 `nums` 的前 `k` 个元素包含唯一元素，并按照它们最初在 `nums` 中出现的顺序排列。`nums` 的其余元素与 `nums` 的大小不重要。 +* 返回 `k` 。 + + **判题标准:** + +系统会用下面的代码来测试你的题解: + +``` +int[] nums = [...]; // 输入数组 +int[] expectedNums = [...]; // 长度正确的期望答案 + +int k = removeDuplicates(nums); // 调用 + +assert k == expectedNums.length; +for (int i = 0; i < k; i++) { + assert nums[i] == expectedNums[i]; +} +``` + +如果所有断言都通过，那么您的题解将被 **通过** 。 + + **示例 1：** + +``` +输入：nums = [1,1,2] +输出：2, nums = [1,2,_] +解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。 +``` + + **示例 2：** + +``` +输入：nums = [0,0,1,1,1,2,2,3,3,4] +输出：5, nums = [0,1,2,3,4] +解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。 +``` + + **提示：** + +* `1 <= nums.length <= 3 * 10^4` +* `-10^4 <= nums[i] <= 10^4` +* `nums` 已按 **非严格递增**  排列 + +--- + +双指针： + +可以理解为快慢指针，`left` 指针指向将被替代的值，`right` 快指针指向待检查的值。 + +判断两指针的元素是否相等，若不相等则将 `right` 指针的元素交给 `left + 1` 并**右移左右指针**；否则只移动右指针。 + +```Java +class Solution { + public int removeDuplicates(int[] nums) { + int n = nums.length, left = 0, right = 0; + if(n <= 1) return n; + while(right < n){ + if(nums[right] != nums[left]){ + nums[++left] = nums[right]; + } + right++; + } + return left + 1; + } +} +``` \ No newline at end of file From fa9a9e7d001db7c7bc6b18df0ff8c810d5f22d58 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 22:24:08 +0800 Subject: [PATCH 235/373] =?UTF-8?q?Create=2080.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E6=9C=89=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD=E7=9A=84=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E9=A1=B9=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...351\207\215\345\244\215\351\241\271 II.md" | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 "Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" diff --git "a/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" "b/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" new file mode 100644 index 0000000..b40912b --- /dev/null +++ "b/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" @@ -0,0 +1,76 @@ +#### 80. 删除有序数组中的重复项 II + +难度：中等 + +--- + +给你一个有序数组 `nums` ，请你 **[原地](http://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95)** 删除重复出现的元素，使得出现次数超过两次的元素 **只出现两次** ，返回删除后数组的新长度。 + +不要使用额外的数组空间，你必须在 **[原地](https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95) 修改输入数组** 并在使用 O(1) 额外空间的条件下完成。 + + **说明：** + +为什么返回数值是整数，但输出的答案是数组呢？ + +请注意，输入数组是以 **「引用」** 方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。 + +你可以想象内部操作如下: + +``` +// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 +int len = removeDuplicates(nums); + +// 在函数里修改输入数组对于调用者是可见的。 +// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 +for (int i = 0; i < len; i++) { +    print(nums[i]); +} +``` + + **示例 1：** + +``` +输入：nums = [1,1,1,2,2,3] +输出：5, nums = [1,1,2,2,3] +解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。 +``` + + **示例 2：** + +``` +输入：nums = [0,0,1,1,1,1,2,3,3] +输出：7, nums = [0,0,1,1,2,3,3] +解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。 +``` + + **提示：** + +* `1 <= nums.length <= 3 * 10^4` +* `-10^4 <= nums[i] <= 10^4` +* `nums` 已按升序排列 + +--- + +快慢指针（或者滑动窗口）： + +慢指针记录被替换的下标，快指针记录待检查的下标。 + +或者是长度为 3 的滑动窗口，该窗口中不能包含相等的元素。 + +```Java +class Solution { + public int removeDuplicates(int[] nums) { + int n = nums.length; + if(n <= 2) return n; + int slow = 2, fast = 2; + while(fast < n){ + if(nums[slow - 2] != nums[fast]){ + nums[slow] = nums[fast]; + slow++; + } + fast++; + } + return slow; + } +} +``` \ No newline at end of file From 7e6b3ee84eb3ae4da0c604065fd20c9f4211b0ee Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 23 Jan 2024 22:27:01 +0800 Subject: [PATCH 236/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 0ab3ca8..540dda2 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | +| 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | | 2024-01-23 20:59 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 4 | **2** | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | | 2024-01-23 15:55 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 2 | 1 | From 1d192512ea7fe94315bba3e49d92d3d027330cf9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 24 Jan 2024 20:28:25 +0800 Subject: [PATCH 237/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 540dda2..c05318b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | | 2024-01-23 20:59 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 4 | **2** | From d2e09f0da23f8fe1db60fe6263fa6cf193e76d7d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 24 Jan 2024 20:41:49 +0800 Subject: [PATCH 238/373] =?UTF-8?q?Create=20274.=20H=20=E6=8C=87=E6=95=B0.?= =?UTF-8?q?md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../274. H \346\214\207\346\225\260.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Dichotomy/274. H \346\214\207\346\225\260.md" diff --git "a/Dichotomy/274. H \346\214\207\346\225\260.md" "b/Dichotomy/274. H \346\214\207\346\225\260.md" new file mode 100644 index 0000000..7d513e0 --- /dev/null +++ "b/Dichotomy/274. H \346\214\207\346\225\260.md" @@ -0,0 +1,61 @@ +#### 274. H 指数 + +难度：中等 + +--- + +给你一个整数数组 `citations` ，其中 `citations[i]` 表示研究者的第 `i` 篇论文被引用的次数。计算并返回该研究者的 **`h` 指数** 。 + +根据维基百科上 [h 指数的定义](https://baike.baidu.com/item/h-index/3991452?fr=aladdin)：`h` 代表“高引用次数” ，一名科研人员的 `h` **指数** 是指他（她）至少发表了 `h` 篇论文，并且  **至少**  有 `h` 篇论文被引用次数大于等于 `h` 。如果 `h` 有多种可能的值， **`h` 指数** 是其中最大的那个。 + + **示例 1：** + +``` +输入：citations = [3,0,6,1,5] +输出：3 +解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。 +  由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。 +``` + + **示例 2：** + +``` +输入：citations = [1,3,1] +输出：1 +``` + + **提示：** + +* `n == citations.length` +* `1 <= n <= 5000` +* `0 <= citations[i] <= 1000` + +--- + +二分： + +显然从 `0` 遍历至 `n` 逐个检查是没问题的，因此二分也适用。 + +此处需要注意的是 `mid` 值的选取，因为 `left = mid`，当 `left + 1 = right` 时会死循环，所以 `mid = (left + right + 1) / 2`。另外每次检查满足条件的话，则最后结果是大于等于该 `h` 值，否则小于。 + +```Java +class Solution { + public int hIndex(int[] citations) { + int n = citations.length, left = 0, right = n; + while(left < right){ + int mid = (right + left + 1) / 2; + if(check(citations, mid)) left = mid; + else right = mid - 1; + } + return left; + } + + private boolean check(int[] citations, int target){ + int cnt = 0; + for(int citation: citations){ + if(citation >= target) cnt++; + } + return cnt >= target; + } +} +``` \ No newline at end of file From f5471830b22df9760d9c2eb8f7505ae06b134b19 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 26 Jan 2024 08:58:48 +0800 Subject: [PATCH 239/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c05318b..e36dbf4 100644 --- a/README.md +++ b/README.md @@ -353,7 +353,7 @@ | 2022-03-22 12:43 | [#2038 如果相邻两个颜色均相同则删除当前颜色](https://leetcode.cn/problems/remove-colored-pieces-if-both-neighbors-are-the-same-color) | MEDIUM | 3 | 1 | | 2022-03-21 15:27 | [#653 两数之和 IV - 输入二叉搜索树](https://leetcode.cn/problems/two-sum-iv-input-is-a-bst) | EASY | 1 | 1 | | 2022-03-20 15:10 | [#2039 网络空闲的时刻](https://leetcode.cn/problems/the-time-when-the-network-becomes-idle) | MEDIUM | 1 | 1 | -| 2022-03-19 15:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | EASY | 3 | 1 | +| 2022-03-19 15:00 | [#606 根据二叉树创建字符串](https://leetcode.cn/problems/construct-string-from-binary-tree) | MEDIUM | 3 | 1 | | 2022-03-18 12:11 | [#2043 简易银行系统](https://leetcode.cn/problems/simple-bank-system) | MEDIUM | 1 | 1 | | 2022-03-17 14:57 | [#720 词典中最长的单词](https://leetcode.cn/problems/longest-word-in-dictionary) | MEDIUM | 8 | 1 | | 2022-03-16 19:29 | [#432 全 O(1) 的数据结构](https://leetcode.cn/problems/all-oone-data-structure) | HARD | 4 | 1 | From 0a4f23e14669e26ccad1c75705a80a354fe866e1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 26 Jan 2024 20:24:00 +0800 Subject: [PATCH 240/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index e36dbf4..d9a7006 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | +| 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | | 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | From 921dd10e3e9f80e6b31f05411427324c2c821881 Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Sat, 27 Jan 2024 08:58:58 +0800 Subject: [PATCH 241/373] =?UTF-8?q?Create=20235.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC?= =?UTF-8?q?=E5=85=B1=E7=A5=96=E5=85=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...54\345\205\261\347\245\226\345\205\210.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Linked List/235. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" diff --git "a/Linked List/235. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" "b/Linked List/235. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" new file mode 100644 index 0000000..fc7ee02 --- /dev/null +++ "b/Linked List/235. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" @@ -0,0 +1,61 @@ +#### 235. 二叉搜索树的最近公共祖先 + +难度：中等 + +--- + +给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 + +[百度百科](https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin)中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（ **一个节点也可以是它自己的祖先** ）。” + +例如，给定如下二叉搜索树:  root = \[6,2,8,0,4,7,9,null,null,3,5\] + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/binarysearchtree_improved.png) + + **示例 1:** + +``` +输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 +输出: 6 +解释: 节点 2 和节点 8 的最近公共祖先是 6。 +``` + + **示例 2:** + +``` +输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 +输出: 2 +解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。 +``` + + **说明:** + +* 所有节点的值都是唯一的。 +* p、q 为不同节点且均存在于给定的二叉搜索树中。 + +--- + +迭代遍历： + +根据二叉搜索树的特点，左子树的值比根节点小，左子树的值比根节点大。每次都将根节点和给定的 `p, q` 两个节点的值进行比较，再将根节点的左子树或右子树赋值给根节点，直到根节点的值在 `p` 和 `q` 节点值之间。因为不确定 `p` 还是 `q` 节点值的大小，所以使用根节点和两个节点差的乘积是否小于零判断。 + +```Java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ + +class Solution { + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + while((long)(root.val - p.val) * (long)(root.val - q.val) > 0){ + root = root.val < p.val ? root.right : root.left; + } + return root; + } +} +``` \ No newline at end of file From bf7385220c7b42fd939dcdc22bd7f51d68442b0a Mon Sep 17 00:00:00 2001 From: Laptop Go Date: Sat, 27 Jan 2024 10:37:14 +0800 Subject: [PATCH 242/373] =?UTF-8?q?Create=2091.=20=E8=A7=A3=E7=A0=81?= =?UTF-8?q?=E6=96=B9=E6=B3=95.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...43\347\240\201\346\226\271\346\263\225.md" | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 "Dynamic Programming/91. \350\247\243\347\240\201\346\226\271\346\263\225.md" diff --git "a/Dynamic Programming/91. \350\247\243\347\240\201\346\226\271\346\263\225.md" "b/Dynamic Programming/91. \350\247\243\347\240\201\346\226\271\346\263\225.md" new file mode 100644 index 0000000..ba2704c --- /dev/null +++ "b/Dynamic Programming/91. \350\247\243\347\240\201\346\226\271\346\263\225.md" @@ -0,0 +1,78 @@ +#### 91. 解码方法 + +难度：中等 + +--- + +一条包含字母 `A-Z` 的消息通过以下映射进行了 **编码** ： + +``` +'A' -> "1" +'B' -> "2" +... +'Z' -> "26" +``` + +要 **解码** 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，`"11106"` 可以映射为： + +* `"AAJF"` ，将消息分组为 `(1 1 10 6)` +* `"KJF"` ，将消息分组为 `(11 10 6)` + +注意，消息不能分组为  `(1 11 06)` ，因为 `"06"` 不能映射为 `"F"` ，这是由于 `"6"` 和 `"06"` 在映射中并不等价。 + +给你一个只含数字的 **非空** 字符串 `s` ，请计算并返回 **解码** 方法的 **总数** 。 + +题目数据保证答案肯定是一个 **32 位** 的整数。 + + **示例 1：** + +``` +输入：s = "12" +输出：2 +解释：它可以解码为 "AB"（1 2）或者 "L"（12）。 +``` + + **示例 2：** + +``` +输入：s = "226" +输出：3 +解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。 +``` + + **示例 3：** + +``` +输入：s = "06" +输出：0 +解释："06" 无法映射到 "F" ，因为存在前导零（"6" 和 "06" 并不等价）。 +``` + + **提示：** + +* `1 <= s.length <= 100` +* `s` 只包含数字，并且可能包含前导零。 + +--- + +动态规划： + +`dp[i]` 指前 `i` 个数可行的总数。初始化 `dp[0] = 1`，状态转移方程为 $dp[i] = \left\{ \begin{array}{rcl} dp[i] += dp[i - 1] & dp[i - 1] != '0' \\ dp[i] += dp[i - 2] & dp[i - 2] != '0' \&\& num <= 26 \end{array}\right.$ + +```Java +class Solution { + public int numDecodings(String s) { + int n = s.length(); + int[] dp = new int[n + 1]; + dp[0] = 1; + for(int i = 1; i <= n; i++){ + if(s.charAt(i - 1) != '0') dp[i] += dp[i - 1]; + if(i > 1 && s.charAt(i - 2) != '0'){ + int temp = (s.charAt(i - 2) - '0') * 10 + s.charAt(i - 1) - '0'; + if(temp <= 26) dp[i] += dp[i - 2]; + } + } + return dp[n]; + } +} +``` \ No newline at end of file From 65e42b7ac4d9d26e2764f761f7e6ca461823a940 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 9 Feb 2024 20:23:51 +0800 Subject: [PATCH 243/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d9a7006..db34ea4 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | | 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | | 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | @@ -33,7 +34,6 @@ | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | | 2024-01-23 20:59 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 4 | **2** | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | -| 2024-01-23 15:55 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 2 | 1 | | 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | | 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | From 81502c886deecd9f4f39643aee9b619d04fc567c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 3 Mar 2024 10:31:16 +0800 Subject: [PATCH 244/373] =?UTF-8?q?Create=20225.=20=E7=94=A8=E9=98=9F?= =?UTF-8?q?=E5=88=97=E5=AE=9E=E7=8E=B0=E6=A0=88.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...27\345\256\236\347\216\260\346\240\210.md" | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 "Queue/225. \347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md" diff --git "a/Queue/225. \347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md" "b/Queue/225. \347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md" new file mode 100644 index 0000000..6f5063b --- /dev/null +++ "b/Queue/225. \347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md" @@ -0,0 +1,101 @@ +#### 225. 用队列实现栈 + +难度：简单 + +--- + +请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（`push`、`top`、`pop` 和 `empty`）。 + +实现 `MyStack` 类： + +* `void push(int x)` 将元素 x 压入栈顶。 +* `int pop()` 移除并返回栈顶元素。 +* `int top()` 返回栈顶元素。 +* `boolean empty()` 如果栈是空的，返回 `true` ；否则，返回 `false` 。 + + **注意：** + +* 你只能使用队列的基本操作 —— 也就是 `push to back`、`peek/pop from front`、`size` 和 `is empty` 这些操作。 +* 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。 + + **示例：** + +``` +输入： +["MyStack", "push", "push", "top", "pop", "empty"] +[[], [1], [2], [], [], []] +输出： +[null, null, null, 2, 2, false] + +解释： +MyStack myStack = new MyStack(); +myStack.push(1); +myStack.push(2); +myStack.top(); // 返回 2 +myStack.pop(); // 返回 2 +myStack.empty(); // 返回 False +``` + + **提示：** + +* `1 <= x <= 9` +* 最多调用`100` 次 `push`、`pop`、`top` 和 `empty` +* 每次调用 `pop` 和 `top` 都保证栈不为空 + + **进阶：** 你能否仅用一个队列来实现栈。 + +--- + +队列： + +固定第一个队列为主队列，第二个队列为辅助队列； + +- 调用 `push()` 时，每次都向主队列插入数据； +- 调用 `pop()` 时，将主队列里的前 `size() - 1` 个数按队列弹出的顺序插入到辅助队列中，清空主队列后再交换主队列和辅助队列； +- 调用 `top()` 时，先调用 `pop()` 方法保存变量，再插入到主队列中，最后返回该变量； +- 调用 `isEmpty()` 时，直接调用主函数的 `isEmpty()` 方法即可。 + +```Java +class MyStack { + ArrayDeque q1, q2; + + public MyStack() { + q1 = new ArrayDeque(); + q2 = new ArrayDeque(); + } + + public void push(int x) { + q1.offer(x); + } + + public int pop() { + int sz = q1.size(); + while(--sz >= 1){ + q2.offer(q1.poll()); + } + ArrayDeque temp = q1; + q1 = q2; + q2 = temp; + return q2.poll(); + } + + public int top() { + int temp = pop(); + q1.offer(temp); + return temp; + } + + public boolean empty() { + return q1.isEmpty(); + } +} + +/** + * Your MyStack object will be instantiated and called as such: + * MyStack obj = new MyStack(); + * obj.push(x); + * int param_2 = obj.pop(); + * int param_3 = obj.top(); + * boolean param_4 = obj.empty(); + */ +``` \ No newline at end of file From ccd4948adf682f23f768e84849683e78ccf0c1d8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 3 Mar 2024 10:34:05 +0800 Subject: [PATCH 245/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index db34ea4..4549928 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-03 09:49 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 1 | 1 | | 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | | 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | From f50b4ba2e61353990851a96758b785ae2d7a47ed Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 3 Mar 2024 20:23:05 +0800 Subject: [PATCH 246/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 4549928..36eab8a 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2024-03-03 09:49 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 1 | 1 | +| 2024-03-03 11:41 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 3 | 1 | | 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | | 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | From 0c301148ff9873f6af10744d999dafaea8ade13a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Mar 2024 14:19:43 +0800 Subject: [PATCH 247/373] =?UTF-8?q?Create=20299.=20=E7=8C=9C=E6=95=B0?= =?UTF-8?q?=E5=AD=97=E6=B8=B8=E6=88=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...60\345\255\227\346\270\270\346\210\217.md" | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 "Hash Table/299. \347\214\234\346\225\260\345\255\227\346\270\270\346\210\217.md" diff --git "a/Hash Table/299. \347\214\234\346\225\260\345\255\227\346\270\270\346\210\217.md" "b/Hash Table/299. \347\214\234\346\225\260\345\255\227\346\270\270\346\210\217.md" new file mode 100644 index 0000000..b5641c7 --- /dev/null +++ "b/Hash Table/299. \347\214\234\346\225\260\345\255\227\346\270\270\346\210\217.md" @@ -0,0 +1,75 @@ +#### 299. 猜数字游戏 + +难度：中等 + +--- + +你在和朋友一起玩 [猜数字（Bulls and Cows）](https://baike.baidu.com/item/%E7%8C%9C%E6%95%B0%E5%AD%97/83200?fromtitle=Bulls+and+Cows&fromid=12003488&fr=aladdin)游戏，该游戏规则如下： + +写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就会给他一个包含下述信息的提示： + +* 猜测数字中有多少位属于数字和确切位置都猜对了（称为 "Bulls"，公牛）， +* 有多少位属于数字猜对了但是位置不对（称为 "Cows"，奶牛）。也就是说，这次猜测中有多少位非公牛数字可以通过重新排列转换成公牛数字。 + +给你一个秘密数字 `secret` 和朋友猜测的数字 `guess` ，请你返回对朋友这次猜测的提示。 + +提示的格式为 `"xAyB"` ，`x` 是公牛个数， `y` 是奶牛个数，`A` 表示公牛，`B` 表示奶牛。 + +请注意秘密数字和朋友猜测的数字都可能含有重复数字。 + + **示例 1：** + +``` +输入：secret = "1807", guess = "7810" +输出："1A3B" +解释：数字和位置都对（公牛）用 '|' 连接，数字猜对位置不对（奶牛）的采用斜体加粗标识。 +"1807" + | +"7810" +``` + + **示例 2：** + +``` +输入：secret = "1123", guess = "0111" +输出："1A1B" +解释：数字和位置都对（公牛）用 '|' 连接，数字猜对位置不对（奶牛）的采用斜体加粗标识。 +"1123" "1123" + | or | +"0111" "0111" +注意，两个不匹配的 1 中，只有一个会算作奶牛（数字猜对位置不对）。通过重新排列非公牛数字，其中仅有一个 1 可以成为公牛数字。 +``` + + **提示：** + +* `1 <= secret.length, guess.length <= 1000` +* `secret.length == guess.length` +* `secret` 和 `guess` 仅由数字组成 + +--- + +哈希表： + +- 当前位置的字符不一致时，使用两个哈希表各自记录当前字符出现的次数，最后再比较两个哈希表中共同元素的最小值，。 + +- 当前位置的字符一致时，即为公牛的个数， + +```go +func getHint(secret string, guess string) string { + sz := len(secret) + var countB, countC int + arrayS, arrayG := make(map[byte]int), make(map[byte]int) + for i := 0; i < sz; i++ { + if secret[i] == guess[i] { + countB++ + } else { + arrayS[secret[i]]++ + arrayG[guess[i]]++ + } + } + for k, v := range arrayS { + countC += min(v, arrayG[k]) + } + return fmt.Sprintf("%dA%dB", countB, countC) +} +``` \ No newline at end of file From cdc77d41ab0b2cb8a1bbfb1e79d3806602eb1d77 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 10 Mar 2024 14:22:26 +0800 Subject: [PATCH 248/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 36eab8a..61bebae 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | | 2024-03-03 11:41 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 3 | 1 | | 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | From 046d03f4e23d55221b36c3a44391ea971f557575 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 12 Mar 2024 20:24:26 +0800 Subject: [PATCH 249/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 61bebae..0513257 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | | 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | | 2024-03-03 11:41 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 3 | 1 | | 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | From fa6e39d84c142960bc1093a067366a6552a272dd Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 15 Mar 2024 14:41:27 +0800 Subject: [PATCH 250/373] =?UTF-8?q?Create=202487.=20=E4=BB=8E=E9=93=BE?= =?UTF-8?q?=E8=A1=A8=E4=B8=AD=E7=A7=BB=E9=99=A4=E8=8A=82=E7=82=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...73\351\231\244\350\212\202\347\202\271.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Depth First Search/2487. \344\273\216\351\223\276\350\241\250\344\270\255\347\247\273\351\231\244\350\212\202\347\202\271.md" diff --git "a/Depth First Search/2487. \344\273\216\351\223\276\350\241\250\344\270\255\347\247\273\351\231\244\350\212\202\347\202\271.md" "b/Depth First Search/2487. \344\273\216\351\223\276\350\241\250\344\270\255\347\247\273\351\231\244\350\212\202\347\202\271.md" new file mode 100644 index 0000000..54ee071 --- /dev/null +++ "b/Depth First Search/2487. \344\273\216\351\223\276\350\241\250\344\270\255\347\247\273\351\231\244\350\212\202\347\202\271.md" @@ -0,0 +1,69 @@ +#### 2487. 从链表中移除节点 + +难度：中等 + +--- + +给你一个链表的头节点 `head` 。 + +移除每个右侧有一个更大数值的节点。 + +返回修改后链表的头节点 `head` 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2022/10/02/drawio.png) + +``` +输入：head = [5,2,13,3,8] +输出：[13,8] +解释：需要移除的节点是 5 ，2 和 3 。 +- 节点 13 在节点 5 右侧。 +- 节点 13 在节点 2 右侧。 +- 节点 8 在节点 3 右侧。 +``` + + **示例 2：** + +``` +输入：head = [1,1,1,1] +输出：[1,1,1,1] +解释：每个节点的值都是 1 ，所以没有需要移除的节点。 +``` + + **提示：** + +* 给定列表中的节点数目在范围 `[1, 10^5]` 内 +* `1 <= Node.val <= 10^5` + +--- +DFS: + +由题意可知，节点对它右侧的所有节点都没有影响，因此对于某一节点，我们可以**对它的右侧节点递归地进行移除操作**： + +- 该节点为空，那么递归函数返回空指针。 + +- 该节点不为空，那么先对它的右侧节点进行移除操作，得到一个新的子链表，如果子链表的表头节点值大于该节点的值，那么移除该节点，否则将该节点作为子链表的表头节点，最后返回该子链表。 + + + +```Go +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func removeNodes(head *ListNode) *ListNode { + if head == nil { + return head + } + head.Next = removeNodes(head.Next) + if head.Next != nil && head.Val < head.Next.Val { + return head.Next + } else { + return head + } +} +``` \ No newline at end of file From 2bc38fbe346db8d1cb81113b9d0ab5861e02d435 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 15 Mar 2024 14:44:00 +0800 Subject: [PATCH 251/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 0513257..4900f92 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | | 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | | 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | | 2024-03-03 11:41 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 3 | 1 | From 27ce06d48de486c2476644fd254d3a2d03128d52 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Mar 2024 11:28:16 +0800 Subject: [PATCH 252/373] =?UTF-8?q?Create=20187.=20=E9=87=8D=E5=A4=8D?= =?UTF-8?q?=E7=9A=84DNA=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...347\232\204DNA\345\272\217\345\210\227.md" | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 "Sliding Window/187. \351\207\215\345\244\215\347\232\204DNA\345\272\217\345\210\227.md" diff --git "a/Sliding Window/187. \351\207\215\345\244\215\347\232\204DNA\345\272\217\345\210\227.md" "b/Sliding Window/187. \351\207\215\345\244\215\347\232\204DNA\345\272\217\345\210\227.md" new file mode 100644 index 0000000..a161c5c --- /dev/null +++ "b/Sliding Window/187. \351\207\215\345\244\215\347\232\204DNA\345\272\217\345\210\227.md" @@ -0,0 +1,52 @@ +#### 187. 重复的DNA序列 + +难度：中等 + +--- + + **DNA序列**  由一系列核苷酸组成，缩写为 `'A'`, `'C'`, `'G'` 和 `'T'`.。 + +* 例如，`"ACGAATTCCG"` 是一个 **DNA序列** 。 + +在研究 **DNA** 时，识别 DNA 中的重复序列非常有用。 + +给定一个表示 **DNA序列** 的字符串 `s` ，返回所有在 DNA 分子中出现不止一次的  **长度为 `10`**  的序列(子字符串)。你可以按 **任意顺序** 返回答案。 + + **示例 1：** + +``` +输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT" +输出：["AAAAACCCCC","CCCCCAAAAA"] +``` + + **示例 2：** + +``` +输入：s = "AAAAAAAAAAAAA" +输出：["AAAAAAAAAA"] +``` + + **提示：** + +* `0 <= s.length <= 10^5` +* `s[i]``==``'A'`、`'C'`、`'G'` or `'T'` + +--- +哈希表 + 固定窗口的滑动： + +固定窗口内的字符作为哈希表的 key， value 为出现的次数。次数等于 2 则加入到 res 里。 + +```Go +func findRepeatedDnaSequences(s string) []string { + var res []string + hashmap := make(map[string]int) + for i := 0; i <= len(s) - 10; i++ { + sub := s[i:i+10] + hashmap[sub]++ + if hashmap[sub] == 2 { + res = append(res, sub) + } + } + return res +} +``` \ No newline at end of file From 9e3cbbe9c5d7782ece92f4cb5df0e5efd6ad0d64 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Mar 2024 11:30:28 +0800 Subject: [PATCH 253/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 4900f92..d9ae31a 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-18 11:20 | [#187 重复的DNA序列](https://leetcode.cn/problems/repeated-dna-sequences) | MEDIUM | 2 | 1 | | 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | | 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | | 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | From f6933aa1f156f1a38fb3397589aa7a2aa4fde53c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Mar 2024 19:53:37 +0800 Subject: [PATCH 254/373] =?UTF-8?q?Create=20658.=20=E6=89=BE=E5=88=B0=20K?= =?UTF-8?q?=20=E4=B8=AA=E6=9C=80=E6=8E=A5=E8=BF=91=E7=9A=84=E5=85=83?= =?UTF-8?q?=E7=B4=A0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...21\347\232\204\345\205\203\347\264\240.md" | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 "Sort/658. \346\211\276\345\210\260 K \344\270\252\346\234\200\346\216\245\350\277\221\347\232\204\345\205\203\347\264\240.md" diff --git "a/Sort/658. \346\211\276\345\210\260 K \344\270\252\346\234\200\346\216\245\350\277\221\347\232\204\345\205\203\347\264\240.md" "b/Sort/658. \346\211\276\345\210\260 K \344\270\252\346\234\200\346\216\245\350\277\221\347\232\204\345\205\203\347\264\240.md" new file mode 100644 index 0000000..9252a05 --- /dev/null +++ "b/Sort/658. \346\211\276\345\210\260 K \344\270\252\346\234\200\346\216\245\350\277\221\347\232\204\345\205\203\347\264\240.md" @@ -0,0 +1,60 @@ +#### 658. 找到 K 个最接近的元素 + +难度：中等 + +--- + +给定一个 **排序好** 的数组 `arr` ，两个整数 `k` 和 `x` ，从数组中找到最靠近 `x`（两数之差最小）的 `k` 个数。返回的结果必须要是按升序排好的。 + +整数 `a` 比整数 `b` 更接近 `x` 需要满足： + +* `|a - x| < |b - x|` 或者 +* `|a - x| == |b - x|` 且 `a < b` + + **示例 1：** + +``` +输入：arr = [1,2,3,4,5], k = 4, x = 3 +输出：[1,2,3,4] +``` + + **示例 2：** + +``` +输入：arr = [1,2,3,4,5], k = 4, x = -1 +输出：[1,2,3,4] +``` + + **提示：** + +* `1 <= k <= arr.length` +* `1 <= arr.length <= 10^4` +* `arr` 按 **升序** 排列 +* `-10^4 <= arr[i], x <= 10^4` + +--- +自定义排序： + +将数组的每个值与 `x` 的差的绝对值进行重新排序，得到的前 `k` 个结果再重新排序即可得到最后答案。 + + +```Go +func findClosestElements(arr []int, k int, x int) []int { + sort.Slice(arr, func(i, j int) bool { + if abs(arr[i] - x) != abs(arr[j] - x){ + return abs(arr[i] - x) < abs(arr[j] - x) + } + return arr[i] < arr[j] + }) + arr = arr[:k] + sort.Ints(arr) + return arr +} + +func abs(num int) int { + if num < 0 { + return -num + } + return num +} +``` \ No newline at end of file From e3b22c63a56cdffd5fb97f7637c29f165c07557d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 18 Mar 2024 19:56:11 +0800 Subject: [PATCH 255/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d9ae31a..cb2c40b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-18 14:24 | [#658 找到 K 个最接近的元素](https://leetcode.cn/problems/find-k-closest-elements) | MEDIUM | 4 | 1 | | 2024-03-18 11:20 | [#187 重复的DNA序列](https://leetcode.cn/problems/repeated-dna-sequences) | MEDIUM | 2 | 1 | | 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | | 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | From 05eaeb015a39aefa9048cb6939a672f59b1415d0 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 19 Mar 2024 19:59:43 +0800 Subject: [PATCH 256/373] =?UTF-8?q?Create=201838.=20=E6=9C=80=E9=AB=98?= =?UTF-8?q?=E9=A2=91=E5=85=83=E7=B4=A0=E7=9A=84=E9=A2=91=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\347\232\204\351\242\221\346\225\260.md" | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 "Sliding Window/1838. \346\234\200\351\253\230\351\242\221\345\205\203\347\264\240\347\232\204\351\242\221\346\225\260.md" diff --git "a/Sliding Window/1838. \346\234\200\351\253\230\351\242\221\345\205\203\347\264\240\347\232\204\351\242\221\346\225\260.md" "b/Sliding Window/1838. \346\234\200\351\253\230\351\242\221\345\205\203\347\264\240\347\232\204\351\242\221\346\225\260.md" new file mode 100644 index 0000000..0be0586 --- /dev/null +++ "b/Sliding Window/1838. \346\234\200\351\253\230\351\242\221\345\205\203\347\264\240\347\232\204\351\242\221\346\225\260.md" @@ -0,0 +1,73 @@ +#### 1838. 最高频元素的频数 + +难度：中等 + +--- + +元素的 **频数** 是该元素在一个数组中出现的次数。 + +给你一个整数数组 `nums` 和一个整数 `k` 。在一步操作中，你可以选择 `nums` 的一个下标，并将该下标对应元素的值增加 `1` 。 + +执行最多 `k` 次操作后，返回数组中最高频元素的 **最大可能频数** _。_ + + **示例 1：** + +``` +输入：nums = [1,2,4], k = 5 +输出：3 +解释：对第一个元素执行 3 次递增操作，对第二个元素执 2 次递增操作，此时 nums = [4,4,4] 。 +4 是数组中最高频元素，频数是 3 。 +``` + + **示例 2：** + +``` +输入：nums = [1,4,8,13], k = 5 +输出：2 +解释：存在多种最优解决方案： +- 对第一个元素执行 3 次递增操作，此时 nums = [4,4,8,13] 。4 是数组中最高频元素，频数是 2 。 +- 对第二个元素执行 4 次递增操作，此时 nums = [1,8,8,13] 。8 是数组中最高频元素，频数是 2 。 +- 对第三个元素执行 5 次递增操作，此时 nums = [1,4,13,13] 。13 是数组中最高频元素，频数是 2 。 +``` + + **示例 3：** + +``` +输入：nums = [3,9,6], k = 2 +输出：1 +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `1 <= nums[i] <= 10^5` +* `1 <= k <= 10^5` + +--- + +滑动窗口： + +题目类似于补全两个下标之间的数以到达同一水平线，窗口内记录补全需要的总数，如果总数大于 `k`，则左下标向右移动，否则右下标继续向右移动。 + +```Go +func maxFrequency(nums []int, k int) int { + sort.Ints(nums) + ans := 1 + for left, right, total := 0, 1, 0; right < len(nums); right ++ { + total += (nums[right] - nums[right -1]) * (right - left) + if total > k { + total -= nums[right] - nums[left] + left++ + } + ans = max(ans, right - left + 1) + } + return ans +} + +func max(num1, num2 int) int { + if num1 > num2 { + return num1 + } + return num2 +} +``` \ No newline at end of file From b932c51d0460f0cbc5568b3e0fe0265b60ab559f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 19 Mar 2024 20:03:16 +0800 Subject: [PATCH 257/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index cb2c40b..cac2e17 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-19 19:39 | [#1838 最高频元素的频数](https://leetcode.cn/problems/frequency-of-the-most-frequent-element) | MEDIUM | 1 | 1 | | 2024-03-18 14:24 | [#658 找到 K 个最接近的元素](https://leetcode.cn/problems/find-k-closest-elements) | MEDIUM | 4 | 1 | | 2024-03-18 11:20 | [#187 重复的DNA序列](https://leetcode.cn/problems/repeated-dna-sequences) | MEDIUM | 2 | 1 | | 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | From f7f527b3c7f262ca73c7083ecc3ef7b43a6d32af Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 23 Mar 2024 20:26:39 +0800 Subject: [PATCH 258/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index cac2e17..69ee678 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-23 16:02 | [#1471 数组中的 k 个最强值](https://leetcode.cn/problems/the-k-strongest-values-in-an-array) | MEDIUM | 1 | 1 | | 2024-03-19 19:39 | [#1838 最高频元素的频数](https://leetcode.cn/problems/frequency-of-the-most-frequent-element) | MEDIUM | 1 | 1 | | 2024-03-18 14:24 | [#658 找到 K 个最接近的元素](https://leetcode.cn/problems/find-k-closest-elements) | MEDIUM | 4 | 1 | | 2024-03-18 11:20 | [#187 重复的DNA序列](https://leetcode.cn/problems/repeated-dna-sequences) | MEDIUM | 2 | 1 | From dbac3e516a851dd8371f1ec703352feb979b5871 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 31 Mar 2024 20:24:14 +0800 Subject: [PATCH 259/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 69ee678..6d4405e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-03-31 14:08 | [#424 替换后的最长重复字符](https://leetcode.cn/problems/longest-repeating-character-replacement) | MEDIUM | 2 | 1 | | 2024-03-23 16:02 | [#1471 数组中的 k 个最强值](https://leetcode.cn/problems/the-k-strongest-values-in-an-array) | MEDIUM | 1 | 1 | | 2024-03-19 19:39 | [#1838 最高频元素的频数](https://leetcode.cn/problems/frequency-of-the-most-frequent-element) | MEDIUM | 1 | 1 | | 2024-03-18 14:24 | [#658 找到 K 个最接近的元素](https://leetcode.cn/problems/find-k-closest-elements) | MEDIUM | 4 | 1 | From 769ecf784721df224f3d60d195b03e25fa064521 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 18 Apr 2024 20:24:56 +0800 Subject: [PATCH 260/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6d4405e..594cb33 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-04-18 14:51 | [#525 连续数组](https://leetcode.cn/problems/contiguous-array) | MEDIUM | 1 | 1 | | 2024-03-31 14:08 | [#424 替换后的最长重复字符](https://leetcode.cn/problems/longest-repeating-character-replacement) | MEDIUM | 2 | 1 | | 2024-03-23 16:02 | [#1471 数组中的 k 个最强值](https://leetcode.cn/problems/the-k-strongest-values-in-an-array) | MEDIUM | 1 | 1 | | 2024-03-19 19:39 | [#1838 最高频元素的频数](https://leetcode.cn/problems/frequency-of-the-most-frequent-element) | MEDIUM | 1 | 1 | From 4ae39dc03657aa38069210f5f97c788ef4e303c7 Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 26 May 2024 14:59:02 +0800 Subject: [PATCH 261/373] =?UTF-8?q?Update=2080.=20=E5=88=A0=E9=99=A4?= =?UTF-8?q?=E6=9C=89=E5=BA=8F=E6=95=B0=E7=BB=84=E4=B8=AD=E7=9A=84=E9=87=8D?= =?UTF-8?q?=E5=A4=8D=E9=A1=B9=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...351\207\215\345\244\215\351\241\271 II.md" | 25 ++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git "a/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" "b/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" index b40912b..e67dd51 100644 --- "a/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" +++ "b/Two Pointers/80. \345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271 II.md" @@ -51,13 +51,12 @@ for (int i = 0; i < len; i++) { --- -快慢指针（或者滑动窗口）： +快慢指针： 慢指针记录被替换的下标，快指针记录待检查的下标。 -或者是长度为 3 的滑动窗口，该窗口中不能包含相等的元素。 - ```Java +//Java class Solution { public int removeDuplicates(int[] nums) { int n = nums.length; @@ -73,4 +72,24 @@ class Solution { return slow; } } +``` + + +```go +//Go +func removeDuplicates(nums []int) int { + n := len(nums) + if n <= 2 { + return n + } + slow, fast := 2, 2 + for ;fast < n; { + if nums[slow - 2] != nums[fast] { + nums[slow] = nums[fast] + slow++ + } + fast++ + } + return slow +} ``` \ No newline at end of file From ed655e189c93362d7f2a238d723ad495900087ac Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 26 May 2024 15:03:08 +0800 Subject: [PATCH 262/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 594cb33..b1676d9 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-05-06 11:57 | [#382 链表随机节点](https://leetcode.cn/problems/linked-list-random-node) | MEDIUM | 3 | 1 | +| 2024-05-06 11:07 | [#413 等差数列划分](https://leetcode.cn/problems/arithmetic-slices) | MEDIUM | 1 | 1 | | 2024-04-18 14:51 | [#525 连续数组](https://leetcode.cn/problems/contiguous-array) | MEDIUM | 1 | 1 | | 2024-03-31 14:08 | [#424 替换后的最长重复字符](https://leetcode.cn/problems/longest-repeating-character-replacement) | MEDIUM | 2 | 1 | | 2024-03-23 16:02 | [#1471 数组中的 k 个最强值](https://leetcode.cn/problems/the-k-strongest-values-in-an-array) | MEDIUM | 1 | 1 | From 47303a31ef61def0307a7897fd84f85e1c90f3b9 Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 26 May 2024 15:36:53 +0800 Subject: [PATCH 263/373] =?UTF-8?q?Update=20189.=20=E8=BD=AE=E8=BD=AC?= =?UTF-8?q?=E6=95=B0=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...56\350\275\254\346\225\260\347\273\204.md" | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git "a/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" "b/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" index 5383d3f..bba72ff 100644 --- "a/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" +++ "b/Methodology/189. \350\275\256\350\275\254\346\225\260\347\273\204.md" @@ -47,6 +47,7 @@ 另外，如果是 **向左轮转**，则是先反转整个数组，再各自反转 `[0, n - 1 - (k mod n)]` 和 `[n - (k mod n), n - 1]`。 ```Java +// Java class Solution { public void rotate(int[] nums, int k) { int n = nums.length; @@ -66,4 +67,36 @@ class Solution { } } } +``` + +```go +// Go +func rotate(nums []int, k int) { + n := len(nums) + reverse(nums, 0, n - 1 - k) + reverse(nums, n - k, n - 1) + reverse(nums, 0, n - 1) +} + +func reverse(nums []int, left, right int) { + for ;left < right; { + nums[left], nums[right] = nums[right], nums[left] + left++ + right-- + } +} +``` + +方法二：额外数组 + +```go +func rotate(nums []int, k int) { + n := len(nums) + arr := make([]int, n) + k = k % n + for index := range nums { + arr[index] = nums[(n - k + index) % n] + } + copy(nums, arr) +} ``` \ No newline at end of file From 40417f95d2e462725525da1f1f4b7640557d4cd4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 26 May 2024 15:39:16 +0800 Subject: [PATCH 264/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b1676d9..8babd62 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-05-26 15:35 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 3 | **2** | | 2024-05-06 11:57 | [#382 链表随机节点](https://leetcode.cn/problems/linked-list-random-node) | MEDIUM | 3 | 1 | | 2024-05-06 11:07 | [#413 等差数列划分](https://leetcode.cn/problems/arithmetic-slices) | MEDIUM | 1 | 1 | | 2024-04-18 14:51 | [#525 连续数组](https://leetcode.cn/problems/contiguous-array) | MEDIUM | 1 | 1 | @@ -55,7 +56,6 @@ | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | -| 2024-01-18 10:12 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | From e5fb6418d7fdb74e343e5e956ba657ae3259930c Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 14 Jun 2024 21:52:57 +0800 Subject: [PATCH 265/373] =?UTF-8?q?Create=202786.=20=E8=AE=BF=E9=97=AE?= =?UTF-8?q?=E6=95=B0=E7=BB=84=E4=B8=AD=E7=9A=84=E4=BD=8D=E7=BD=AE=E4=BD=BF?= =?UTF-8?q?=E5=88=86=E6=95=B0=E6=9C=80=E5=A4=A7.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...06\346\225\260\346\234\200\345\244\247.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Dynamic Programming/2786. \350\256\277\351\227\256\346\225\260\347\273\204\344\270\255\347\232\204\344\275\215\347\275\256\344\275\277\345\210\206\346\225\260\346\234\200\345\244\247.md" diff --git "a/Dynamic Programming/2786. \350\256\277\351\227\256\346\225\260\347\273\204\344\270\255\347\232\204\344\275\215\347\275\256\344\275\277\345\210\206\346\225\260\346\234\200\345\244\247.md" "b/Dynamic Programming/2786. \350\256\277\351\227\256\346\225\260\347\273\204\344\270\255\347\232\204\344\275\215\347\275\256\344\275\277\345\210\206\346\225\260\346\234\200\345\244\247.md" new file mode 100644 index 0000000..dc4ff58 --- /dev/null +++ "b/Dynamic Programming/2786. \350\256\277\351\227\256\346\225\260\347\273\204\344\270\255\347\232\204\344\275\215\347\275\256\344\275\277\345\210\206\346\225\260\346\234\200\345\244\247.md" @@ -0,0 +1,61 @@ +#### 2786. 访问数组中的位置使分数最大 + +难度：中等 + +--- + +给你一个下标从 **0**  开始的整数数组 `nums` 和一个正整数 `x` 。 + +你 **一开始**  在数组的位置 `0` 处，你可以按照下述规则访问数组中的其他位置： + +* 如果你当前在位置 `i` ，那么你可以移动到满足 `i < j` 的  **任意**  位置 `j` 。 +* 对于你访问的位置 `i` ，你可以获得分数 `nums[i]` 。 +* 如果你从位置 `i` 移动到位置 `j` 且 `nums[i]` 和 `nums[j]` 的 **奇偶性**  不同，那么你将失去分数 `x` 。 + +请你返回你能得到的 **最大**  得分之和。 + + **注意**  ，你一开始的分数为 `nums[0]` 。 + + **示例 1：** + +``` +输入：nums = [2,3,6,1,9,2], x = 5 +输出：13 +解释：我们可以按顺序访问数组中的位置：0 -> 2 -> 3 -> 4 。 +对应位置的值为 2 ，6 ，1 和 9 。因为 6 和 1 的奇偶性不同，所以下标从 2 -> 3 让你失去 x = 5 分。 +总得分为：2 + 6 + 1 + 9 - 5 = 13 。 +``` + + **示例 2：** + +``` +输入：nums = [2,4,6,8], x = 3 +输出：20 +解释：数组中的所有元素奇偶性都一样，所以我们可以将每个元素都访问一次，而且不会失去任何分数。 +总得分为：2 + 4 + 6 + 8 = 20 。 +``` + + **提示：** + +* `2 <= nums.length <= 10^5` +* `1 <= nums[i], x <= 10^6` + +--- + +动态规划： + +从左往右遍历的过程中，只取决于最近偶数时和最近奇数时得分的最大值。然后再根据当前值和两个最大值进行比较，取更大者即可。 + +```Go +func maxScore(nums []int, x int) int64 { + res := int64(nums[0]) + dp := []int64{math.MinInt32, math.MinInt32} + dp[nums[0] % 2] = int64(nums[0]) + for i := 1; i < len(nums); i++ { + maxn := max(dp[nums[i] % 2], dp[(nums[i] + 1) % 2] - int64(x)) + int64(nums[i]) + res = max(res, maxn) + dp[nums[i] % 2] = max(dp[nums[i] % 2], maxn) + } + return res +} +``` \ No newline at end of file From d305e81f0aa4d693cb34199795456a006c18925d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 14 Jun 2024 21:56:03 +0800 Subject: [PATCH 266/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8babd62..37eb1b6 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | | 2024-05-26 15:35 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 3 | **2** | | 2024-05-06 11:57 | [#382 链表随机节点](https://leetcode.cn/problems/linked-list-random-node) | MEDIUM | 3 | 1 | | 2024-05-06 11:07 | [#413 等差数列划分](https://leetcode.cn/problems/arithmetic-slices) | MEDIUM | 1 | 1 | From 6d71b7d5c5da9801d22537e87ccbcd969eb85b16 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 15 Jun 2024 14:37:53 +0800 Subject: [PATCH 267/373] =?UTF-8?q?Create=202779.=20=E6=95=B0=E7=BB=84?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E7=BE=8E=E4=B8=BD=E5=80=BC.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...47\347\276\216\344\270\275\345\200\274.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Sliding Window/2779. \346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\347\276\216\344\270\275\345\200\274.md" diff --git "a/Sliding Window/2779. \346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\347\276\216\344\270\275\345\200\274.md" "b/Sliding Window/2779. \346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\347\276\216\344\270\275\345\200\274.md" new file mode 100644 index 0000000..c18deac --- /dev/null +++ "b/Sliding Window/2779. \346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\347\276\216\344\270\275\345\200\274.md" @@ -0,0 +1,69 @@ +#### 2779. 数组的最大美丽值 + +难度：中等 + +--- + +给你一个下标从 **0** 开始的整数数组 `nums` 和一个 **非负** 整数 `k` 。 + +在一步操作中，你可以执行下述指令： + +* 在范围 `[0, nums.length - 1]` 中选择一个 **此前没有选过** 的下标 `i` 。 +* 将 `nums[i]` 替换为范围 `[nums[i] - k, nums[i] + k]` 内的任一整数。 + +数组的 **美丽值** 定义为数组中由相等元素组成的最长子序列的长度。 + +对数组 `nums` 执行上述操作任意次后，返回数组可能取得的 **最大** 美丽值。 + + **注意：** 你 **只** 能对每个下标执行 **一次** 此操作。 + +数组的 **子序列** 定义是：经由原数组删除一些元素（也可能不删除）得到的一个新数组，且在此过程中剩余元素的顺序不发生改变。 + + **示例 1：** + +``` +输入：nums = [4,6,1,2], k = 2 +输出：3 +解释：在这个示例中，我们执行下述操作： +- 选择下标 1 ，将其替换为 4（从范围 [4,8] 中选出），此时 nums = [4,4,1,2] 。 +- 选择下标 3 ，将其替换为 4（从范围 [0,4] 中选出），此时 nums = [4,4,1,4] 。 +执行上述操作后，数组的美丽值是 3（子序列由下标 0 、1 、3 对应的元素组成）。 +可以证明 3 是我们可以得到的由相等元素组成的最长子序列长度。 +``` + + **示例 2：** + +``` +输入：nums = [1,1,1,1], k = 10 +输出：4 +解释：在这个示例中，我们无需执行任何操作。 +数组 nums 的美丽值是 4（整个数组）。 +``` + + **提示：** + +* `1 <= nums.length <= 10^5` +* `0 <= nums[i], k <= 10^5` + +--- + +排序 + 滑动窗口： + +根据题目对子序列的定义，我们知道元素的顺序对数组的美丽值无影响，因此考虑先排序。 + +初始化窗口长度为一，并枚举右端点（右端点不断的向右移动），当右端点的下一位数与左端点的差大于两倍的 `k`，左端点向右移动一位。 + +这样能保证窗口长度只增不减，一定是最大美丽值。 + +```Go +func maximumBeauty(nums []int, k int) int { + sort.Ints(nums) + left, right := 0, 0 + for ;right < len(nums) - 1; right++ { + if nums[right + 1] - nums[left] > 2 * k { + left++ + } + } + return right - left + 1 +} +``` \ No newline at end of file From 6c977df2ab1d76216a90917f98eb949488e3c3a2 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 15 Jun 2024 14:40:42 +0800 Subject: [PATCH 268/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 37eb1b6..f83c039 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | | 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | | 2024-05-26 15:35 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 3 | **2** | | 2024-05-06 11:57 | [#382 链表随机节点](https://leetcode.cn/problems/linked-list-random-node) | MEDIUM | 3 | 1 | From 3a120df124e3e1f72702bc27c6964024d3781ce5 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 15 Jun 2024 16:06:05 +0800 Subject: [PATCH 269/373] =?UTF-8?q?Update=20300.=20=E6=9C=80=E9=95=BF?= =?UTF-8?q?=E9=80=92=E5=A2=9E=E5=AD=90=E5=BA=8F=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\345\255\220\345\272\217\345\210\227.md" | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git "a/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" index ef2b116..5b6dd1c 100644 --- "a/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" +++ "b/Dynamic Programming/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" @@ -92,3 +92,26 @@ class Solution { } ``` + + +Go 语言： + +```go +func lengthOfLIS(nums []int) int { + dp := make([]int, len(nums)) + dp[0] = 1 + res := dp[0] + for i := 1; i < len(nums); i++ { + maxn := 0 + for j := 0; j < i; j++ { + if nums[i] > nums[j] { + maxn = max(maxn, dp[j]) + } + } + dp[i] = maxn + 1 + res = max(res, dp[i]) + } + return res +} +``` + From 2f6293db64c2c6c251611245897412aa648ce9d8 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 15 Jun 2024 20:10:45 +0800 Subject: [PATCH 270/373] =?UTF-8?q?Create=2022.=20=E6=8B=AC=E5=8F=B7?= =?UTF-8?q?=E7=94=9F=E6=88=90.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...54\345\217\267\347\224\237\346\210\220.md" | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 "Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" diff --git "a/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" "b/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" new file mode 100644 index 0000000..d5dee33 --- /dev/null +++ "b/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" @@ -0,0 +1,56 @@ +#### 22. 括号生成 + +难度：中等 + +--- + +数字 `n` 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 **有效的** 括号组合。 + + **示例 1：** + +``` +输入：n = 3 +输出：["((()))","(()())","(())()","()(())","()()()"] +``` + + **示例 2：** + +``` +输入：n = 1 +输出：["()"] +``` + + **提示：** + +* `1 <= n <= 8` + +--- + +深度优先搜索： + +用两个变量分别记录左/右括号剩余的数量，显然，左括号剩余的数量一定不能大于右括号剩余的数量。 + +只要左括号剩余的数量大于零，就要将该数量减一并继续递归。只有当右括号剩余的数量大于左括号剩余的数量时，才继续递归。 + +```Go +func generateParenthesis(n int) []string { + res := []string{} + var dfs func(num1, num2 int, s string) + dfs = func(num1, num2 int, s string) { + if len(s) == 2 * n { + res = append(res, s) + return + } + if num1 > 0 { + dfs(num1 - 1, num2, s + "(") + } + if num1 < num2 { + dfs(num1, num2 - 1, s + ")") + } + } + dfs(n, n, "") + return res +} + + +``` \ No newline at end of file From 03c78c66e041b377acc15995ad9812bc2413918c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 15 Jun 2024 20:13:30 +0800 Subject: [PATCH 271/373] Update changes --- README.md | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/README.md b/README.md index f83c039..2b78f5d 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | | 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | | 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | | 2024-05-26 15:35 | [#189 轮转数组](https://leetcode.cn/problems/rotate-array) | MEDIUM | 3 | **2** | @@ -47,7 +48,6 @@ | 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | -| 2024-01-23 20:59 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 4 | **2** | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | | 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | | 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | @@ -82,7 +82,6 @@ | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | | 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | -| 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | @@ -317,8 +316,6 @@ | 2022-05-12 21:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | | 2022-05-10 15:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | | 2022-05-09 14:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | -| 2022-05-09 14:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | -| 2022-05-09 14:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | | 2022-05-09 13:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | | 2022-05-08 10:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | | 2022-05-07 20:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | @@ -332,7 +329,6 @@ | 2022-05-02 14:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | | 2022-05-01 17:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | | 2022-04-30 14:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | -| 2022-04-29 15:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | | 2022-04-28 12:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | | 2022-04-26 19:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | | 2022-04-25 12:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | @@ -351,7 +347,6 @@ | 2022-04-11 15:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | | 2022-04-10 12:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | | 2022-04-09 18:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | -| 2022-04-08 11:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | | 2022-04-06 14:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | | 2022-04-05 15:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | | 2022-04-03 20:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | @@ -376,7 +371,6 @@ | 2022-03-15 15:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | | 2022-03-14 11:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | | 2022-03-13 16:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | -| 2022-03-12 13:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | | 2021-09-14 15:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | | 2021-08-03 13:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | | 2021-07-30 19:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | From 56ce52278282eb3c5331c23ac58164f3f9c869cb Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 16 Jun 2024 14:32:04 +0800 Subject: [PATCH 272/373] =?UTF-8?q?Update=2022.=20=E6=8B=AC=E5=8F=B7?= =?UTF-8?q?=E7=94=9F=E6=88=90.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../22. \346\213\254\345\217\267\347\224\237\346\210\220.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" "b/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" index d5dee33..82e2693 100644 --- "a/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" +++ "b/Depth First Search/22. \346\213\254\345\217\267\347\224\237\346\210\220.md" @@ -42,7 +42,7 @@ func generateParenthesis(n int) []string { return } if num1 > 0 { - dfs(num1 - 1, num2, s + "(") + dfs(num1 - 1, num2, s + "(") // 类似于回溯，此处不对字符串 s 本身做修改，所以不需要新增字符串再删除字符串的操作 } if num1 < num2 { dfs(num1, num2 - 1, s + ")") From 650453c90cfde8dc033cce7bdc6fa89fbd1a52f1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 16 Jun 2024 14:35:05 +0800 Subject: [PATCH 273/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2b78f5d..801d294 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-16 13:51 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 3 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | | 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | | 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | @@ -381,7 +382,6 @@ | 2021-07-05 15:44 | [#120 三角形最小路径和](https://leetcode.cn/problems/triangle) | MEDIUM | 2 | 1 | | 2021-07-05 14:12 | [#55 跳跃游戏](https://leetcode.cn/problems/jump-game) | MEDIUM | 4 | 1 | | 2021-07-05 13:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | -| 2021-07-05 13:03 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 2 | **2** | | 2021-07-05 12:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | | 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | | 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | From 31ba06294cfaa4a695928c28f09f88e9badd807e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 18 Jun 2024 09:05:29 +0800 Subject: [PATCH 274/373] Update changes --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 801d294..46c37f8 100644 --- a/README.md +++ b/README.md @@ -83,6 +83,7 @@ | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | | 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | +| 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | @@ -317,6 +318,8 @@ | 2022-05-12 21:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | | 2022-05-10 15:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | | 2022-05-09 14:49 | [#107 二叉树的层序遍历 II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii) | MEDIUM | 2 | 1 | +| 2022-05-09 14:35 | [#117 填充每个节点的下一个右侧节点指针 II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii) | MEDIUM | 1 | 1 | +| 2022-05-09 14:32 | [#116 填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node) | MEDIUM | 2 | 1 | | 2022-05-09 13:49 | [#942 增减字符串匹配](https://leetcode.cn/problems/di-string-match) | EASY | 1 | 1 | | 2022-05-08 10:22 | [#442 数组中重复的数据](https://leetcode.cn/problems/find-all-duplicates-in-an-array) | MEDIUM | 1 | 1 | | 2022-05-07 20:21 | [#207 课程表](https://leetcode.cn/problems/course-schedule) | MEDIUM | 2 | 1 | @@ -330,6 +333,7 @@ | 2022-05-02 14:17 | [#796 旋转字符串](https://leetcode.cn/problems/rotate-string) | EASY | 4 | **2** | | 2022-05-01 17:59 | [#1305 两棵二叉搜索树中的所有元素](https://leetcode.cn/problems/all-elements-in-two-binary-search-trees) | MEDIUM | 3 | 1 | | 2022-04-30 14:28 | [#908 最小差值 I](https://leetcode.cn/problems/smallest-range-i) | EASY | 6 | 1 | +| 2022-04-29 15:45 | [#427 建立四叉树](https://leetcode.cn/problems/construct-quad-tree) | MEDIUM | 1 | 1 | | 2022-04-28 12:36 | [#905 按奇偶排序数组](https://leetcode.cn/problems/sort-array-by-parity) | EASY | 2 | 1 | | 2022-04-26 19:39 | [#883 三维形体投影面积](https://leetcode.cn/problems/projection-area-of-3d-shapes) | EASY | 2 | 1 | | 2022-04-25 12:52 | [#398 随机数索引](https://leetcode.cn/problems/random-pick-index) | MEDIUM | 2 | 1 | @@ -348,6 +352,7 @@ | 2022-04-11 15:05 | [#357 统计各位数字都不同的数字个数](https://leetcode.cn/problems/count-numbers-with-unique-digits) | MEDIUM | 1 | 1 | | 2022-04-10 12:27 | [#804 唯一摩尔斯密码词](https://leetcode.cn/problems/unique-morse-code-words) | EASY | 1 | 1 | | 2022-04-09 18:33 | [#780 到达终点](https://leetcode.cn/problems/reaching-points) | HARD | 6 | 1 | +| 2022-04-08 11:24 | [#429 N 叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal) | MEDIUM | 2 | 1 | | 2022-04-06 14:13 | [#310 最小高度树](https://leetcode.cn/problems/minimum-height-trees) | MEDIUM | 1 | 1 | | 2022-04-05 15:42 | [#762 二进制表示中质数个计算置位](https://leetcode.cn/problems/prime-number-of-set-bits-in-binary-representation) | EASY | 3 | 1 | | 2022-04-03 20:29 | [#744 寻找比目标字母大的最小字母](https://leetcode.cn/problems/find-smallest-letter-greater-than-target) | EASY | 8 | 1 | @@ -372,6 +377,7 @@ | 2022-03-15 15:21 | [#2044 统计按位或能得到最大值的子集数目](https://leetcode.cn/problems/count-number-of-maximum-bitwise-or-subsets) | MEDIUM | 6 | 1 | | 2022-03-14 11:27 | [#599 两个列表的最小索引总和](https://leetcode.cn/problems/minimum-index-sum-of-two-lists) | EASY | 2 | 1 | | 2022-03-13 16:05 | [#393 UTF-8 编码验证](https://leetcode.cn/problems/utf-8-validation) | MEDIUM | 10 | 1 | +| 2022-03-12 13:21 | [#590 N 叉树的后序遍历](https://leetcode.cn/problems/n-ary-tree-postorder-traversal) | EASY | 1 | 1 | | 2021-09-14 15:09 | [#524 通过删除字母匹配到字典里最长单词](https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting) | MEDIUM | 3 | 1 | | 2021-08-03 13:57 | [#581 最短无序连续子数组](https://leetcode.cn/problems/shortest-unsorted-continuous-subarray) | MEDIUM | 8 | 1 | | 2021-07-30 19:34 | [#171 Excel 表列序号](https://leetcode.cn/problems/excel-sheet-column-number) | EASY | 5 | 1 | From 89a7d37e38792093bee6c3ddf4c27962a2a2406d Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 23 Jun 2024 16:26:00 +0800 Subject: [PATCH 275/373] =?UTF-8?q?Update=2031.=20=E4=B8=8B=E4=B8=80?= =?UTF-8?q?=E4=B8=AA=E6=8E=92=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\270\252\346\216\222\345\210\227.md" | 30 ++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git "a/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" index 7f198c4..ab506bb 100644 --- "a/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" +++ "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" @@ -82,4 +82,32 @@ class Solution { nums[j] = temp; } } -``` \ No newline at end of file +``` + + + +Go： + +```go +func nextPermutation(nums []int) { + i, j := 0, len(nums) - 1 + for ;j > 0; j-- { + if nums[j] > nums[j - 1] { + i = j - 1 + break + } + } + for k := len(nums) - 1; k >= j; k-- { + if nums[k] > nums[i] { + nums[i], nums[k] = nums[k], nums[i] + break + } + } + + for k := len(nums) - 1; k > j; k, j = k - 1, j + 1 { + nums[j], nums[k] = nums[k], nums[j] + } + return +} +``` + From 6fd1f0413a20b92cd697f39c44573f6b5158adfd Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 23 Jun 2024 16:28:45 +0800 Subject: [PATCH 276/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 46c37f8..89c9dfe 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-23 15:47 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 6 | **3** | | 2024-06-16 13:51 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 3 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | | 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | @@ -107,7 +108,6 @@ | 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | -| 2023-09-11 20:06 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 4 | **2** | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | From 87417c5123c5a6a930bf552cc27f191d06c917c4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 23 Jun 2024 20:27:07 +0800 Subject: [PATCH 277/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 89c9dfe..ffd6d77 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-06-23 19:20 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 2 | **2** | | 2024-06-23 15:47 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 6 | **3** | | 2024-06-16 13:51 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 3 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | @@ -97,7 +98,6 @@ | 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | -| 2023-10-05 18:14 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | | 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | From ed62a18c1cf0b13a688730d674809d1117d5f47e Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 29 Jun 2024 20:00:30 +0800 Subject: [PATCH 278/373] =?UTF-8?q?Update=20122.=20=E4=B9=B0=E5=8D=96?= =?UTF-8?q?=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6=E6=9C=BA?= =?UTF-8?q?=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\344\275\263\346\227\266\346\234\272 II.md" | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git "a/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" "b/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" index 0326111..743e737 100644 --- "a/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" +++ "b/Dynamic Programming/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" @@ -44,7 +44,7 @@ --- -动态规划： +贪心/动态规划： 一次遍历。`dp[i]` 表示从第一天到第 `i + 1` 天内的最大利润（并不意味着第 `i + 1` 天卖出股票），其值要么是上一个值，要么是上一个值加上**当前价格与昨天价格的差**（这样做的原因是题目中允许当天购买和出售），最后返回数组最后一位值即可。 @@ -58,5 +58,19 @@ class Solution { } return dp[n - 1]; } +``` + +**贪心**：由于题目允许当天购买和出售，因此只要前后两天收益差值大于零就可以计入股票收益中。 + +```go +func maxProfit(prices []int) int { + ans := 0 + for i := 1; i < len(prices); i++ { + ans += max(0, prices[i] - prices[i - 1]) + } + return ans } -``` \ No newline at end of file +``` + + + From e828d56019fef994b25fa5aa90aab54ed1a76c88 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 29 Jun 2024 20:53:18 +0800 Subject: [PATCH 279/373] =?UTF-8?q?Update=20416.=20=E5=88=86=E5=89=B2?= =?UTF-8?q?=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...11\345\222\214\345\255\220\351\233\206.md" | 38 ++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git "a/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" index 0f8b5f2..411d43d 100644 --- "a/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" +++ "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" @@ -60,4 +60,40 @@ class Solution { return dp[n - 1][target]; } } -``` \ No newline at end of file +``` + + + +Go 语言： + +```go +func canPartition(nums []int) bool { + n, sum := len(nums), 0 + for _, value := range(nums) { + sum += value + } + if sum % 2 != 0 || n == 1 { + return false + } + target := sum / 2 + dp := make([][]bool, n) + for i := range dp { + dp[i] = make([]bool, target + 1) + dp[i][0] = true + } + if nums[0] <= target { + dp[0][nums[0]] = true + } + for i := 1; i < n; i++ { + for j := 1; j <= target; j++ { + if j > nums[i] { + dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]] + } else { + dp[i][j] = dp[i - 1][j] + } + } + } + return dp[n - 1][target] +} +``` + From 322c541f38736e61c593c2d72a2107b909ce8ef2 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 6 Jul 2024 10:08:21 +0800 Subject: [PATCH 280/373] =?UTF-8?q?Create=203101.=20=E4=BA=A4=E6=9B=BF?= =?UTF-8?q?=E5=AD=90=E6=95=B0=E7=BB=84=E8=AE=A1=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...60\347\273\204\350\256\241\346\225\260.md" | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 "Two Pointers/3101. \344\272\244\346\233\277\345\255\220\346\225\260\347\273\204\350\256\241\346\225\260.md" diff --git "a/Two Pointers/3101. \344\272\244\346\233\277\345\255\220\346\225\260\347\273\204\350\256\241\346\225\260.md" "b/Two Pointers/3101. \344\272\244\346\233\277\345\255\220\346\225\260\347\273\204\350\256\241\346\225\260.md" new file mode 100644 index 0000000..e5f6a00 --- /dev/null +++ "b/Two Pointers/3101. \344\272\244\346\233\277\345\255\220\346\225\260\347\273\204\350\256\241\346\225\260.md" @@ -0,0 +1,62 @@ +#### 3101. 交替子数组计数 + +难度：中等 + +--- + +给你一个 二进制数组 `nums` 。 + +如果一个 子数组 中 **不存在** 两个 **相邻** 元素的值 **相同** 的情况，我们称这样的子数组为 **交替子数组** 。 + +返回数组 `nums` 中交替子数组的数量。 + + **示例 1：** + + **输入：** nums = \[0,1,1,1\] + + **输出：** 5 + + **解释：** + +以下子数组是交替子数组：`[0]` 、`[1]` 、`[1]` 、`[1]` 以及 `[0,1]` 。 + + **示例 2：** + + **输入：** nums = \[1,0,1,0\] + + **输出：** 10 + + **解释：** + +数组的每个子数组都是交替子数组。可以统计在内的子数组共有 10 个。 + + **提示：** + +* `1 <= nums.length <= 10^5` +* `nums[i]` 不是 `0` 就是 `1` 。 + +--- + +双指针：找到数组里**每个最长交替数组**，每个最长数组的交替子数组的和为 $len * (len + 1) / 2$，将每个交替子数组的和求和即可。 + +```Go +func countAlternatingSubarrays(nums []int) int64 { + n := len(nums) + res := int64(0) + left, right := 0, 0 + for right < n { + if right + 1 < n && nums[right] != nums[right + 1] { + right++ + } else { + res += calculate(right - left + 1) + right = right + 1 + left = right + } + } + return res +} + +func calculate(length int) int64 { + return int64(length) * int64(length + 1) / 2 +} +``` \ No newline at end of file From 64515b19e2d13d16f16c68d343b4d19373953001 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 6 Jul 2024 13:00:06 +0800 Subject: [PATCH 281/373] =?UTF-8?q?Update=2039.=20=E7=BB=84=E5=90=88?= =?UTF-8?q?=E6=80=BB=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\220\210\346\200\273\345\222\214.md" | 56 ++++++++++++++++++- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git "a/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" "b/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" index 5c0ebb6..cf3d258 100644 --- "a/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" +++ "b/Backtrace/39. \347\273\204\345\220\210\346\200\273\345\222\214.md" @@ -44,7 +44,7 @@ --- -回溯 + 剪枝： +**方法一：枚举选哪个** 从 `target` 开始，每次回溯都减或不减当前下标的值。本题用到剪枝在于先将数组按升序排序，如果当前下标的值小于 `target` 了，那么后续也不需要遍历了。 @@ -73,8 +73,60 @@ class Solution { backtrace(res, temp, candidates, i, target - candidates[i]); temp.remove(temp.size() - 1); } + } +} +``` +Go + +```go +func combinationSum(candidates []int, target int) [][]int { + res := [][]int{} + var dfs func(index, remain int, temp []int) + dfs = func(index, remain int, temp []int){ + if remain == 0 { + res = append(res, slices.Clone(temp)) // 一定要复制一份 + return + } + if remain < 0 { + return + } + for i := index; i < len(candidates); i++ { + temp = append(temp, candidates[i]) + dfs(i, remain - candidates[i], temp) + temp = temp[:len(temp) - 1] + } } + dfs(0, target, []int{}) + return res +} +``` + + + + +**方法二：选或不选** + +```go +func combinationSum(candidates []int, target int) [][]int { + res := [][]int{} + var dfs func(index, remain int, temp []int) + dfs = func(index, remain int, temp []int){ + if index >= len(candidates) || remain < 0 { + return + } + if remain == 0 { + res = append(res, slices.Clone(temp)) + return + } + dfs(index + 1, remain, temp) + temp = append(temp, candidates[index]) + dfs(index, remain - candidates[index], temp) + temp = temp[:len(temp) - 1] + } + dfs(0, target, []int{}) + return res } -``` \ No newline at end of file +``` + From 789229037f87cc7fada832db2fa9a937161be014 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 6 Jul 2024 13:03:55 +0800 Subject: [PATCH 282/373] Update changes --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index ffd6d77..dda5eb8 100644 --- a/README.md +++ b/README.md @@ -26,9 +26,12 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2024-06-23 19:20 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 2 | **2** | +| 2024-07-06 12:53 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 3 | **3** | +| 2024-07-06 10:28 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 4 | **4** | +| 2024-07-06 09:50 | [#3101 交替子数组计数](https://leetcode.cn/problems/count-alternating-subarrays) | MEDIUM | 2 | 1 | +| 2024-06-29 20:52 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 6 | **2** | +| 2024-06-29 19:50 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 3 | **3** | | 2024-06-23 15:47 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 6 | **3** | -| 2024-06-16 13:51 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 3 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | | 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | | 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | @@ -52,14 +55,12 @@ | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | -| 2024-01-23 12:13 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 2 | **2** | | 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | -| 2024-01-18 14:02 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 1 | 1 | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | From 95ae0183ef0fe7f172afba141f7fa52725dac0ca Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 10 Jul 2024 20:30:15 +0800 Subject: [PATCH 283/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index dda5eb8..ea14622 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-10 20:08 | [#14 最长公共前缀](https://leetcode.cn/problems/longest-common-prefix) | EASY | 10 | 1 | +| 2024-07-10 13:27 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 9 | **3** | | 2024-07-06 12:53 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 3 | **3** | | 2024-07-06 10:28 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 4 | **4** | | 2024-07-06 09:50 | [#3101 交替子数组计数](https://leetcode.cn/problems/count-alternating-subarrays) | MEDIUM | 2 | 1 | @@ -74,7 +76,6 @@ | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | | 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | -| 2023-12-20 20:00 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 5 | **2** | | 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | From ab817f2ef5e9df85557ca2abacb042b449c4cd8a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 11 Jul 2024 20:29:59 +0800 Subject: [PATCH 284/373] Update changes --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ea14622..44653c2 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-11 19:56 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 3 | **2** | +| 2024-07-11 19:16 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 2 | **2** | +| 2024-07-11 15:22 | [#6 Z 字形变换](https://leetcode.cn/problems/zigzag-conversion) | MEDIUM | 1 | 1 | | 2024-07-10 20:08 | [#14 最长公共前缀](https://leetcode.cn/problems/longest-common-prefix) | EASY | 10 | 1 | | 2024-07-10 13:27 | [#11 盛最多水的容器](https://leetcode.cn/problems/container-with-most-water) | MEDIUM | 9 | **3** | | 2024-07-06 12:53 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 3 | **3** | @@ -64,7 +67,6 @@ | 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | -| 2024-01-03 10:27 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | @@ -91,7 +93,6 @@ | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | -| 2023-11-09 15:01 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 2 | 1 | | 2023-11-04 16:08 | [#47 全排列 II](https://leetcode.cn/problems/permutations-ii) | MEDIUM | 5 | **4** | | 2023-11-04 15:45 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 7 | **5** | | 2023-11-02 10:23 | [#153 寻找旋转排序数组中的最小值](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array) | MEDIUM | 1 | 1 | From 983754303e5ba33057a052b5cfd0f904bde692bd Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 12 Jul 2024 09:06:13 +0800 Subject: [PATCH 285/373] Update changes --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 44653c2..98c1283 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-11 23:09 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 3 | **2** | +| 2024-07-11 20:51 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 6 | **3** | +| 2024-07-11 20:38 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 4 | **2** | | 2024-07-11 19:56 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 3 | **2** | | 2024-07-11 19:16 | [#150 逆波兰表达式求值](https://leetcode.cn/problems/evaluate-reverse-polish-notation) | MEDIUM | 2 | **2** | | 2024-07-11 15:22 | [#6 Z 字形变换](https://leetcode.cn/problems/zigzag-conversion) | MEDIUM | 1 | 1 | @@ -64,7 +67,6 @@ | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | -| 2024-01-19 16:19 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 4 | **2** | | 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | @@ -103,7 +105,6 @@ | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | -| 2023-09-21 15:14 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 3 | 1 | | 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | | 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | | 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | @@ -135,7 +136,6 @@ | 2023-05-25 16:03 | [#452 用最少数量的箭引爆气球](https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons) | MEDIUM | 2 | 1 | | 2023-05-21 14:18 | [#435 无重叠区间](https://leetcode.cn/problems/non-overlapping-intervals) | MEDIUM | 3 | 1 | | 2023-05-14 18:13 | [#1054 距离相等的条形码](https://leetcode.cn/problems/distant-barcodes) | MEDIUM | 3 | 1 | -| 2023-05-11 17:54 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 1 | 1 | | 2023-05-11 10:54 | [#1016 子串能表示从 1 到 N 数字的二进制串](https://leetcode.cn/problems/binary-string-with-substrings-representing-1-to-n) | MEDIUM | 2 | 1 | | 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | | 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | From 1fbce4163fe4767249acd682cec57f06574ff427 Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 14 Jul 2024 12:05:42 +0800 Subject: [PATCH 286/373] =?UTF-8?q?Create=20102.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...02\345\272\217\351\201\215\345\216\206.md" | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 "Queue/102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" diff --git "a/Queue/102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" "b/Queue/102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" new file mode 100644 index 0000000..0bb0f85 --- /dev/null +++ "b/Queue/102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" @@ -0,0 +1,74 @@ +#### 102. 二叉树的层序遍历 + +难度：中等 + +--- + +给你二叉树的根节点 `root` ，返回其节点值的 **层序遍历** 。 （即逐层地，从左到右访问所有节点）。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg) +``` +输入：root = [3,9,20,null,null,15,7] +输出：[[3],[9,20],[15,7]] +``` + + **示例 2：** + +``` +输入：root = [1] +输出：[[1]] +``` + + **示例 3：** + +``` +输入：root = [] +输出：[] +``` + + **提示：** + +* 树中节点数目在范围 `[0, 2000]` 内 +* `-1000 <= Node.val <= 1000` + +--- + +队列：每一层的节点从左往右依次存到队列中，每次都取出当前层的节点值并把左右非空子节点再存到队列中即可。 + +```Go +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func levelOrder(root *TreeNode) [][]int { + if root == nil { + return nil + } + res := make([][]int, 0) + queue := []*TreeNode{root} + depth := 0 + for len(queue) != 0 { + res = append(res, []int{}) + size := len(queue) + for i := 0; i < size; i++ { + node := queue[i] + res[depth] = append(res[depth], node.Val) + if node.Left != nil { + queue = append(queue, node.Left) + } + if node.Right != nil { + queue = append(queue, node.Right) + } + } + queue = queue[size:] + depth += 1 + } + return res +} +``` \ No newline at end of file From c27cadb0069ed09b3ae6ff8b197d7b5927f1ceb8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 14 Jul 2024 12:08:17 +0800 Subject: [PATCH 287/373] Update changes --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 98c1283..bf36235 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,10 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-14 11:01 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 4 | **2** | +| 2024-07-14 10:40 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 7 | **2** | +| 2024-07-13 22:05 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 7 | **2** | +| 2024-07-13 21:33 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 8 | **3** | | 2024-07-11 23:09 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 3 | **2** | | 2024-07-11 20:51 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 6 | **3** | | 2024-07-11 20:38 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 4 | **2** | @@ -189,9 +193,7 @@ | 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | | 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | | 2022-12-15 20:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | -| 2022-12-15 20:23 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 4 | 1 | | 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | -| 2022-12-13 12:34 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 4 | 1 | | 2022-12-13 11:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | | 2022-12-12 16:15 | [#1781 所有子字符串美丽值之和](https://leetcode.cn/problems/sum-of-beauty-of-all-substrings) | MEDIUM | 1 | 1 | | 2022-12-11 16:13 | [#1827 最少操作使数组递增](https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing) | EASY | 1 | 1 | @@ -212,7 +214,6 @@ | 2022-11-26 18:56 | [#787 K 站中转内最便宜的航班](https://leetcode.cn/problems/cheapest-flights-within-k-stops) | MEDIUM | 6 | **2** | | 2022-11-26 16:01 | [#882 细分图中的可到达节点](https://leetcode.cn/problems/reachable-nodes-in-subdivided-graph) | HARD | 2 | 1 | | 2022-11-26 13:52 | [#809 情感丰富的文字](https://leetcode.cn/problems/expressive-words) | MEDIUM | 2 | 1 | -| 2022-11-24 16:25 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 6 | **2** | | 2022-11-24 15:52 | [#1668 最大重复子字符串](https://leetcode.cn/problems/maximum-repeating-substring) | EASY | 4 | **2** | | 2022-11-24 15:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | | 2022-11-23 21:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | @@ -316,7 +317,6 @@ | 2022-05-17 11:08 | [#953 验证外星语词典](https://leetcode.cn/problems/verifying-an-alien-dictionary) | EASY | 2 | 1 | | 2022-05-16 16:08 | [#面试题 04.06 后继者](https://leetcode.cn/problems/successor-lcci) | MEDIUM | 5 | 1 | | 2022-05-15 14:35 | [#812 最大三角形面积](https://leetcode.cn/problems/largest-triangle-area) | EASY | 4 | 1 | -| 2022-05-13 22:09 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 3 | 1 | | 2022-05-13 13:28 | [#面试题 01.05 一次编辑](https://leetcode.cn/problems/one-away-lcci) | MEDIUM | 3 | 1 | | 2022-05-12 21:36 | [#944 删列造序](https://leetcode.cn/problems/delete-columns-to-make-sorted) | EASY | 2 | 1 | | 2022-05-10 15:12 | [#210 课程表 II](https://leetcode.cn/problems/course-schedule-ii) | MEDIUM | 2 | 1 | From bf00513842362622adcc76aa153afaf91cb63c88 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 26 Jul 2024 19:53:37 +0800 Subject: [PATCH 288/373] =?UTF-8?q?Create=20238.=20=E9=99=A4=E8=87=AA?= =?UTF-8?q?=E8=BA=AB=E4=BB=A5=E5=A4=96=E6=95=B0=E7=BB=84=E7=9A=84=E4=B9=98?= =?UTF-8?q?=E7=A7=AF.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\347\232\204\344\271\230\347\247\257.md" | 93 +++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 "Array/238. \351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" diff --git "a/Array/238. \351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" "b/Array/238. \351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" new file mode 100644 index 0000000..5416c48 --- /dev/null +++ "b/Array/238. \351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" @@ -0,0 +1,93 @@ +#### 238. 除自身以外数组的乘积 + +难度：中等 + +--- + +给你一个整数数组 `nums`，返回 数组 `answer` ，其中 `answer[i]` 等于 `nums` 中除 `nums[i]` 之外其余各元素的乘积 。 + +题目数据 **保证** 数组 `nums`之中任意元素的全部前缀元素和后缀的乘积都在  **32 位** 整数范围内。 + +请  **不要使用除法，** 且在 `O(n)` 时间复杂度内完成此题。 + + **示例 1:** + +``` +输入: nums = [1,2,3,4] +输出: [24,12,8,6] +``` + + **示例 2:** + +``` +输入: nums = [-1,1,0,-3,3] +输出: [0,0,9,0,0] +``` + + **提示：** + +* `2 <= nums.length <= 10^5` +* `-30 <= nums[i] <= 30` +* **保证** 数组 `nums`之中任意元素的全部前缀元素和后缀的乘积都在  **32 位** 整数范围内 + + **进阶：** 你可以在 `O(1)` 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组  **不被视为**  额外空间。） + +--- + +法一： + +利用两个数组分别从左往右/从右往左遍历，记录除当前下标值的前缀/后缀乘积，注意前缀数组的第一个值为一，后缀数组的最后一个值为一，最后再两者相乘即是输出数组 + +```go +func productExceptSelf(nums []int) []int { + n := len(nums) + leftArray, rightArray, output := make([]int, n), make([]int, n), make([]int, n) + for i := 0; i < n; i++ { + if i == 0 { + leftArray[i] = 1 + } else { + leftArray[i] = leftArray[i - 1] * nums[i - 1] + } + } + for i := n - 1; i >= 0; i-- { + if i == n - 1 { + rightArray[i] = 1 + } else { + rightArray[i] = rightArray[i + 1] * nums[i + 1] + } + } + for i := 0; i < n; i++ { + output[i] = leftArray[i] * rightArray[i] + } + + return output +} +``` + + + +法二： + +先在 `output` 输出数组上从左往右累乘，再从右往左累乘，用一个临时遍历记录从右往左累乘的数。 + +```Go +func productExceptSelf(nums []int) []int { + n := len(nums) + output := make([]int, n) + for i := 0; i < n; i++ { + if i == 0 { + output[i] = 1 + } else { + output[i] = output[i - 1] * nums[i - 1] + } + } + temp := 1 + for i := n - 1; i >= 0; i-- { + if i != n - 1 { + output[i] *= temp + } + temp *= nums[i] + } + return output +} +``` \ No newline at end of file From b41ad5de8cb64890d267c1fa2bc615ac5758bee3 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 26 Jul 2024 20:03:48 +0800 Subject: [PATCH 289/373] =?UTF-8?q?Update=20322.=20=E9=9B=B6=E9=92=B1?= =?UTF-8?q?=E5=85=91=E6=8D=A2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...66\351\222\261\345\205\221\346\215\242.md" | 34 ++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git "a/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" "b/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" index b82b27a..550b7f5 100644 --- "a/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" +++ "b/Dynamic Programming/322. \351\233\266\351\222\261\345\205\221\346\215\242.md" @@ -42,6 +42,8 @@ 动态规划： +每种硬币的数量是无限的，因此是**完全背包问题**。 + `dp[i]` 指凑成总金额为 `i` 的最少硬币数量。状态转移方程为 $dp[i] = \min_{j = 0, .., n - 1}dp[i - coins[j]] + 1$。简而言之，取所有当前金额与 `coins` 数组之差最少硬币数量的最小值并加一。 假设 `coins = [1, 2, 5], amount = 11`，当 `i = 11` 时，取 ` coins` 数组中所有比 `11` 小的值，即 `dp[11 - 1], dp[11 - 2], dp[11 - 5]` 的最小值，最后加一即可。 @@ -67,4 +69,34 @@ class Solution { return dp[amount]; } } -``` \ No newline at end of file +``` + + + +二维数组： `dp[i][j]` 表示前 `i` 个数组可以凑成总金额为 `j` 的最少硬币数量，并且初始化数组为最大值。 + +```Go +func coinChange(coins []int, amount int) int { + n := len(coins) + dp := make([][]int, n + 1) + for i := 0; i <= n; i++ { + dp[i] = make([]int, amount + 1) + for j := 1; j <= amount; j++ { + dp[i][j] = 1 << 30 + } + } + for i := 1; i <= n; i++ { + for j := 1; j <= amount; j++ { + dp[i][j] = dp[i - 1][j] + if j-coins[i-1] >= 0 { + dp[i][j] = min(min(dp[i][j], dp[i-1][j-coins[i - 1]]+1), dp[i][j-coins[i - 1]]+1) + } + } + } + if dp[n][amount] == 1<<30 { + return -1 + } + return dp[n][amount] +} +``` + From 7b00a27f5c99b6cd32148589d13b50be6296ea75 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 26 Jul 2024 20:07:22 +0800 Subject: [PATCH 290/373] =?UTF-8?q?Create=2054.=20=E8=9E=BA=E6=97=8B?= =?UTF-8?q?=E7=9F=A9=E9=98=B5.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...72\346\227\213\347\237\251\351\230\265.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Simulation/54. \350\236\272\346\227\213\347\237\251\351\230\265.md" diff --git "a/Simulation/54. \350\236\272\346\227\213\347\237\251\351\230\265.md" "b/Simulation/54. \350\236\272\346\227\213\347\237\251\351\230\265.md" new file mode 100644 index 0000000..eb006b2 --- /dev/null +++ "b/Simulation/54. \350\236\272\346\227\213\347\237\251\351\230\265.md" @@ -0,0 +1,82 @@ +#### 54. 螺旋矩阵 + +难度：中等 + +--- + +给你一个 `m` 行 `n` 列的矩阵 `matrix` ，请按照 **顺时针螺旋顺序** ，返回矩阵中的所有元素。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg) +``` +输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] +输出：[1,2,3,6,9,8,7,4,5] +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2020/11/13/spiral.jpg) +``` +输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]] +输出：[1,2,3,4,8,12,11,10,9,5,6,7] +``` + + **提示：** + +* `m == matrix.length` +* `n == matrix[i].length` +* `1 <= m, n <= 10` +* `-100 <= matrix[i][j] <= 100` + +--- + +模拟： + +用若干个变量分别表示下一步走的方向，上下左右四个方向的边界以及当前点的坐标。再分别考虑当前点到达角落时后续的移动情况。 + +```Go +func spiralOrder(matrix [][]int) []int { + left, right, up, down := 0, len(matrix[0]) - 1, 0, len(matrix) - 1 + first, second := 0, 0 + flag, sum := 1, (right + 1) * (down + 1) + res := make([]int, sum) + for cnt := 0; cnt < sum; cnt++ { + res[cnt] = matrix[first][second] + if flag == 1 { + if second == right{ + flag = 2 + up++ + first++ + }else { + second++ + } + } else if flag == 2 { + if first == down { + flag = 3 + right-- + second-- + } else { + first++ + } + } else if flag == 3 { + if second == left { + flag = 4 + down-- + first-- + } else { + second-- + } + } else if flag == 4 { + if first == up { + flag = 1 + left++ + second++ + } else { + first-- + } + } + } + return res +} +``` \ No newline at end of file From 038eccc199293fc8a785350b6b988b62fec44e77 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 26 Jul 2024 21:54:29 +0800 Subject: [PATCH 291/373] =?UTF-8?q?Create=20494.=20=E7=9B=AE=E6=A0=87?= =?UTF-8?q?=E5=92=8C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .... \347\233\256\346\240\207\345\222\214.md" | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 "Dynamic Programming/494. \347\233\256\346\240\207\345\222\214.md" diff --git "a/Dynamic Programming/494. \347\233\256\346\240\207\345\222\214.md" "b/Dynamic Programming/494. \347\233\256\346\240\207\345\222\214.md" new file mode 100644 index 0000000..2442acd --- /dev/null +++ "b/Dynamic Programming/494. \347\233\256\346\240\207\345\222\214.md" @@ -0,0 +1,86 @@ +#### 494. 目标和 + +难度：中等 + +--- + +给你一个非负整数数组 `nums` 和一个整数 `target` 。 + +向数组中的每个整数前添加 `'+'` 或 `'-'` ，然后串联起所有整数，可以构造一个 **表达式** ： + +* 例如，`nums = [2, 1]` ，可以在 `2` 之前添加 `'+'` ，在 `1` 之前添加 `'-'` ，然后串联起来得到表达式 `"+2-1"` 。 + +返回可以通过上述方法构造的、运算结果等于 `target` 的不同 **表达式** 的数目。 + + **示例 1：** + +``` +输入：nums = [1,1,1,1,1], target = 3 +输出：5 +解释：一共有 5 种方法让最终目标和为 3 。 +-1 + 1 + 1 + 1 + 1 = 3 ++1 - 1 + 1 + 1 + 1 = 3 ++1 + 1 - 1 + 1 + 1 = 3 ++1 + 1 + 1 - 1 + 1 = 3 ++1 + 1 + 1 + 1 - 1 = 3 +``` + + **示例 2：** + +``` +输入：nums = [1], target = 1 +输出：1 +``` + + **提示：** + +* `1 <= nums.length <= 20` +* `0 <= nums[i] <= 1000` +* `0 <= sum(nums[i]) <= 1000` +* `-1000 <= target <= 1000` + +--- + +动态规划： + +假设所有元素和为 `sum`，那么所有元素都加上负号之后为 `-sum`， 所以元素和的变化值为 `[-sum, sum]`，因此将其范围平移至 `[0, 2 * sum + 1]`。并且定义二维数组 `dp[i][j]` 表示前 `i` 个数组的和为 `j` 的表达式数量。最后的结果为 `dp[len(sum)][sum + target]`。状态转移方程为： + +`dp[i][j] = dp[i - 1][j - nums[i - 1]] + dp[i - 1][j + nums[i - 1]]` + +```Go +func findTargetSumWays(nums []int, target int) int { + n := len(nums) + sum := 0 + for _, num := range nums { + sum += num + } + if abs(target) > sum { + return 0 + } + dp := make([][]int, n + 1) + m := 2 * sum + 1 + for i := range dp { + dp[i] = make([]int, m + 1) + } + dp[0][sum] = 1 + for i := 1; i <= n; i++ { + for j := 0; j <= m; j++ { + dp[i][j] = 0 + if j - nums[i - 1] >= 0{ + dp[i][j] += dp[i - 1][j - nums[i - 1]] + } + if j + nums[i - 1] <= m { + dp[i][j] += dp[i - 1][j + nums[i - 1]] + } + } + } + return dp[n][target + sum] +} + +func abs(a int) int { + if a < 0 { + return -a + } + return a +} +``` \ No newline at end of file From 1b60ca673b9f9acd19e3fcda8e9ce711aa0fc849 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 27 Jul 2024 11:29:31 +0800 Subject: [PATCH 292/373] Update changes --- README.md | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index bf36235..5b79354 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,27 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-26 16:54 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 3 | **3** | +| 2024-07-26 15:28 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 8 | **3** | +| 2024-07-26 15:10 | [#474 一和零](https://leetcode.cn/problems/ones-and-zeroes) | MEDIUM | 1 | 1 | +| 2024-07-26 13:56 | [#1049 最后一块石头的重量 II](https://leetcode.cn/problems/last-stone-weight-ii) | MEDIUM | 6 | 1 | +| 2024-07-25 20:19 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 7 | **2** | +| 2024-07-25 17:58 | [#2844 生成特殊数字的最少操作](https://leetcode.cn/problems/minimum-operations-to-make-a-special-number) | MEDIUM | 6 | 1 | +| 2024-07-24 22:32 | [#54 螺旋矩阵](https://leetcode.cn/problems/spiral-matrix) | MEDIUM | 1 | 1 | +| 2024-07-24 09:37 | [#238 除自身以外数组的乘积](https://leetcode.cn/problems/product-of-array-except-self) | MEDIUM | 3 | 1 | +| 2024-07-20 17:03 | [#5 最长回文子串](https://leetcode.cn/problems/longest-palindromic-substring) | MEDIUM | 5 | **2** | +| 2024-07-20 15:02 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 7 | **2** | +| 2024-07-20 14:34 | [#424 替换后的最长重复字符](https://leetcode.cn/problems/longest-repeating-character-replacement) | MEDIUM | 3 | **2** | +| 2024-07-19 09:52 | [#LCR 016 无重复字符的最长子串](https://leetcode.cn/problems/wtcaE1) | MEDIUM | 5 | 1 | +| 2024-07-18 10:01 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 6 | **3** | +| 2024-07-18 09:26 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 12 | **6** | +| 2024-07-18 09:10 | [#2560 打家劫舍 IV](https://leetcode.cn/problems/house-robber-iv) | MEDIUM | 1 | 1 | +| 2024-07-17 23:16 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 15 | **2** | +| 2024-07-17 19:06 | [#222 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes) | EASY | 1 | 1 | +| 2024-07-16 20:57 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 5 | **3** | +| 2024-07-15 20:07 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 3 | **2** | +| 2024-07-15 17:23 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 3 | **2** | +| 2024-07-14 21:41 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 3 | 1 | | 2024-07-14 11:01 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 4 | **2** | | 2024-07-14 10:40 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 7 | **2** | | 2024-07-13 22:05 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 7 | **2** | @@ -51,7 +72,6 @@ | 2024-05-06 11:57 | [#382 链表随机节点](https://leetcode.cn/problems/linked-list-random-node) | MEDIUM | 3 | 1 | | 2024-05-06 11:07 | [#413 等差数列划分](https://leetcode.cn/problems/arithmetic-slices) | MEDIUM | 1 | 1 | | 2024-04-18 14:51 | [#525 连续数组](https://leetcode.cn/problems/contiguous-array) | MEDIUM | 1 | 1 | -| 2024-03-31 14:08 | [#424 替换后的最长重复字符](https://leetcode.cn/problems/longest-repeating-character-replacement) | MEDIUM | 2 | 1 | | 2024-03-23 16:02 | [#1471 数组中的 k 个最强值](https://leetcode.cn/problems/the-k-strongest-values-in-an-array) | MEDIUM | 1 | 1 | | 2024-03-19 19:39 | [#1838 最高频元素的频数](https://leetcode.cn/problems/frequency-of-the-most-frequent-element) | MEDIUM | 1 | 1 | | 2024-03-18 14:24 | [#658 找到 K 个最接近的元素](https://leetcode.cn/problems/find-k-closest-elements) | MEDIUM | 4 | 1 | @@ -71,15 +91,12 @@ | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | -| 2024-01-18 15:29 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 2 | **2** | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | -| 2023-12-29 16:24 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 1 | 1 | | 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | | 2023-12-28 17:12 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 2 | 1 | -| 2023-12-28 13:30 | [#5 最长回文子串](https://leetcode.cn/problems/longest-palindromic-substring) | MEDIUM | 2 | 1 | | 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | @@ -109,10 +126,6 @@ | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | -| 2023-09-19 21:25 | [#347 前 K 个高频元素](https://leetcode.cn/problems/top-k-frequent-elements) | MEDIUM | 3 | 1 | -| 2023-09-18 19:50 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 4 | **2** | -| 2023-09-17 22:03 | [#213 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii) | MEDIUM | 4 | **2** | -| 2023-09-17 22:02 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 10 | **5** | | 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | @@ -125,7 +138,6 @@ | 2023-07-13 23:30 | [#931 下降路径最小和](https://leetcode.cn/problems/minimum-falling-path-sum) | MEDIUM | 1 | 1 | | 2023-07-12 19:42 | [#450 删除二叉搜索树中的节点](https://leetcode.cn/problems/delete-node-in-a-bst) | MEDIUM | 5 | 1 | | 2023-07-10 22:29 | [#394 字符串解码](https://leetcode.cn/problems/decode-string) | MEDIUM | 3 | 1 | -| 2023-07-06 00:26 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 1 | 1 | | 2023-07-03 23:34 | [#445 两数相加 II](https://leetcode.cn/problems/add-two-numbers-ii) | MEDIUM | 3 | 1 | | 2023-06-27 21:34 | [#912 排序数组](https://leetcode.cn/problems/sort-an-array) | MEDIUM | 13 | **6** | | 2023-06-25 13:35 | [#162 寻找峰值](https://leetcode.cn/problems/find-peak-element) | MEDIUM | 2 | 1 | @@ -144,7 +156,6 @@ | 2023-05-07 12:24 | [#1010 总持续时间可被 60 整除的歌曲](https://leetcode.cn/problems/pairs-of-songs-with-total-durations-divisible-by-60) | MEDIUM | 3 | 1 | | 2023-05-06 22:58 | [#1419 数青蛙](https://leetcode.cn/problems/minimum-number-of-frogs-croaking) | MEDIUM | 10 | 1 | | 2023-05-05 13:57 | [#283 移动零](https://leetcode.cn/problems/move-zeroes) | EASY | 1 | 1 | -| 2023-05-04 16:25 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 4 | 1 | | 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | | 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | | 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | @@ -184,7 +195,6 @@ | 2023-01-09 16:15 | [#1806 还原排列的最少操作步数](https://leetcode.cn/problems/minimum-number-of-operations-to-reinitialize-a-permutation) | MEDIUM | 1 | 1 | | 2023-01-07 22:33 | [#1658 将 x 减到 0 的最小操作数](https://leetcode.cn/problems/minimum-operations-to-reduce-x-to-zero) | MEDIUM | 1 | 1 | | 2023-01-05 20:00 | [#143 重排链表](https://leetcode.cn/problems/reorder-list) | MEDIUM | 2 | 1 | -| 2023-01-05 19:37 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 2 | 1 | | 2023-01-03 15:54 | [#34 在排序数组中查找元素的第一个和最后一个位置](https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array) | MEDIUM | 4 | 1 | | 2022-12-31 10:58 | [#2037 使每位学生都有座位的最少移动次数](https://leetcode.cn/problems/minimum-number-of-moves-to-seat-everyone) | EASY | 1 | 1 | | 2022-12-19 14:07 | [#1971 寻找图中是否存在路径](https://leetcode.cn/problems/find-if-path-exists-in-graph) | EASY | 4 | 1 | @@ -423,7 +433,6 @@ | 2020-07-29 10:05 | [#12 整数转罗马数字](https://leetcode.cn/problems/integer-to-roman) | MEDIUM | 1 | 1 | | 2020-07-28 18:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | | 2020-07-27 10:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | -| 2020-07-23 15:55 | [#2 两数相加](https://leetcode.cn/problems/add-two-numbers) | MEDIUM | 5 | 1 | | 2020-07-23 14:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | | 2020-07-23 14:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | | 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | From 1b07cb7822a641ca16be270a352d952219632874 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 27 Jul 2024 11:45:54 +0800 Subject: [PATCH 293/373] =?UTF-8?q?Update=20416.=20=E5=88=86=E5=89=B2?= =?UTF-8?q?=E7=AD=89=E5=92=8C=E5=AD=90=E9=9B=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...11\345\222\214\345\255\220\351\233\206.md" | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git "a/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" index 411d43d..67841be 100644 --- "a/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" +++ "b/Dynamic Programming/416. \345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" @@ -97,3 +97,33 @@ func canPartition(nums []int) bool { } ``` + + +一维数组： + +`dp[i]` 表示是否存在和为 `i` 的 num 组合。`target` 为数组和的二分之一，因为是求两个等和子集。 + +- 外层遍历 nums 每个 num； +- 内层遍历 target（由大到小）。 + +```go +func canPartition(nums []int) bool { + sum := 0 + for _, num := range nums { + sum += num + } + if sum % 2 == 1 { + return false + } + target := sum / 2 + dp := make([]bool, target + 1) + dp[0] = true + for _, num := range nums { + for j := target; j >= num; j-- { + dp[j] = dp[j] || dp[j - num] + } + } + return dp[target] +} +``` + From d1af9b7c67d2737e7f242d0f22de2149f5bd8893 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 27 Jul 2024 11:48:36 +0800 Subject: [PATCH 294/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5b79354..aba5e69 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-27 11:43 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 7 | **3** | | 2024-07-26 16:54 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 3 | **3** | | 2024-07-26 15:28 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 8 | **3** | | 2024-07-26 15:10 | [#474 一和零](https://leetcode.cn/problems/ones-and-zeroes) | MEDIUM | 1 | 1 | @@ -62,7 +63,6 @@ | 2024-07-06 12:53 | [#39 组合总和](https://leetcode.cn/problems/combination-sum) | MEDIUM | 3 | **3** | | 2024-07-06 10:28 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 4 | **4** | | 2024-07-06 09:50 | [#3101 交替子数组计数](https://leetcode.cn/problems/count-alternating-subarrays) | MEDIUM | 2 | 1 | -| 2024-06-29 20:52 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 6 | **2** | | 2024-06-29 19:50 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 3 | **3** | | 2024-06-23 15:47 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 6 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | From 1b2c18ea28f0590532ccd7d739038382baa3e86f Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 27 Jul 2024 12:40:29 +0800 Subject: [PATCH 295/373] =?UTF-8?q?Update=20264.=20=E4=B8=91=E6=95=B0=20II?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../264. \344\270\221\346\225\260 II.md" | 81 +++++++++++++++++++ .../264. \344\270\221\346\225\260 II.md" | 31 ++++++- 2 files changed, 111 insertions(+), 1 deletion(-) create mode 100644 "Dynamic Programming/264. \344\270\221\346\225\260 II.md" diff --git "a/Dynamic Programming/264. \344\270\221\346\225\260 II.md" "b/Dynamic Programming/264. \344\270\221\346\225\260 II.md" new file mode 100644 index 0000000..95d56f0 --- /dev/null +++ "b/Dynamic Programming/264. \344\270\221\346\225\260 II.md" @@ -0,0 +1,81 @@ +#### 264. 丑数 II + +难度：中等 + +--- + +给你一个整数 `n` ，请你找出并返回第 `n` 个 **丑数** 。 + + **丑数** 就是只包含质因数 `2`、`3` 和/或 `5` 的正整数。 + + **示例 1：** + +``` +输入：n = 10 +输出：12 +解释：[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。 +``` + + **示例 2：** + +``` +输入：n = 1 +输出：1 +解释：1 通常被视为丑数。 +``` + + **提示：** + +* `1 <= n <= 1690` + +--- + +最小堆： + +已知后面的丑数肯定是前面的丑数乘以2/3/5得到的。那么构造一个存放丑数的最小堆，每次弹出最小值，并且放入该值与2/3/5相乘的结果，并需要**去重**。 + +```java +class Solution { +    public int nthUglyNumber(int n) { +        PriorityQueue pq = new PriorityQueue<>(); +        pq.offer(1l); +        long ans = 1l; +        while(n-- != 0){ +            ans = pq.poll(); +            if(!pq.contains(ans * 2l)) pq.offer(ans * 2l); +            if(!pq.contains(ans * 3l)) pq.offer(ans * 3l); +            if(!pq.contains(ans * 5l)) pq.offer(ans * 5l); +        } +        return (int)ans; +    } +} +``` + + + +动态规划： + +定义三个指针 *p*2, *p*3, *p*5，表示下一个丑数是当前指针指向的丑数乘以对应的质因数。 + +```go +func nthUglyNumber(n int) int { + dp := make([]int, n + 1) + dp[1] = 1 + x2, x3, x5 := 1, 1, 1 + for i := 2; i <= n; i++ { + s2, s3, s5 := dp[x2] * 2, dp[x3] * 3, dp[x5] * 5 + dp[i] = min(min(s2, s3), s5) + if dp[i] == s2 { + x2++ + } + if dp[i] == s3 { // 不能用 else if，而是用 if。因为会有重复计算 + x3++ + } + if dp[i] == s5 { + x5++ + } + } + return dp[n] +} +``` + diff --git "a/Priority Queue/264. \344\270\221\346\225\260 II.md" "b/Priority Queue/264. \344\270\221\346\225\260 II.md" index 2a85edf..95d56f0 100644 --- "a/Priority Queue/264. \344\270\221\346\225\260 II.md" +++ "b/Priority Queue/264. \344\270\221\346\225\260 II.md" @@ -49,4 +49,33 @@ class Solution {         return (int)ans;     } } -``` \ No newline at end of file +``` + + + +动态规划： + +定义三个指针 *p*2, *p*3, *p*5，表示下一个丑数是当前指针指向的丑数乘以对应的质因数。 + +```go +func nthUglyNumber(n int) int { + dp := make([]int, n + 1) + dp[1] = 1 + x2, x3, x5 := 1, 1, 1 + for i := 2; i <= n; i++ { + s2, s3, s5 := dp[x2] * 2, dp[x3] * 3, dp[x5] * 5 + dp[i] = min(min(s2, s3), s5) + if dp[i] == s2 { + x2++ + } + if dp[i] == s3 { // 不能用 else if，而是用 if。因为会有重复计算 + x3++ + } + if dp[i] == s5 { + x5++ + } + } + return dp[n] +} +``` + From e6082541ae750cac31e460f57481e569acfecc1f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 27 Jul 2024 12:43:53 +0800 Subject: [PATCH 296/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index aba5e69..6e9e2a1 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-27 12:36 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 3 | **2** | +| 2024-07-27 12:17 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 3 | **2** | | 2024-07-27 11:43 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 7 | **3** | | 2024-07-26 16:54 | [#494 目标和](https://leetcode.cn/problems/target-sum) | MEDIUM | 3 | **3** | | 2024-07-26 15:28 | [#322 零钱兑换](https://leetcode.cn/problems/coin-change) | MEDIUM | 8 | **3** | @@ -96,7 +98,6 @@ | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | -| 2023-12-28 17:12 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 2 | 1 | | 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | @@ -183,7 +184,6 @@ | 2023-02-09 17:45 | [#1797 设计一个验证系统](https://leetcode.cn/problems/design-authentication-manager) | MEDIUM | 2 | 1 | | 2023-02-08 14:28 | [#1233 删除子文件夹](https://leetcode.cn/problems/remove-sub-folders-from-the-filesystem) | MEDIUM | 1 | 1 | | 2023-01-30 19:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | -| 2023-01-29 16:50 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 2 | 1 | | 2023-01-28 14:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | | 2023-01-27 20:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | | 2023-01-27 19:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | From 0fe0a23ddfa6bbd167f016e925b821c0640eed7e Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 27 Jul 2024 13:20:10 +0800 Subject: [PATCH 297/373] =?UTF-8?q?Create=20518.=20=E9=9B=B6=E9=92=B1?= =?UTF-8?q?=E5=85=91=E6=8D=A2=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...351\222\261\345\205\221\346\215\242 II.md" | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 "Dynamic Programming/518. \351\233\266\351\222\261\345\205\221\346\215\242 II.md" diff --git "a/Dynamic Programming/518. \351\233\266\351\222\261\345\205\221\346\215\242 II.md" "b/Dynamic Programming/518. \351\233\266\351\222\261\345\205\221\346\215\242 II.md" new file mode 100644 index 0000000..92b0e61 --- /dev/null +++ "b/Dynamic Programming/518. \351\233\266\351\222\261\345\205\221\346\215\242 II.md" @@ -0,0 +1,91 @@ +#### 518. 零钱兑换 II + +难度：中等 + +--- + +给你一个整数数组 `coins` 表示不同面额的硬币，另给一个整数 `amount` 表示总金额。 + +请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 `0` 。 + +假设每一种面额的硬币有无限个。  + +题目数据保证结果符合 32 位带符号整数。 + + **示例 1：** + +``` +输入：amount = 5, coins = [1, 2, 5] +输出：4 +解释：有四种方式可以凑成总金额： +5=5 +5=2+2+1 +5=2+1+1+1 +5=1+1+1+1+1 +``` + + **示例 2：** + +``` +输入：amount = 3, coins = [2] +输出：0 +解释：只用面额 2 的硬币不能凑成总金额 3 。 +``` + + **示例 3：** + +``` +输入：amount = 10, coins = [10] +输出：1 +``` + + **提示：** + +* `1 <= coins.length <= 300` +* `1 <= coins[i] <= 5000` +* `coins` 中的所有值 **互不相同** +* `0 <= amount <= 5000` + +--- + +动态规划： + +1. 二维数组，`dp[i][j]` 表示前 `i` 个数组凑成金额为 `j` 的组合数量 + +```Go +func change(amount int, coins []int) int { + n := len(coins) + dp := make([][]int, n + 1) + for i := range dp { + dp[i] = make([]int, amount + 1) + } + dp[0][0] = 1 + for i := 1; i <= n; i++ { + for j := 0; j <= amount; j++ { + dp[i][j] = dp[i - 1][j] + if j >= coins[i - 1] { + dp[i][j] += dp[i][j - coins[i - 1]] + } + } + } + return dp[n][amount] +} +``` + + + +2. 一维数组，`dp[i]` 表示凑成金额为 `i` 的组合数量 + +```go +func change(amount int, coins []int) int { + dp := make([]int, amount + 1) + dp[0] = 1 + for _, coin := range coins { + for j := coin; j <= amount; j++ { + dp[j] += dp[j - coin] + } + } + return dp[amount] +} +``` + From ac25ce79bf87494ccc2f5d29f9c3e70ead8f57e5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 27 Jul 2024 13:22:54 +0800 Subject: [PATCH 298/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6e9e2a1..d80807a 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-27 13:16 | [#518 零钱兑换 II](https://leetcode.cn/problems/coin-change-ii) | MEDIUM | 2 | 1 | | 2024-07-27 12:36 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 3 | **2** | | 2024-07-27 12:17 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 3 | **2** | | 2024-07-27 11:43 | [#416 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum) | MEDIUM | 7 | **3** | From 1b8c19b3faeb02b22c1df2caeca1ea4761bbb58b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 28 Jul 2024 20:27:07 +0800 Subject: [PATCH 299/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index d80807a..bc9f5e8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-28 20:14 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 15 | **4** | +| 2024-07-28 17:12 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 2 | **2** | | 2024-07-27 13:16 | [#518 零钱兑换 II](https://leetcode.cn/problems/coin-change-ii) | MEDIUM | 2 | 1 | | 2024-07-27 12:36 | [#264 丑数 II](https://leetcode.cn/problems/ugly-number-ii) | MEDIUM | 3 | **2** | | 2024-07-27 12:17 | [#279 完全平方数](https://leetcode.cn/problems/perfect-squares) | MEDIUM | 3 | **2** | @@ -67,7 +69,6 @@ | 2024-07-06 10:28 | [#22 括号生成](https://leetcode.cn/problems/generate-parentheses) | MEDIUM | 4 | **4** | | 2024-07-06 09:50 | [#3101 交替子数组计数](https://leetcode.cn/problems/count-alternating-subarrays) | MEDIUM | 2 | 1 | | 2024-06-29 19:50 | [#122 买卖股票的最佳时机 II](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii) | MEDIUM | 3 | **3** | -| 2024-06-23 15:47 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 6 | **3** | | 2024-06-15 15:46 | [#300 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence) | MEDIUM | 5 | **3** | | 2024-06-15 14:12 | [#2779 数组的最大美丽值](https://leetcode.cn/problems/maximum-beauty-of-an-array-after-applying-operation) | MEDIUM | 4 | 1 | | 2024-06-14 21:37 | [#2786 访问数组中的位置使分数最大](https://leetcode.cn/problems/visit-array-positions-to-maximize-score) | MEDIUM | 2 | 1 | @@ -202,7 +203,6 @@ | 2022-12-18 21:25 | [#28 找出字符串中第一个匹配项的下标](https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string) | EASY | 1 | 1 | | 2022-12-17 18:17 | [#1764 通过连接另一个数组的子数组得到一个数组](https://leetcode.cn/problems/form-array-by-concatenating-subarrays-of-another-array) | MEDIUM | 4 | 1 | | 2022-12-16 12:06 | [#1785 构成特定和需要添加的最少元素](https://leetcode.cn/problems/minimum-elements-to-add-to-form-a-given-sum) | MEDIUM | 2 | 1 | -| 2022-12-15 20:52 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 1 | 1 | | 2022-12-15 20:42 | [#LCR 142 训练计划 IV](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof) | EASY | 1 | 1 | | 2022-12-15 11:18 | [#1945 字符串转化后的各位数字之和](https://leetcode.cn/problems/sum-of-digits-of-string-after-convert) | EASY | 3 | 1 | | 2022-12-13 11:30 | [#1832 判断句子是否为全字母句](https://leetcode.cn/problems/check-if-the-sentence-is-pangram) | EASY | 1 | 1 | From 9a150d91c95083cef33717c533650291aeb1d23e Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 28 Jul 2024 20:40:26 +0800 Subject: [PATCH 300/373] =?UTF-8?q?Update=2031.=20=E4=B8=8B=E4=B8=80?= =?UTF-8?q?=E4=B8=AA=E6=8E=92=E5=88=97.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" index ab506bb..a00c778 100644 --- "a/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" +++ "b/Methodology/31. \344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" @@ -49,7 +49,7 @@ 算法步骤： 1. 从后往前找到第一个升序的元素对，分别定义其下标为 `index - 1` 和 `index`，即 `nums[index - 1] < nums[i]` -2. 重新从后往前找到第一个大于 `nums[index - 1]` 的元素，定义其下标为 `i`， 即元素为 `nums[i]` 并交换 `nums[index - 1]` +2. 重新从后往前找到第一个大于 `nums[index - 1]` 的元素，定义其下标为 `i`， 即元素为 `nums[i]` 并交换 `nums[index - 1]`，注意此时不一定能找到，因此也不一定发生交换，所以不能从前往后找。 3. 接着反转 `[index , n - 1]` 范围内的所有元素，因为 `[index, n - 1]` 范围内的元素经过第一步筛选后一定是非升序的，下一个更大的排列一定是升序的。 ```Java From 8b4397ed56d645ac5a772a824d630b3ea1fc631b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 29 Jul 2024 20:30:27 +0800 Subject: [PATCH 301/373] Update changes --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index bc9f5e8..6b2dfc1 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,10 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-29 11:12 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 3 | **3** | +| 2024-07-29 09:51 | [#202 快乐数](https://leetcode.cn/problems/happy-number) | EASY | 3 | 1 | +| 2024-07-29 09:34 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 4 | **2** | +| 2024-07-29 09:12 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 5 | **2** | | 2024-07-28 20:14 | [#31 下一个排列](https://leetcode.cn/problems/next-permutation) | MEDIUM | 15 | **4** | | 2024-07-28 17:12 | [#21 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists) | EASY | 2 | **2** | | 2024-07-27 13:16 | [#518 零钱兑换 II](https://leetcode.cn/problems/coin-change-ii) | MEDIUM | 2 | 1 | @@ -123,13 +127,10 @@ | 2023-11-04 15:45 | [#46 全排列](https://leetcode.cn/problems/permutations) | MEDIUM | 7 | **5** | | 2023-11-02 10:23 | [#153 寻找旋转排序数组中的最小值](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2023-10-27 10:26 | [#1465 切割后面积最大的蛋糕](https://leetcode.cn/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts) | MEDIUM | 2 | 1 | -| 2023-10-23 22:55 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 2 | **2** | -| 2023-10-23 19:28 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 2 | 1 | | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | -| 2023-09-14 20:00 | [#75 颜色分类](https://leetcode.cn/problems/sort-colors) | MEDIUM | 3 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | From 71905813bb1514f81b101edfa5fcfca82f2f39f1 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 30 Jul 2024 20:30:05 +0800 Subject: [PATCH 302/373] Update changes --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 6b2dfc1..1aeeadf 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,10 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-30 17:55 | [#222 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes) | EASY | 2 | **2** | +| 2024-07-30 17:06 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 3 | **2** | +| 2024-07-30 14:43 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 6 | **2** | +| 2024-07-30 14:09 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 8 | **2** | | 2024-07-29 11:12 | [#142 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii) | MEDIUM | 3 | **3** | | 2024-07-29 09:51 | [#202 快乐数](https://leetcode.cn/problems/happy-number) | EASY | 3 | 1 | | 2024-07-29 09:34 | [#141 环形链表](https://leetcode.cn/problems/linked-list-cycle) | EASY | 4 | **2** | @@ -52,7 +56,6 @@ | 2024-07-18 09:26 | [#198 打家劫舍](https://leetcode.cn/problems/house-robber) | MEDIUM | 12 | **6** | | 2024-07-18 09:10 | [#2560 打家劫舍 IV](https://leetcode.cn/problems/house-robber-iv) | MEDIUM | 1 | 1 | | 2024-07-17 23:16 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 15 | **2** | -| 2024-07-17 19:06 | [#222 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes) | EASY | 1 | 1 | | 2024-07-16 20:57 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 5 | **3** | | 2024-07-15 20:07 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 3 | **2** | | 2024-07-15 17:23 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 3 | **2** | @@ -163,7 +166,6 @@ | 2023-05-03 22:12 | [#1003 检查替换后的词是否有效](https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions) | MEDIUM | 1 | 1 | | 2023-05-02 11:03 | [#970 强整数](https://leetcode.cn/problems/powerful-integers) | MEDIUM | 3 | 1 | | 2023-05-01 12:27 | [#1376 通知所有员工所需的时间](https://leetcode.cn/problems/time-needed-to-inform-all-employees) | MEDIUM | 1 | 1 | -| 2023-04-30 19:11 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 2 | 1 | | 2023-04-30 14:00 | [#1033 移动石子直到连续](https://leetcode.cn/problems/moving-stones-until-consecutive) | MEDIUM | 3 | 1 | | 2023-04-14 20:04 | [#1023 驼峰式匹配](https://leetcode.cn/problems/camelcase-matching) | MEDIUM | 3 | 1 | | 2023-04-09 11:22 | [#739 每日温度](https://leetcode.cn/problems/daily-temperatures) | MEDIUM | 2 | 1 | @@ -171,7 +173,6 @@ | 2023-03-30 20:02 | [#1637 两点之间不包含任何点的最宽垂直区域](https://leetcode.cn/problems/widest-vertical-area-between-two-points-containing-no-points) | EASY | 2 | 1 | | 2023-03-29 23:55 | [#1641 统计字典序元音字符串的数目](https://leetcode.cn/problems/count-sorted-vowel-strings) | MEDIUM | 1 | 1 | | 2023-03-22 19:50 | [#1626 无矛盾的最佳球队](https://leetcode.cn/problems/best-team-with-no-conflicts) | MEDIUM | 5 | 1 | -| 2023-03-21 19:16 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 2 | 1 | | 2023-03-18 11:47 | [#1616 分割两个字符串得到回文串](https://leetcode.cn/problems/split-two-strings-to-make-palindrome) | MEDIUM | 5 | 1 | | 2023-03-17 21:21 | [#89 格雷编码](https://leetcode.cn/problems/gray-code) | MEDIUM | 1 | 1 | | 2023-03-15 11:09 | [#1615 最大网络秩](https://leetcode.cn/problems/maximal-network-rank) | MEDIUM | 1 | 1 | @@ -436,7 +437,6 @@ | 2020-07-28 18:48 | [#104 二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree) | EASY | 1 | 1 | | 2020-07-27 10:32 | [#392 判断子序列](https://leetcode.cn/problems/is-subsequence) | EASY | 8 | 1 | | 2020-07-23 14:37 | [#344 反转字符串](https://leetcode.cn/problems/reverse-string) | EASY | 5 | 1 | -| 2020-07-23 14:15 | [#64 最小路径和](https://leetcode.cn/problems/minimum-path-sum) | MEDIUM | 6 | 1 | | 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | | 2020-07-18 23:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | | 2020-07-17 16:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | From c333403fac5af2cfacfffbbc45c0031de99c7f1a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 31 Jul 2024 08:56:16 +0800 Subject: [PATCH 303/373] Update changes --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 1aeeadf..da55097 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-30 22:49 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 4 | **2** | +| 2024-07-30 21:58 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 5 | **3** | | 2024-07-30 17:55 | [#222 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes) | EASY | 2 | **2** | | 2024-07-30 17:06 | [#49 字母异位词分组](https://leetcode.cn/problems/group-anagrams) | MEDIUM | 3 | **2** | | 2024-07-30 14:43 | [#62 不同路径](https://leetcode.cn/problems/unique-paths) | MEDIUM | 6 | **2** | @@ -64,7 +66,6 @@ | 2024-07-14 10:40 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 7 | **2** | | 2024-07-13 22:05 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 7 | **2** | | 2024-07-13 21:33 | [#19 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list) | MEDIUM | 8 | **3** | -| 2024-07-11 23:09 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 3 | **2** | | 2024-07-11 20:51 | [#56 合并区间](https://leetcode.cn/problems/merge-intervals) | MEDIUM | 6 | **3** | | 2024-07-11 20:38 | [#155 最小栈](https://leetcode.cn/problems/min-stack) | MEDIUM | 4 | **2** | | 2024-07-11 19:56 | [#151 反转字符串中的单词](https://leetcode.cn/problems/reverse-words-in-a-string) | MEDIUM | 3 | **2** | @@ -135,7 +136,6 @@ | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | | 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | -| 2023-09-12 20:12 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 1 | 1 | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | | 2023-08-28 19:16 | [#57 插入区间](https://leetcode.cn/problems/insert-interval) | MEDIUM | 1 | 1 | From 90beb25e6aee007c95291357718cff0aebb1bb7a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 31 Jul 2024 20:30:23 +0800 Subject: [PATCH 304/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index da55097..694bed8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-07-31 11:05 | [#3111 覆盖所有点的最少矩形数目](https://leetcode.cn/problems/minimum-rectangles-to-cover-points) | MEDIUM | 1 | 1 | | 2024-07-30 22:49 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 4 | **2** | | 2024-07-30 21:58 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 5 | **3** | | 2024-07-30 17:55 | [#222 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes) | EASY | 2 | **2** | From 8baee49cf547c763835fb9e0d518e0bc41471291 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 1 Aug 2024 09:12:41 +0800 Subject: [PATCH 305/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 694bed8..e435b13 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-01 09:06 | [#1291 顺次数](https://leetcode.cn/problems/sequential-digits) | MEDIUM | 1 | 1 | +| 2024-07-31 21:27 | [#423 从英文中重建数字](https://leetcode.cn/problems/reconstruct-original-digits-from-english) | MEDIUM | 1 | 1 | | 2024-07-31 11:05 | [#3111 覆盖所有点的最少矩形数目](https://leetcode.cn/problems/minimum-rectangles-to-cover-points) | MEDIUM | 1 | 1 | | 2024-07-30 22:49 | [#438 找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string) | MEDIUM | 4 | **2** | | 2024-07-30 21:58 | [#560 和为 K 的子数组](https://leetcode.cn/problems/subarray-sum-equals-k) | MEDIUM | 5 | **3** | From 1006c6f37c5f4e3244321bea1d5765e2782aca49 Mon Sep 17 00:00:00 2001 From: linze Date: Thu, 1 Aug 2024 16:49:29 +0800 Subject: [PATCH 306/373] =?UTF-8?q?Create=20=E6=89=8B=E5=86=99=E5=A0=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../\346\211\213\345\206\231\345\240\206.md" | 169 ++++++++++++++++++ ...31\345\244\247\351\241\266\345\240\206.md" | 73 -------- 2 files changed, 169 insertions(+), 73 deletions(-) create mode 100644 "Heap/\346\211\213\345\206\231\345\240\206.md" delete mode 100644 "Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" diff --git "a/Heap/\346\211\213\345\206\231\345\240\206.md" "b/Heap/\346\211\213\345\206\231\345\240\206.md" new file mode 100644 index 0000000..2995150 --- /dev/null +++ "b/Heap/\346\211\213\345\206\231\345\240\206.md" @@ -0,0 +1,169 @@ + + +# 小顶堆（Go） + +建堆有两种方式： + +1. 自顶向下，从第一个节点开始到最后一个节点遍历，按插入节点的方式建堆，节点的交换是从下往上的，时间复杂度是 `O(nlogn)` +2. 自底向上，从倒数第一个非叶子节点开始，到第一个节点，节点的交换是从上往下的，时间复杂度是 `O(n)` + +堆的操作： + +1. 插入节点：将节点插入到数组尾，用将数组的尾节点从下往上的交换方式一直往上交换 + +2. 弹出堆顶：交换堆顶节点和数组最后一个节点，删除数组最后一个节点，接着将堆顶节点用从上往下的方式一直往下交换 + +```go +package main + +import "fmt" + +func main() { + h := heap{4, 6, 9, 1, 2, 3, 12, 34, 5, 6} + h.init1() + fmt.Println(h) + h.insert(0) + fmt.Println(h) + h.pop() + fmt.Println(h) +} + +type heap []int + +func (h heap) swap(i, j int) { + h[i], h[j] = h[j], h[i] +} + +func (h heap) init1() { // bottom-up, O(n), 自底向上的建堆方式，节点的交换是从上往下的 + for i := len(h)/2 - 1; i >= 0; i-- { + h.topDown(i) + } +} + +func (h heap) init2() { // top-down O(nlogn) 自顶向下的建堆方式，节点的交换是从下往上的 + for i := 0; i < len(h); i++ { + h.bottomUp(i) + } +} + +func (h *heap) insert(val int) { + *h = append(*h, val) + h.bottomUp(len(*h) - 1) +} + +func (h heap) bottomUp(cur int) { + parent := (cur+1)/2 - 1 + for parent >= 0 { + if h[cur] < h[parent] { + h.swap(cur, parent) + } else { + break + } + cur = parent + parent = (parent+1)/2 - 1 + } +} + +func (h heap) topDown(cur int) { + minn := 2*cur + 1 + for minn < len(h) { + if 2*cur+2 < len(h) && h[2*cur+2] < h[minn] { + minn = 2*cur + 2 + } + if h[cur] > h[minn] { + h.swap(cur, minn) + } else { + break + } + cur = minn + minn = 2*cur + 1 + } +} + +func (h *heap) pop() int { + h.swap(0, len(*h)-1) + res := (*h)[len(*h)-1] + *h = (*h)[:len(*h)-1] + h.topDown(0) + return res +} + +``` + + + + + +# 大顶堆（Java） + +从第一个非叶子节点（若数组长度为 `size`，那么第一个非叶子节点的下标则为 `size / 2` ）倒序遍历至第一个节点，每个循环中都与自身子节点中较大的子节点交换。 + +```java +package src.DataStructure; + +public class Heap { + + private int[] arrays = new int[1000]; + + private int size; + + public Heap(int[] arrays){ + this.size = arrays.length; + System.arraycopy(arrays, 0, this.arrays, 0, size); + heapify(size); + } + + public void add(int value){ + arrays[size++] = value; + heapify(size); + } + + + public void heapify(int size){ + for(int i = size / 2; i >= 0; i--){ + sink(i); + } + } + + public void sink(int index){ + while(2 * index + 1 < size){ + int temp = 2 * index + 1; + if(temp + 1 < size && arrays[temp] < arrays[temp + 1]){ + temp = temp + 1; + } + if(arrays[temp] <= arrays[index]){ + break; + } + swap(arrays, index, temp); + index = temp; + } + } + + public int poll(){ + int ans = arrays[0]; + swap(arrays, 0, --size); + heapify(size); + return ans; + } + + public void swap(int[] nums, int left, int right){ + int temp = nums[left]; + nums[left] = nums[right]; + nums[right] = temp; + } + + + public static void main(String[] args) { + int[] arrays = new int[]{6, 8, 10, 2, 4, 11, 13, 9, 1, 5, 7, 3}; + Heap heap = new Heap(arrays); + heap.add(200); + while(heap.size != 0){ + System.out.println(heap.poll()); + } + } +} + +``` + + + diff --git "a/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" "b/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" deleted file mode 100644 index d42baaa..0000000 --- "a/Heap/\346\211\213\345\206\231\345\244\247\351\241\266\345\240\206.md" +++ /dev/null @@ -1,73 +0,0 @@ - - -手写大顶堆： - -从第一个非叶子节点（若数组长度为 `size`，那么第一个非叶子节点的下标则为 `size / 2` ）倒序遍历至第一个节点，每个循环中都与自身子节点中较大的子节点交换。 - -```java -package src.DataStructure; - -public class Heap { - - private int[] arrays = new int[1000]; - - private int size; - - public Heap(int[] arrays){ - this.size = arrays.length; - System.arraycopy(arrays, 0, this.arrays, 0, size); - heapify(size); - } - - public void add(int value){ - arrays[size++] = value; - heapify(size); - } - - - public void heapify(int size){ - for(int i = size / 2; i >= 0; i--){ - sink(i); - } - } - - public void sink(int index){ - while(2 * index + 1 < size){ - int temp = 2 * index + 1; - if(temp + 1 < size && arrays[temp] < arrays[temp + 1]){ - temp = temp + 1; - } - if(arrays[temp] <= arrays[index]){ - break; - } - swap(arrays, index, temp); - index = temp; - } - } - - public int poll(){ - int ans = arrays[0]; - swap(arrays, 0, --size); - heapify(size); - return ans; - } - - public void swap(int[] nums, int left, int right){ - int temp = nums[left]; - nums[left] = nums[right]; - nums[right] = temp; - } - - - public static void main(String[] args) { - int[] arrays = new int[]{6, 8, 10, 2, 4, 11, 13, 9, 1, 5, 7, 3}; - Heap heap = new Heap(arrays); - heap.add(200); - while(heap.size != 0){ - System.out.println(heap.poll()); - } - } -} - -``` - From 80061303748335d08f694774099bb27baf376c95 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 1 Aug 2024 16:52:12 +0800 Subject: [PATCH 307/373] Update changes --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index e435b13..a768069 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-01 14:39 | [#316 去除重复字母](https://leetcode.cn/problems/remove-duplicate-letters) | MEDIUM | 2 | 1 | +| 2024-08-01 10:04 | [#2740 找出分区值](https://leetcode.cn/problems/find-the-value-of-the-partition) | MEDIUM | 2 | 1 | | 2024-08-01 09:06 | [#1291 顺次数](https://leetcode.cn/problems/sequential-digits) | MEDIUM | 1 | 1 | | 2024-07-31 21:27 | [#423 从英文中重建数字](https://leetcode.cn/problems/reconstruct-original-digits-from-english) | MEDIUM | 1 | 1 | | 2024-07-31 11:05 | [#3111 覆盖所有点的最少矩形数目](https://leetcode.cn/problems/minimum-rectangles-to-cover-points) | MEDIUM | 1 | 1 | From 706de57c299551d6f02ace7b8fcae92a9672883d Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 2 Aug 2024 13:45:46 +0800 Subject: [PATCH 308/373] =?UTF-8?q?Update=2092.=20=E5=8F=8D=E8=BD=AC?= =?UTF-8?q?=E9=93=BE=E8=A1=A8=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...350\275\254\351\223\276\350\241\250 II.md" | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git "a/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" "b/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" index c66714b..3356e2b 100644 --- "a/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" +++ "b/Linked List/92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" @@ -119,3 +119,30 @@ class Solution { } ``` +Go语言： + +```go +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func reverseBetween(head *ListNode, left int, right int) *ListNode { + dummy := &ListNode{-1, head} + pre := dummy + for i := 0; i < left - 1; i++ { + pre = pre.Next + } + cur, next := pre.Next, pre.Next.Next + for i := 0; i < right - left; i++ { + cur.Next = next.Next + next.Next = pre.Next + pre.Next = next + next = cur.Next + } + return dummy.Next +} +``` + From 2f9a900a4267734fcc210bb2552e8cf03acc04ce Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 2 Aug 2024 13:48:50 +0800 Subject: [PATCH 309/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a768069..826c8f4 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-02 13:38 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 5 | **3** | | 2024-08-01 14:39 | [#316 去除重复字母](https://leetcode.cn/problems/remove-duplicate-letters) | MEDIUM | 2 | 1 | | 2024-08-01 10:04 | [#2740 找出分区值](https://leetcode.cn/problems/find-the-value-of-the-partition) | MEDIUM | 2 | 1 | | 2024-08-01 09:06 | [#1291 顺次数](https://leetcode.cn/problems/sequential-digits) | MEDIUM | 1 | 1 | @@ -127,7 +128,6 @@ | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | -| 2023-11-25 16:27 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 2 | **2** | | 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | From 4b8b9541ccf17dcd2792886b9ab5408918d323cb Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 2 Aug 2024 14:55:40 +0800 Subject: [PATCH 310/373] =?UTF-8?q?Create=20=E5=A0=86.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "Heap/\345\240\206.md" | 46 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 "Heap/\345\240\206.md" diff --git "a/Heap/\345\240\206.md" "b/Heap/\345\240\206.md" new file mode 100644 index 0000000..8a2d32d --- /dev/null +++ "b/Heap/\345\240\206.md" @@ -0,0 +1,46 @@ +Go 语言： + +```go +package main + +import ( + "container/heap" + "fmt" + "sort" +) + +type heap2 struct { + sort.IntSlice +} + +func (h heap2) Less(i, j int) bool { // 最小堆：h.IntSlice[i] < h.IntSlice[j]；最大堆：h.IntSlice[i] > h.IntSlice[j]； + return h.IntSlice[i] > h.IntSlice[j] +} + +func (h *heap2) Push(v interface{}) { + h.IntSlice = append(h.IntSlice, v.(int)) +} + +func (h *heap2) Pop() interface{} { + temp := h.IntSlice + v := temp[len(temp)-1] + h.IntSlice = temp[:len(temp)-1] + return v +} + +func (h *heap2) push(v int) { + heap.Push(h, v) +} + +func (h *heap2) pop() int { + return heap.Pop(h).(int) +} + +func main() { + q := &heap2{[]int{3, 4, 1, 2, 4, 3}} + heap.Init(q) + fmt.Println(q) +} + +``` + From b925743ec17a0745c691cb01b5932739347577a3 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 2 Aug 2024 15:26:47 +0800 Subject: [PATCH 311/373] =?UTF-8?q?Create=201046.=20=E6=9C=80=E5=90=8E?= =?UTF-8?q?=E4=B8=80=E5=9D=97=E7=9F=B3=E5=A4=B4=E7=9A=84=E9=87=8D=E9=87=8F?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...64\347\232\204\351\207\215\351\207\217.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Heap/1046. \346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217.md" diff --git "a/Heap/1046. \346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217.md" "b/Heap/1046. \346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217.md" new file mode 100644 index 0000000..9c6b164 --- /dev/null +++ "b/Heap/1046. \346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217.md" @@ -0,0 +1,82 @@ +#### 1046. 最后一块石头的重量 + +难度：简单 + +--- + +有一堆石头，每块石头的重量都是正整数。 + +每一回合，从中选出两块 **最重的** 石头，然后将它们一起粉碎。假设石头的重量分别为 `x` 和 `y`，且 `x <= y`。那么粉碎的可能结果如下： + +* 如果 `x == y`，那么两块石头都会被完全粉碎； +* 如果 `x != y`，那么重量为 `x` 的石头将会完全粉碎，而重量为 `y` 的石头新重量为 `y-x`。 + +最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 `0`。 + + **示例：** + +``` +输入：[2,7,4,1,8,1] +输出：1 +解释： +先选出 7 和 8，得到 1，所以数组转换为 [2,4,1,1,1]， +再选出 2 和 4，得到 2，所以数组转换为 [2,1,1,1]， +接着是 2 和 1，得到 1，所以数组转换为 [1,1,1]， +最后选出 1 和 1，得到 0，最终数组转换为 [1]，这就是最后剩下那块石头的重量。 +``` + + **提示：** + +* `1 <= stones.length <= 30` +* `1 <= stones[i] <= 1000` + +--- + +最大堆： + +每次连续两次弹出堆顶元素并相减，再将相减后的值插入到堆中。 + +```Go +type hp struct { + sort.IntSlice +} + +func (h hp) Less(i, j int) bool { + return h.IntSlice[i] > h.IntSlice[j] +} + +func (h *hp) Push(v interface{}) { + h.IntSlice = append(h.IntSlice, v.(int)) +} + +func (h *hp) Pop() interface{} { + temp := h.IntSlice + v := temp[len(temp) - 1] + h.IntSlice = temp[:len(temp) - 1] + return v +} + +func (h *hp) push(v int) { + heap.Push(h, v) +} + +func (h *hp) pop() int { + return heap.Pop(h).(int) +} + +func lastStoneWeight(stones []int) int { + maxnHeap := &hp{stones} + heap.Init(maxnHeap) + for len(maxnHeap.IntSlice) > 1 { + y := maxnHeap.pop() + x := maxnHeap.pop() + if y - x != 0 { + maxnHeap.push(y - x) + } + } + if len(maxnHeap.IntSlice) == 0 { + return 0 + } + return maxnHeap.pop() +} +``` \ No newline at end of file From 3e2a819b7efb550d03fa7b238b4498504f319bb9 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 2 Aug 2024 15:29:13 +0800 Subject: [PATCH 312/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 826c8f4..1f7f7b6 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-02 15:25 | [#1046 最后一块石头的重量](https://leetcode.cn/problems/last-stone-weight) | EASY | 1 | 1 | | 2024-08-02 13:38 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 5 | **3** | | 2024-08-01 14:39 | [#316 去除重复字母](https://leetcode.cn/problems/remove-duplicate-letters) | MEDIUM | 2 | 1 | | 2024-08-01 10:04 | [#2740 找出分区值](https://leetcode.cn/problems/find-the-value-of-the-partition) | MEDIUM | 2 | 1 | From dd21f53893795d0b96342af1dbb04f8f523723a5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 2 Aug 2024 20:29:27 +0800 Subject: [PATCH 313/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1f7f7b6..ce65fd0 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-02 16:21 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 2 | **2** | | 2024-08-02 15:25 | [#1046 最后一块石头的重量](https://leetcode.cn/problems/last-stone-weight) | EASY | 1 | 1 | | 2024-08-02 13:38 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 5 | **3** | | 2024-08-01 14:39 | [#316 去除重复字母](https://leetcode.cn/problems/remove-duplicate-letters) | MEDIUM | 2 | 1 | @@ -140,7 +141,6 @@ | 2023-10-11 10:11 | [#2512 奖励最顶尖的 K 名学生](https://leetcode.cn/problems/reward-top-k-students) | MEDIUM | 1 | 1 | | 2023-10-05 19:53 | [#309 买卖股票的最佳时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown) | MEDIUM | 1 | 1 | | 2023-10-05 17:54 | [#121 买卖股票的最佳时机](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock) | EASY | 1 | 1 | -| 2023-09-25 22:38 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 1 | 1 | | 2023-09-13 20:18 | [#763 划分字母区间](https://leetcode.cn/problems/partition-labels) | MEDIUM | 1 | 1 | | 2023-09-10 12:15 | [#2594 修车的最少时间](https://leetcode.cn/problems/minimum-time-to-repair-cars) | MEDIUM | 4 | 1 | | 2023-09-01 09:45 | [#2240 买钢笔和铅笔的方案数](https://leetcode.cn/problems/number-of-ways-to-buy-pens-and-pencils) | MEDIUM | 3 | 1 | From a094a87d93e9c98b0dc3e0193cbb0a4f26588ffa Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 3 Aug 2024 15:01:21 +0800 Subject: [PATCH 314/373] =?UTF-8?q?Create=203143.=20=E6=AD=A3=E6=96=B9?= =?UTF-8?q?=E5=BD=A2=E4=B8=AD=E7=9A=84=E6=9C=80=E5=A4=9A=E7=82=B9=E6=95=B0?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\244\232\347\202\271\346\225\260.md" | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 "Methodology/3143. \346\255\243\346\226\271\345\275\242\344\270\255\347\232\204\346\234\200\345\244\232\347\202\271\346\225\260.md" diff --git "a/Methodology/3143. \346\255\243\346\226\271\345\275\242\344\270\255\347\232\204\346\234\200\345\244\232\347\202\271\346\225\260.md" "b/Methodology/3143. \346\255\243\346\226\271\345\275\242\344\270\255\347\232\204\346\234\200\345\244\232\347\202\271\346\225\260.md" new file mode 100644 index 0000000..4ca8adf --- /dev/null +++ "b/Methodology/3143. \346\255\243\346\226\271\345\275\242\344\270\255\347\232\204\346\234\200\345\244\232\347\202\271\346\225\260.md" @@ -0,0 +1,99 @@ +#### 3143. 正方形中的最多点数 + +难度：中等 + +--- + +给你一个二维数组 `points` 和一个字符串 `s` ，其中 `points[i]` 表示第 `i` 个点的坐标，`s[i]` 表示第 `i` 个点的 **标签**  。 + +如果一个正方形的中心在 `(0, 0)` ，所有边都平行于坐标轴，且正方形内  **不**  存在标签相同的两个点，那么我们称这个正方形是  **合法**  的。 + +请你返回 **合法**  正方形中可以包含的 **最多**  点数。 + + **注意：** + +* 如果一个点位于正方形的边上或者在边以内，则认为该点位于正方形内。 +* 正方形的边长可以为零。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2024/03/29/3708-tc1.png) + +**输入：**points = \[\[2,2\],\[-1,-2\],\[-4,4\],\[-3,1\],\[3,-3\]\], s = "abdca" + +**输出：**2 + + **解释：** + +边长为 4 的正方形包含两个点 `points[0]` 和 `points[1]` 。 + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2024/03/29/3708-tc2.png) + +**输入：**points = \[\[1,1\],\[-2,-2\],\[-2,2\]\], s = "abb" + +**输出：**1 + + **解释：** + +边长为 2 的正方形包含 1 个点 `points[0]` 。 + + **示例 3：** + +**输入：**points = \[\[1,1\],\[-1,-1\],\[2,-2\]\], s = "ccd" + +**输出：**0 + + **解释：** + +任何正方形都无法只包含 `points[0]` 和 `points[1]` 中的一个点，所以合法正方形中都不包含任何点。 + + **提示：** + +* `1 <= s.length, points.length <= 10^5` +* `points[i].length == 2` +* `-10^9 <= points[i][0], points[i][1] <= 10^9` +* `s.length == points.length` +* `points` 中的点坐标互不相同。 +* `s` 只包含小写英文字母。 + +--- + +维护次小半径： + +遍历所有坐标，记录所有标签的次小半径，最后统计**各个标签的最小半径**小于**次小半径**的个数 + +```Go +func maxPointsInsideSquare(points [][]int, s string) int { + alphabet := [26]int{} + for i := range alphabet { + alphabet[i] = math.MaxInt + } + minn := math.MaxInt + for i := range points { + ch := s[i] + dis := max(abs(points[i][0]), abs(points[i][1])) + if dis < alphabet[ch - 'a'] { + minn = min(minn, alphabet[ch - 'a']) + alphabet[ch - 'a'] = dis + } else if dis < minn { + minn = dis + } + } + res := 0 + for i := 0; i < 26; i++ { + if alphabet[i] < minn { + res++ + } + } + return res +} + +func abs(i int) int { + if i < 0 { + return -i + } + return i +} +``` \ No newline at end of file From 8e02d80464bad0c85d5e4f1c6e5084e772a4fc8b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 3 Aug 2024 15:04:01 +0800 Subject: [PATCH 315/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ce65fd0..aedc8ab 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-03 14:54 | [#3143 正方形中的最多点数](https://leetcode.cn/problems/maximum-points-inside-the-square) | MEDIUM | 2 | 1 | | 2024-08-02 16:21 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 2 | **2** | | 2024-08-02 15:25 | [#1046 最后一块石头的重量](https://leetcode.cn/problems/last-stone-weight) | EASY | 1 | 1 | | 2024-08-02 13:38 | [#92 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii) | MEDIUM | 5 | **3** | From 74a99ed2e812f20f40a749d56b741109dd09da8f Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 3 Aug 2024 15:39:15 +0800 Subject: [PATCH 316/373] =?UTF-8?q?Update=20209.=20=E9=95=BF=E5=BA=A6?= =?UTF-8?q?=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\255\220\346\225\260\347\273\204.md" | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git "a/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" index 24e9522..bd4b0ce 100644 --- "a/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" +++ "b/Sliding Window/209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -61,4 +61,28 @@ class Solution { return res == Integer.MAX_VALUE ? 0 : res; } } -``` \ No newline at end of file +``` + + + +Go： + +```go +func minSubArrayLen(target int, nums []int) int { + left, right, res, sum := 0, 0, math.MaxInt, 0 + for right < len(nums) { + sum += nums[right] + for sum >= target { + res = min(res, right - left + 1) + sum -= nums[left] + left++ + } + right++ + } + if res == math.MaxInt { + return 0 + } + return res +} +``` + From f5c6ba36c56b8d7277e3185c91a5e7d83c635dec Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 3 Aug 2024 15:42:09 +0800 Subject: [PATCH 317/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index aedc8ab..2cf1bfc 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-03 15:39 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 5 | **2** | | 2024-08-03 14:54 | [#3143 正方形中的最多点数](https://leetcode.cn/problems/maximum-points-inside-the-square) | MEDIUM | 2 | 1 | | 2024-08-02 16:21 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 2 | **2** | | 2024-08-02 15:25 | [#1046 最后一块石头的重量](https://leetcode.cn/problems/last-stone-weight) | EASY | 1 | 1 | @@ -113,7 +114,6 @@ | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | -| 2024-01-03 09:58 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 4 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | From 640f4f0ccda6e11497033b430ab4d909abc8c27c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 3 Aug 2024 20:27:22 +0800 Subject: [PATCH 318/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2cf1bfc..4a925aa 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-03 17:11 | [#69 x 的平方根 ](https://leetcode.cn/problems/sqrtx) | EASY | 2 | 1 | | 2024-08-03 15:39 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 5 | **2** | | 2024-08-03 14:54 | [#3143 正方形中的最多点数](https://leetcode.cn/problems/maximum-points-inside-the-square) | MEDIUM | 2 | 1 | | 2024-08-02 16:21 | [#146 LRU 缓存](https://leetcode.cn/problems/lru-cache) | MEDIUM | 2 | **2** | From fb31cbac962c9d605b73d0d4ff67c024ba45679d Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 4 Aug 2024 15:23:57 +0800 Subject: [PATCH 319/373] =?UTF-8?q?Update=20206.=20=E5=8F=8D=E8=BD=AC?= =?UTF-8?q?=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...15\350\275\254\351\223\276\350\241\250.md" | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git "a/Linked List/206. \345\217\215\350\275\254\351\223\276\350\241\250.md" "b/Linked List/206. \345\217\215\350\275\254\351\223\276\350\241\250.md" index c615f39..a79cb42 100644 --- "a/Linked List/206. \345\217\215\350\275\254\351\223\276\350\241\250.md" +++ "b/Linked List/206. \345\217\215\350\275\254\351\223\276\350\241\250.md" @@ -65,6 +65,32 @@ class Solution { } ``` +Go语言： + +```go +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func reverseList(head *ListNode) *ListNode { + var pre *ListNode + for head != nil { + next := head.Next + head.Next = pre + pre = head + head = next + } + return pre +} +``` + + + + + 方法二，递归： ```java From 48bf9824247dc99498a05cf1eba5361d52ec219c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 4 Aug 2024 15:26:45 +0800 Subject: [PATCH 320/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 4a925aa..e201778 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-04 15:21 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 4 | **3** | +| 2024-08-04 15:18 | [#234 回文链表](https://leetcode.cn/problems/palindrome-linked-list) | EASY | 1 | 1 | | 2024-08-03 17:11 | [#69 x 的平方根 ](https://leetcode.cn/problems/sqrtx) | EASY | 2 | 1 | | 2024-08-03 15:39 | [#209 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) | MEDIUM | 5 | **2** | | 2024-08-03 14:54 | [#3143 正方形中的最多点数](https://leetcode.cn/problems/maximum-points-inside-the-square) | MEDIUM | 2 | 1 | @@ -71,7 +73,6 @@ | 2024-07-17 23:16 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 15 | **2** | | 2024-07-16 20:57 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 5 | **3** | | 2024-07-15 20:07 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 3 | **2** | -| 2024-07-15 17:23 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 3 | **2** | | 2024-07-14 21:41 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 3 | 1 | | 2024-07-14 11:01 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 4 | **2** | | 2024-07-14 10:40 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 7 | **2** | From 8a34937a54a778103e6df2713a7e580912ea6de5 Mon Sep 17 00:00:00 2001 From: linze Date: Sun, 4 Aug 2024 15:27:49 +0800 Subject: [PATCH 321/373] =?UTF-8?q?Create=20234.=20=E5=9B=9E=E6=96=87?= =?UTF-8?q?=E9=93=BE=E8=A1=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...36\346\226\207\351\223\276\350\241\250.md" | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 "Linked List/234. \345\233\236\346\226\207\351\223\276\350\241\250.md" diff --git "a/Linked List/234. \345\233\236\346\226\207\351\223\276\350\241\250.md" "b/Linked List/234. \345\233\236\346\226\207\351\223\276\350\241\250.md" new file mode 100644 index 0000000..be70d97 --- /dev/null +++ "b/Linked List/234. \345\233\236\346\226\207\351\223\276\350\241\250.md" @@ -0,0 +1,82 @@ +#### 234. 回文链表 + +难度：简单 + +--- + +给你一个单链表的头节点 `head` ，请你判断该链表是否为 + +回文链表 + +。如果是，返回 `true` ；否则，返回 `false` 。 + + **示例 1：** + +![](https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg) +``` +输入：head = [1,2,2,1] +输出：true +``` + + **示例 2：** + +![](https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg) +``` +输入：head = [1,2] +输出：false +``` + + **提示：** + +* 链表中节点数目在范围`[1, 10^5]` 内 +* `0 <= Node.val <= 9` + + **进阶：** 你能否用 `O(n)` 时间复杂度和 `O(1)` 空间复杂度解决此题？ + +--- + +进阶，用快慢指针和反转链表的方式： + +首先用快慢指针找到链表中点，接着将中点后的节点反转，得到新的节点后与 `head` 节点逐个比较值。 + +```Go +/** + * Definition for singly-linked list. + * type ListNode struct { + * Val int + * Next *ListNode + * } + */ +func isPalindrome(head *ListNode) bool { + mid := endOfFirstHalf(head) + end := reverse(mid.Next) + for end != nil { + if head.Val != end.Val { + return false + } + end = end.Next + head = head.Next + } + return true +} + +func reverse(cur *ListNode) *ListNode { + var pre *ListNode + for cur != nil { + next := cur.Next + cur.Next = pre + pre = cur + cur = next + } + return pre +} + +func endOfFirstHalf(head *ListNode) *ListNode { + slow, fast := head, head + for fast.Next != nil && fast.Next.Next != nil { + slow = slow.Next + fast = fast.Next.Next + } + return slow +} +``` \ No newline at end of file From f0088529953cf6e312c908aeec308433e8b61c2d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 5 Aug 2024 20:30:52 +0800 Subject: [PATCH 322/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index e201778..4678cd8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-05 14:23 | [#907 子数组的最小值之和](https://leetcode.cn/problems/sum-of-subarray-minimums) | MEDIUM | 4 | 1 | +| 2024-08-05 13:29 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 5 | **3** | | 2024-08-04 15:21 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 4 | **3** | | 2024-08-04 15:18 | [#234 回文链表](https://leetcode.cn/problems/palindrome-linked-list) | EASY | 1 | 1 | | 2024-08-03 17:11 | [#69 x 的平方根 ](https://leetcode.cn/problems/sqrtx) | EASY | 2 | 1 | @@ -127,7 +129,6 @@ | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | | 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | -| 2023-12-05 19:53 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 3 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | | 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | From 695da19e2107aa689cdd321bb2b164d2f3edf71e Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 7 Aug 2024 20:31:07 +0800 Subject: [PATCH 323/373] Update changes --- README.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 4678cd8..76f1c35 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,11 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-07 20:16 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 4 | **2** | +| 2024-08-07 16:41 | [#103 二叉树的锯齿形层序遍历](https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal) | MEDIUM | 1 | 1 | +| 2024-08-07 16:24 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 4 | **2** | +| 2024-08-07 15:51 | [#152 乘积最大子数组](https://leetcode.cn/problems/maximum-product-subarray) | MEDIUM | 6 | 1 | +| 2024-08-07 13:54 | [#面试题 17.10 主要元素](https://leetcode.cn/problems/find-majority-element-lcci) | EASY | 3 | 1 | | 2024-08-05 14:23 | [#907 子数组的最小值之和](https://leetcode.cn/problems/sum-of-subarray-minimums) | MEDIUM | 4 | 1 | | 2024-08-05 13:29 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 5 | **3** | | 2024-08-04 15:21 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 4 | **3** | @@ -105,7 +110,6 @@ | 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | | 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | | 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | -| 2024-03-03 11:41 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 3 | 1 | | 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | | 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | @@ -450,4 +454,3 @@ | 2020-07-20 14:17 | [#167 两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted) | MEDIUM | 1 | 1 | | 2020-07-18 23:56 | [#97 交错字符串](https://leetcode.cn/problems/interleaving-string) | MEDIUM | 4 | 1 | | 2020-07-17 16:01 | [#35 搜索插入位置](https://leetcode.cn/problems/search-insert-position) | EASY | 7 | 1 | -| 2020-04-22 22:11 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 3 | 1 | From 4b79bafb4b7e2801e3e6ffb0d77ba75936d6b71d Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 12 Aug 2024 20:32:36 +0800 Subject: [PATCH 324/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 76f1c35..4ac49ee 100644 --- a/README.md +++ b/README.md @@ -123,7 +123,7 @@ | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | | 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | -| 2023-12-29 15:53 | [#230 二叉搜索树中第K小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | +| 2023-12-29 15:53 | [#230 二叉搜索树中第 K 小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | | 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | From 247403b9983bad1f7817d186465ff88e0df0d28f Mon Sep 17 00:00:00 2001 From: linze Date: Tue, 13 Aug 2024 14:11:54 +0800 Subject: [PATCH 325/373] =?UTF-8?q?Create=20200.=20=E5=B2=9B=E5=B1=BF?= =?UTF-8?q?=E6=95=B0=E9=87=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...33\345\261\277\346\225\260\351\207\217.md" | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 "Depth First Search/200. \345\262\233\345\261\277\346\225\260\351\207\217.md" diff --git "a/Depth First Search/200. \345\262\233\345\261\277\346\225\260\351\207\217.md" "b/Depth First Search/200. \345\262\233\345\261\277\346\225\260\351\207\217.md" new file mode 100644 index 0000000..756337e --- /dev/null +++ "b/Depth First Search/200. \345\262\233\345\261\277\346\225\260\351\207\217.md" @@ -0,0 +1,83 @@ +#### 200. 岛屿数量 + +难度：中等 + +--- + +给你一个由 `'1'`（陆地）和 `'0'`（水）组成的的二维网格，请你计算网格中岛屿的数量。 + +岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 + +此外，你可以假设该网格的四条边均被水包围。 + + **示例 1：** + +``` +输入：grid = [ + ["1","1","1","1","0"], + ["1","1","0","1","0"], + ["1","1","0","0","0"], + ["0","0","0","0","0"] +] +输出：1 +``` + + **示例 2：** + +``` +输入：grid = [ + ["1","1","0","0","0"], + ["1","1","0","0","0"], + ["0","0","1","0","0"], + ["0","0","0","1","1"] +] +输出：3 +``` + + **提示：** + +* `m == grid.length` +* `n == grid[i].length` +* `1 <= m, n <= 300` +* `grid[i][j]` 的值为 `'0'` 或 `'1'` + +--- + +深度搜索优先： + +遍历每一格数据，如果当前格数据为 `1`，则岛屿数量加一，并且将四周（上下左右）的 `1` 变为 `0`，不断扩散（深度搜索） + +```Go +func numIslands(grid [][]byte) int { + res := 0 + var dfs func(grid [][]byte, i, j int) + dfs = func(grid [][]byte, i, j int) { + if grid[i][j] == '0' { + return + } + m, n := len(grid), len(grid[0]) + grid[i][j] = '0' + if i > 0 { + dfs(grid, i - 1, j) + } + if i < m - 1 { + dfs(grid, i + 1, j) + } + if j > 0 { + dfs(grid, i, j - 1) + } + if j < n - 1 { + dfs(grid, i, j + 1) + } + } + for i := 0; i < len(grid); i++ { + for j := 0; j < len(grid[0]); j++ { + if grid[i][j] == '1' { + dfs(grid, i, j) + res ++ + } + } + } + return res +} +``` \ No newline at end of file From 6bed04bc7a3017de1a27969fdd3f46138d61df17 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 13 Aug 2024 14:15:06 +0800 Subject: [PATCH 326/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 4ac49ee..b40317f 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-13 13:56 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 2 | **2** | | 2024-08-07 20:16 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 4 | **2** | | 2024-08-07 16:41 | [#103 二叉树的锯齿形层序遍历](https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal) | MEDIUM | 1 | 1 | | 2024-08-07 16:24 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 4 | **2** | @@ -426,7 +427,6 @@ | 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | | 2021-05-24 11:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | | 2021-05-22 00:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | -| 2021-05-21 14:21 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 1 | 1 | | 2021-05-10 15:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | | 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | | 2021-05-05 10:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | From c6a4c29372022dcafbc43d36364ed69370cb8d54 Mon Sep 17 00:00:00 2001 From: linze Date: Tue, 13 Aug 2024 20:16:07 +0800 Subject: [PATCH 327/373] =?UTF-8?q?Update=20=E5=B0=8F=E4=BA=8E=20N=20?= =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=95=B0.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\346\234\200\345\244\247\346\225\260.md" | 43 ++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git "a/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" "b/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" index 1a3282d..cbb2abe 100644 --- "a/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" +++ "b/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" @@ -14,7 +14,48 @@ --- -贪心 + 二分查找：详见注释。 +深度搜索优先：时间复杂度 `O n^len(target)` + +```go +package main + +import ( + "fmt" +) + +var res int + +func main() { + nums := []int{2, 4, 6, 8} + target := 2411 + backtrack(nums, target, 0) + fmt.Println(res) +} + +func backtrack(nums []int, target, sum int) { + if sum >= target { + return + } + res = max(res, sum) + for i := range nums { + backtrack(nums, target, 10*sum+nums[i]) + } +} + +func max(i, j int) int { + if i > j { + return i + } + return j +} + +``` + + + + + +贪心 + 二分查找：时间复杂度 `Ologn` ```java package com.example.demo.test; From 07a97a80376e1aed2b624e4c1cd1b48568ddc655 Mon Sep 17 00:00:00 2001 From: linze Date: Wed, 14 Aug 2024 13:48:15 +0800 Subject: [PATCH 328/373] =?UTF-8?q?Create=203152.=20=E7=89=B9=E6=AE=8A?= =?UTF-8?q?=E6=95=B0=E7=BB=84=20II.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...346\256\212\346\225\260\347\273\204 II.md" | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 "Dynamic Programming/3152. \347\211\271\346\256\212\346\225\260\347\273\204 II.md" diff --git "a/Dynamic Programming/3152. \347\211\271\346\256\212\346\225\260\347\273\204 II.md" "b/Dynamic Programming/3152. \347\211\271\346\256\212\346\225\260\347\273\204 II.md" new file mode 100644 index 0000000..09e7840 --- /dev/null +++ "b/Dynamic Programming/3152. \347\211\271\346\256\212\346\225\260\347\273\204 II.md" @@ -0,0 +1,66 @@ +#### 3152. 特殊数组 II + +难度：中等 + +--- + +如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个 **特殊数组** 。 + +周洋哥有一个整数数组 `nums` 和一个二维整数矩阵 `queries`，对于 `queries[i] = [fromi, toi]`，请你帮助周洋哥检查子数组 `nums[fromi..toi]` 是不是一个 **特殊数组** 。 + +返回布尔数组 `answer`，如果 `nums[fromi..toi]` 是特殊数组，则 `answer[i]` 为 `true` ，否则，`answer[i]` 为 `false` 。 + + **示例 1：** + + **输入：** nums = \[3,4,1,2,6\], queries = \[\[0,4\]\] + + **输出：** \[false\] + + **解释：** + +子数组是 `[3,4,1,2,6]`。2 和 6 都是偶数。 + + **示例 2：** + + **输入：** nums = \[4,3,1,6\], queries = \[\[0,2\],\[2,3\]\] + + **输出：** \[false,true\] + + **解释：** + +1. 子数组是 `[4,3,1]`。3 和 1 都是奇数。因此这个查询的答案是 `false`。 +2. 子数组是 `[1,6]`。只有一对：`(1,6)`，且包含了奇偶性不同的数字。因此这个查询的答案是 `true`。 + + **提示：** + +* `1 <= nums.length <= 10^5` +* `1 <= nums[i] <= 10^5` +* `1 <= queries.length <= 10^5` +* `queries[i].length == 2` +* `0 <= queries[i][0] <= queries[i][1] <= nums.length - 1` + +--- + +动态规划： + +一维数组 `dp[i]` 表示下标 `i` 的数是特殊数组的第几个数。例如 `[3,4,1,2,6]` 所对应的 `dp[i]` 分别是 `[1, 2, 3, 4, 1]`，前四个数为一组特殊数组，最后一个数单独构成一组特殊数组。然后根据给定的区间和当前下标的值进行比较。 + +```Go +func isArraySpecial(nums []int, queries [][]int) []bool { + n := len(nums) + dp := make([]int, n) + dp[0] = 1 + for i := 1; i < n; i++ { + dp[i] = 1 + if ((nums[i] ^ nums[i - 1]) & 1 == 1) { + dp[i] = dp[i - 1] + 1 + } + } + res := []bool{} + for i := range queries { + gap := queries[i][1] - queries[i][0] + res = append(res, dp[queries[i][1]] >= gap + 1) + } + return res +} +``` \ No newline at end of file From c39d4324a1705b6e937b61636fccaaa5143c8c51 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 14 Aug 2024 13:51:01 +0800 Subject: [PATCH 329/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b40317f..1a8c992 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-14 11:50 | [#3152 特殊数组 II](https://leetcode.cn/problems/special-array-ii) | MEDIUM | 3 | 1 | | 2024-08-13 13:56 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 2 | **2** | | 2024-08-07 20:16 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 4 | **2** | | 2024-08-07 16:41 | [#103 二叉树的锯齿形层序遍历](https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal) | MEDIUM | 1 | 1 | From 0918465dd584583e875d1603f49d9442cde8b28f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 15 Aug 2024 09:05:36 +0800 Subject: [PATCH 330/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1a8c992..ee0ae95 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-14 21:23 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 2 | 1 | | 2024-08-14 11:50 | [#3152 特殊数组 II](https://leetcode.cn/problems/special-array-ii) | MEDIUM | 3 | 1 | | 2024-08-13 13:56 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 2 | **2** | | 2024-08-07 20:16 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 4 | **2** | @@ -422,7 +423,6 @@ | 2021-07-05 13:41 | [#45 跳跃游戏 II](https://leetcode.cn/problems/jump-game-ii) | MEDIUM | 15 | 1 | | 2021-07-05 12:31 | [#509 斐波那契数](https://leetcode.cn/problems/fibonacci-number) | EASY | 2 | 1 | | 2021-07-02 15:38 | [#1833 雪糕的最大数量](https://leetcode.cn/problems/maximum-ice-cream-bars) | MEDIUM | 4 | 1 | -| 2021-06-15 10:56 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 1 | 1 | | 2021-06-13 15:46 | [#278 第一个错误的版本](https://leetcode.cn/problems/first-bad-version) | EASY | 4 | 1 | | 2021-06-04 09:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | | 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | From 0b733f8fa3d71e193506d406eb03edf8a698fd7c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 15 Aug 2024 20:30:42 +0800 Subject: [PATCH 331/373] Update changes --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ee0ae95..0e13a33 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | -| 2024-08-14 21:23 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 2 | 1 | +| 2024-08-15 19:27 | [#125 验证回文串](https://leetcode.cn/problems/valid-palindrome) | EASY | 2 | 1 | +| 2024-08-15 18:56 | [#680 验证回文串 II](https://leetcode.cn/problems/valid-palindrome-ii) | EASY | 1 | 1 | +| 2024-08-15 10:18 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 6 | **2** | | 2024-08-14 11:50 | [#3152 特殊数组 II](https://leetcode.cn/problems/special-array-ii) | MEDIUM | 3 | 1 | | 2024-08-13 13:56 | [#200 岛屿数量](https://leetcode.cn/problems/number-of-islands) | MEDIUM | 2 | **2** | | 2024-08-07 20:16 | [#17 电话号码的字母组合](https://leetcode.cn/problems/letter-combinations-of-a-phone-number) | MEDIUM | 4 | **2** | From 0b66e87aa56cf8a37c282971f6ce08a13e7ac6e3 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 16 Aug 2024 16:23:21 +0800 Subject: [PATCH 332/373] =?UTF-8?q?Create=20135.=20=E5=88=86=E5=8F=91?= =?UTF-8?q?=E7=B3=96=E6=9E=9C.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...06\345\217\221\347\263\226\346\236\234.md" | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 "Methodology/135. \345\210\206\345\217\221\347\263\226\346\236\234.md" diff --git "a/Methodology/135. \345\210\206\345\217\221\347\263\226\346\236\234.md" "b/Methodology/135. \345\210\206\345\217\221\347\263\226\346\236\234.md" new file mode 100644 index 0000000..bb8e759 --- /dev/null +++ "b/Methodology/135. \345\210\206\345\217\221\347\263\226\346\236\234.md" @@ -0,0 +1,71 @@ +#### 135. 分发糖果 + +难度：困难 + +--- + +`n` 个孩子站成一排。给你一个整数数组 `ratings` 表示每个孩子的评分。 + +你需要按照以下要求，给这些孩子分发糖果： + +* 每个孩子至少分配到 `1` 个糖果。 +* 相邻两个孩子评分更高的孩子会获得更多的糖果。 + +请你给每个孩子分发糖果，计算并返回需要准备的 **最少糖果数目** 。 + + **示例 1：** + +``` +输入：ratings = [1,0,2] +输出：5 +解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。 +``` + + **示例 2：** + +``` +输入：ratings = [1,2,2] +输出：4 +解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。 + 第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。 +``` + + **提示：** + +* `n == ratings.length` +* `1 <= n <= 2 * 10^4` +* `0 <= ratings[i] <= 2 * 10^4` + +--- + +两遍遍历： + +1. 第一次从左向右遍历，记录当前数只与相邻**左**数比较后应获得的糖果数 +2. 第二次从右向左遍历，记录当前数只与相邻**右**数比较后应获得的糖果数，两者取最大值。 + +根据题意，需要准备**最少**的糖果数，因此相邻数进行比较时，评分高的孩子的糖果数一定是比评分低的只多一颗糖果。 + +``` +func candy(ratings []int) int { + n := len(ratings) + candies := make([]int, n) + for i := range candies { + candies[i] = 1 + } + for i := 1; i < n; i++ { + if ratings[i] > ratings[i - 1] { + candies[i] = candies[i - 1] + 1 + } + } + for i := n - 2; i >= 0; i-- { + if ratings[i] > ratings[i + 1] { + candies[i] = max(candies[i], candies[i + 1] + 1) + } + } + res := 0 + for i := range candies { + res += candies[i] + } + return res +} +``` \ No newline at end of file From 5c47a92effa08af452aaadf359cfbcb8727fd414 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 16 Aug 2024 16:26:28 +0800 Subject: [PATCH 333/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 0e13a33..f85ec6e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-16 16:11 | [#135 分发糖果](https://leetcode.cn/problems/candy) | HARD | 1 | 1 | +| 2024-08-16 14:57 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 6 | **2** | | 2024-08-15 19:27 | [#125 验证回文串](https://leetcode.cn/problems/valid-palindrome) | EASY | 2 | 1 | | 2024-08-15 18:56 | [#680 验证回文串 II](https://leetcode.cn/problems/valid-palindrome-ii) | EASY | 1 | 1 | | 2024-08-15 10:18 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 6 | **2** | @@ -139,7 +141,6 @@ | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | | 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | -| 2023-12-02 13:16 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 3 | **2** | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | From bf722ca85cce6c42c259a7805690158c40c7d4b6 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 16 Aug 2024 20:30:24 +0800 Subject: [PATCH 334/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f85ec6e..5efbffe 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-16 16:59 | [#面试题 17.10 主要元素](https://leetcode.cn/problems/find-majority-element-lcci) | EASY | 5 | **2** | | 2024-08-16 16:11 | [#135 分发糖果](https://leetcode.cn/problems/candy) | HARD | 1 | 1 | | 2024-08-16 14:57 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 6 | **2** | | 2024-08-15 19:27 | [#125 验证回文串](https://leetcode.cn/problems/valid-palindrome) | EASY | 2 | 1 | @@ -37,7 +38,6 @@ | 2024-08-07 16:41 | [#103 二叉树的锯齿形层序遍历](https://leetcode.cn/problems/binary-tree-zigzag-level-order-traversal) | MEDIUM | 1 | 1 | | 2024-08-07 16:24 | [#225 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues) | EASY | 4 | **2** | | 2024-08-07 15:51 | [#152 乘积最大子数组](https://leetcode.cn/problems/maximum-product-subarray) | MEDIUM | 6 | 1 | -| 2024-08-07 13:54 | [#面试题 17.10 主要元素](https://leetcode.cn/problems/find-majority-element-lcci) | EASY | 3 | 1 | | 2024-08-05 14:23 | [#907 子数组的最小值之和](https://leetcode.cn/problems/sum-of-subarray-minimums) | MEDIUM | 4 | 1 | | 2024-08-05 13:29 | [#53 最大子数组和](https://leetcode.cn/problems/maximum-subarray) | MEDIUM | 5 | **3** | | 2024-08-04 15:21 | [#206 反转链表](https://leetcode.cn/problems/reverse-linked-list) | EASY | 4 | **3** | From 8472d40c47b69dfb985bd50a134e38ecfb3adb2a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sun, 18 Aug 2024 20:31:01 +0800 Subject: [PATCH 335/373] Update changes --- README.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 5efbffe..f76f51b 100644 --- a/README.md +++ b/README.md @@ -26,9 +26,14 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-18 15:32 | [#622 设计循环队列](https://leetcode.cn/problems/design-circular-queue) | MEDIUM | 2 | 1 | +| 2024-08-18 15:02 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 4 | 1 | +| 2024-08-18 13:28 | [#752 打开转盘锁](https://leetcode.cn/problems/open-the-lock) | MEDIUM | 3 | 1 | +| 2024-08-18 12:29 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 2 | **2** | +| 2024-08-18 11:57 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 12 | **3** | +| 2024-08-18 11:03 | [#3115 质数的最大距离](https://leetcode.cn/problems/maximum-prime-difference) | MEDIUM | 1 | 1 | | 2024-08-16 16:59 | [#面试题 17.10 主要元素](https://leetcode.cn/problems/find-majority-element-lcci) | EASY | 5 | **2** | | 2024-08-16 16:11 | [#135 分发糖果](https://leetcode.cn/problems/candy) | HARD | 1 | 1 | -| 2024-08-16 14:57 | [#215 数组中的第K个最大元素](https://leetcode.cn/problems/kth-largest-element-in-an-array) | MEDIUM | 6 | **2** | | 2024-08-15 19:27 | [#125 验证回文串](https://leetcode.cn/problems/valid-palindrome) | EASY | 2 | 1 | | 2024-08-15 18:56 | [#680 验证回文串 II](https://leetcode.cn/problems/valid-palindrome-ii) | EASY | 1 | 1 | | 2024-08-15 10:18 | [#33 搜索旋转排序数组](https://leetcode.cn/problems/search-in-rotated-sorted-array) | MEDIUM | 6 | **2** | @@ -87,7 +92,6 @@ | 2024-07-17 23:16 | [#128 最长连续序列](https://leetcode.cn/problems/longest-consecutive-sequence) | MEDIUM | 15 | **2** | | 2024-07-16 20:57 | [#337 打家劫舍 III](https://leetcode.cn/problems/house-robber-iii) | MEDIUM | 5 | **3** | | 2024-07-15 20:07 | [#328 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list) | MEDIUM | 3 | **2** | -| 2024-07-14 21:41 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 3 | 1 | | 2024-07-14 11:01 | [#102 二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal) | MEDIUM | 4 | **2** | | 2024-07-14 10:40 | [#23 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists) | HARD | 7 | **2** | | 2024-07-13 22:05 | [#24 两两交换链表中的节点](https://leetcode.cn/problems/swap-nodes-in-pairs) | MEDIUM | 7 | **2** | @@ -128,7 +132,6 @@ | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | -| 2024-01-18 10:52 | [#148 排序链表](https://leetcode.cn/problems/sort-list) | MEDIUM | 1 | 1 | | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 15:53 | [#230 二叉搜索树中第 K 小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | From fca40b6e19563459fe640435b49b4b623ef3c409 Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 19 Aug 2024 14:51:24 +0800 Subject: [PATCH 336/373] =?UTF-8?q?Create=20958.=20=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E7=9A=84=E5=AE=8C=E5=85=A8=E6=80=A7=E6=A3=80=E9=AA=8C?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...50\346\200\247\346\243\200\351\252\214.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Breadth First Search/958. \344\272\214\345\217\211\346\240\221\347\232\204\345\256\214\345\205\250\346\200\247\346\243\200\351\252\214.md" diff --git "a/Breadth First Search/958. \344\272\214\345\217\211\346\240\221\347\232\204\345\256\214\345\205\250\346\200\247\346\243\200\351\252\214.md" "b/Breadth First Search/958. \344\272\214\345\217\211\346\240\221\347\232\204\345\256\214\345\205\250\346\200\247\346\243\200\351\252\214.md" new file mode 100644 index 0000000..e971195 --- /dev/null +++ "b/Breadth First Search/958. \344\272\214\345\217\211\346\240\221\347\232\204\345\256\214\345\205\250\346\200\247\346\243\200\351\252\214.md" @@ -0,0 +1,69 @@ +#### 958. 二叉树的完全性检验 + +难度：中等 + +--- + +给你一棵二叉树的根节点 `root` ，请你判断这棵树是否是一棵 **完全二叉树**  。 + +在一棵 **[完全二叉树](https://baike.baidu.com/item/完全二叉树/7773232?fr=aladdin)** 中，除了最后一层外，所有层都被完全填满，并且最后一层中的所有节点都尽可能靠左。最后一层（第 `h` 层）中可以包含 `1` 到 `2^h` 个节点。 + + **示例 1：** + +![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/15/complete-binary-tree-1.png) + +``` +输入：root = [1,2,3,4,5,6] +输出：true +解释：最后一层前的每一层都是满的（即，节点值为 {1} 和 {2,3} 的两层），且最后一层中的所有节点（{4,5,6}）尽可能靠左。 +``` + + **示例 2：** + + **![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/15/complete-binary-tree-2.png)** + +``` +输入：root = [1,2,3,4,5,null,7] +输出：false +解释：值为 7 的节点不满足条件「节点尽可能靠左」。 +``` + + **提示：** + +* 树中节点数目在范围 `[1, 100]` 内 +* `1 <= Node.val <= 1000` + +--- + +广度搜索优先： + +层序遍历将所有节点（包括空节点）放入队列中，并且检查队列中的节点是否是空节点然后弹出，如果遇到空节点并且后续有节点再插入到队列中，意味着肯定为非完全二叉树。 + +```Go +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func isCompleteTree(root *TreeNode) bool { + flag := false + queue := []*TreeNode{root} + for len(queue) > 0 { + node := queue[0] + queue = queue[1:] + if node == nil { + flag = true + } else { + if flag == true { + return false + } + queue = append(queue, node.Left) + queue = append(queue, node.Right) + } + } + return true +} +``` \ No newline at end of file From 17c6e4e4af3a4798198581beb24f64172591110a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 19 Aug 2024 14:54:50 +0800 Subject: [PATCH 337/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index f76f51b..3b937aa 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-19 14:46 | [#958 二叉树的完全性检验](https://leetcode.cn/problems/check-completeness-of-a-binary-tree) | MEDIUM | 1 | 1 | | 2024-08-18 15:32 | [#622 设计循环队列](https://leetcode.cn/problems/design-circular-queue) | MEDIUM | 2 | 1 | | 2024-08-18 15:02 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 4 | 1 | | 2024-08-18 13:28 | [#752 打开转盘锁](https://leetcode.cn/problems/open-the-lock) | MEDIUM | 3 | 1 | From e5a6cb40bb752fff6c195134dfe6b6eb4af85c03 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 19 Aug 2024 20:31:00 +0800 Subject: [PATCH 338/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3b937aa..7ccc11e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-19 16:14 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 4 | **2** | | 2024-08-19 14:46 | [#958 二叉树的完全性检验](https://leetcode.cn/problems/check-completeness-of-a-binary-tree) | MEDIUM | 1 | 1 | | 2024-08-18 15:32 | [#622 设计循环队列](https://leetcode.cn/problems/design-circular-queue) | MEDIUM | 2 | 1 | | 2024-08-18 15:02 | [#470 用 Rand7() 实现 Rand10()](https://leetcode.cn/problems/implement-rand10-using-rand7) | MEDIUM | 4 | 1 | @@ -434,7 +435,6 @@ | 2021-06-04 09:26 | [#160 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists) | EASY | 7 | 1 | | 2021-05-24 16:52 | [#130 被围绕的区域](https://leetcode.cn/problems/surrounded-regions) | MEDIUM | 4 | **2** | | 2021-05-24 11:09 | [#547 省份数量](https://leetcode.cn/problems/number-of-provinces) | MEDIUM | 1 | 1 | -| 2021-05-22 00:06 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 3 | 1 | | 2021-05-10 15:31 | [#872 叶子相似的树](https://leetcode.cn/problems/leaf-similar-trees) | EASY | 7 | 1 | | 2021-05-05 10:53 | [#154 寻找旋转排序数组中的最小值 II](https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii) | HARD | 1 | 1 | | 2021-05-05 10:49 | [#LCR 128 库存管理 I](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof) | EASY | 2 | **2** | From f33414208f856c12d8a974ce0aaca1a623bef992 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 20 Aug 2024 20:31:27 +0800 Subject: [PATCH 339/373] Update changes --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 7ccc11e..2b5a49e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-20 18:25 | [#43 字符串相乘](https://leetcode.cn/problems/multiply-strings) | MEDIUM | 1 | 1 | +| 2024-08-20 14:57 | [#145 二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal) | EASY | 1 | 1 | +| 2024-08-20 09:38 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 3 | **2** | | 2024-08-19 16:14 | [#695 岛屿的最大面积](https://leetcode.cn/problems/max-area-of-island) | MEDIUM | 4 | **2** | | 2024-08-19 14:46 | [#958 二叉树的完全性检验](https://leetcode.cn/problems/check-completeness-of-a-binary-tree) | MEDIUM | 1 | 1 | | 2024-08-18 15:32 | [#622 设计循环队列](https://leetcode.cn/problems/design-circular-queue) | MEDIUM | 2 | 1 | @@ -149,7 +152,6 @@ | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | | 2023-12-01 14:44 | [#2661 找出叠涂元素](https://leetcode.cn/problems/first-completely-painted-row-or-column) | MEDIUM | 3 | 1 | -| 2023-11-25 15:33 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 2 | 1 | | 2023-11-13 20:11 | [#307 区域和检索 - 数组可修改](https://leetcode.cn/problems/range-sum-query-mutable) | MEDIUM | 4 | **3** | | 2023-11-13 15:25 | [#1234 替换子串得到平衡字符串](https://leetcode.cn/problems/replace-the-substring-for-balanced-string) | MEDIUM | 2 | 1 | | 2023-11-10 22:06 | [#114 二叉树展开为链表](https://leetcode.cn/problems/flatten-binary-tree-to-linked-list) | MEDIUM | 2 | **2** | From 8d9f125b664c365cdba72f78b7ba5f49ae3ddb22 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 24 Aug 2024 09:19:05 +0800 Subject: [PATCH 340/373] =?UTF-8?q?Create=2043.=20=E5=AD=97=E7=AC=A6?= =?UTF-8?q?=E4=B8=B2=E7=9B=B8=E4=B9=98.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...46\344\270\262\347\233\270\344\271\230.md" | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 "Simulation/43. \345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.md" diff --git "a/Simulation/43. \345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.md" "b/Simulation/43. \345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.md" new file mode 100644 index 0000000..88ac2e3 --- /dev/null +++ "b/Simulation/43. \345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.md" @@ -0,0 +1,63 @@ +#### 43. 字符串相乘 + +难度：中等 + +--- + +给定两个以字符串形式表示的非负整数 `num1` 和 `num2`，返回 `num1` 和 `num2` 的乘积，它们的乘积也表示为字符串形式。 + + **注意：** 不能使用任何内置的 BigInteger 库或直接将输入转换为整数。 + + **示例 1:** + +``` +输入: num1 = "2", num2 = "3" +输出: "6" +``` + + **示例 2:** + +``` +输入: num1 = "123", num2 = "456" +输出: "56088" +``` + + **提示：** + +* `1 <= num1.length, num2.length <= 200` +* `num1` 和 `num2` 只能由数字组成。 +* `num1` 和 `num2` 都不包含任何前导零，除了数字0本身。 + +--- + +模拟： + +```Java +func multiply(num1 string, num2 string) string { + if num1 == "0" || num2 == "0" { + return "0" + } + m, n := len(num1), len(num2) + array := make([]int, m+n) // 两数相乘，最大长度为 m+n + for i := m - 1; i >= 0; i-- { + temp1 := int(num1[i] - '0') + for j := n - 1; j >= 0; j-- { + temp2 := int(num2[j] - '0') + array[i+j+1] += temp1 * temp2 // 存储的是乘积，没向前进位 + } + } + // 处理进位，i的进位位置在i-1位置 + for i := len(array) - 1; i > 0; i-- { + array[i-1] += array[i] / 10 + array[i] %= 10 + } + res := "" + for i := range array { + if i == 0 && array[i] == 0 { // 如果第0位为0，则需要处理 + continue + } + res += string(array[i] + '0') + } + return res +} +``` \ No newline at end of file From 90fe2d3bb52a1464995bd8f947ad519b56f947e8 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 24 Aug 2024 09:26:14 +0800 Subject: [PATCH 341/373] =?UTF-8?q?Create=20146.=20LRU=20=E7=BC=93?= =?UTF-8?q?=E5=AD=98.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../146. LRU \347\274\223\345\255\230.md" | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 "Hash Table/146. LRU \347\274\223\345\255\230.md" diff --git "a/Hash Table/146. LRU \347\274\223\345\255\230.md" "b/Hash Table/146. LRU \347\274\223\345\255\230.md" new file mode 100644 index 0000000..bc8f7c2 --- /dev/null +++ "b/Hash Table/146. LRU \347\274\223\345\255\230.md" @@ -0,0 +1,96 @@ +#### 146. LRU 缓存 + +难度：中等 + +--- + +请你设计并实现一个满足  [LRU (最近最少使用) 缓存](https://baike.baidu.com/item/LRU) 约束的数据结构。 + +实现 `LRUCache` 类： + +* `LRUCache(int capacity)` 以 **正整数** 作为容量 `capacity` 初始化 LRU 缓存 +* `int get(int key)` 如果关键字 `key` 存在于缓存中，则返回关键字的值，否则返回 `-1` 。 +* `void put(int key, int value)` 如果关键字 `key` 已经存在，则变更其数据值 `value` ；如果不存在，则向缓存中插入该组 `key-value` 。如果插入操作导致关键字数量超过 `capacity` ，则应该 **逐出** 最久未使用的关键字。 + +函数 `get` 和 `put` 必须以 `O(1)` 的平均时间复杂度运行。 + + **示例：** + +``` +输入 +["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] +[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]] +输出 +[null, null, null, 1, null, -1, null, -1, 3, 4] + +解释 +LRUCache lRUCache = new LRUCache(2); +lRUCache.put(1, 1); // 缓存是 {1=1} +lRUCache.put(2, 2); // 缓存是 {1=1, 2=2} +lRUCache.get(1); // 返回 1 +lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3} +lRUCache.get(2); // 返回 -1 (未找到) +lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3} +lRUCache.get(1); // 返回 -1 (未找到) +lRUCache.get(3); // 返回 3 +lRUCache.get(4); // 返回 4 +``` + + **提示：** + +* `1 <= capacity <= 3000` +* `0 <= key <= 10000` +* `0 <= value <= 10^5` +* 最多调用 `2 * 10^5` 次 `get` 和 `put` + +--- + +哈希表 + 双向链表： + +![](https://pic.leetcode.cn/1696039105-PSyHej-146-3-c.png) + +```Java +type LRUCache struct { + doubleLinkedList *list.List + hashmap map[int]*list.Element + capacity int +} + +type entry struct { + k, v int +} + +func Constructor(capacity int) LRUCache { + return LRUCache{list.New(), make(map[int]*list.Element), capacity} +} + +func (this *LRUCache) Get(key int) int { + node := this.hashmap[key] + if node == nil { + return -1 + } + this.doubleLinkedList.MoveToFront(node) + return node.Value.(entry).v +} + +func (this *LRUCache) Put(key int, value int) { + node := this.hashmap[key] + if node != nil { + node.Value = entry{key, value} + this.doubleLinkedList.MoveToFront(node) + return + } + this.hashmap[key] = this.doubleLinkedList.PushFront(entry{key, value}) + if this.capacity < len(this.hashmap) { + delete(this.hashmap, this.doubleLinkedList.Remove(this.doubleLinkedList.Back()).(entry).k) + } +} + + +/** + * Your LRUCache object will be instantiated and called as such: + * obj := Constructor(capacity); + * param_1 := obj.Get(key); + * obj.Put(key,value); + */ +``` \ No newline at end of file From 1863cc8aae24a65860f788d902ca58f187f74482 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 24 Aug 2024 09:45:41 +0800 Subject: [PATCH 342/373] =?UTF-8?q?Create=20LCR=20143.=20=E5=AD=90?= =?UTF-8?q?=E7=BB=93=E6=9E=84=E5=88=A4=E6=96=AD.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...23\346\236\204\345\210\244\346\226\255.md" | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 "Depth First Search/LCR 143. \345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" diff --git "a/Depth First Search/LCR 143. \345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" "b/Depth First Search/LCR 143. \345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" new file mode 100644 index 0000000..e77de62 --- /dev/null +++ "b/Depth First Search/LCR 143. \345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" @@ -0,0 +1,63 @@ +#### LCR 143. 子结构判断 + +难度：中等 + +--- + +给定两棵二叉树 `tree1` 和 `tree2`，判断 `tree2` 是否以 `tree1` 的某个节点为根的子树具有 **相同的结构和节点值** 。 +注意， **空树**  不会是以 `tree1` 的某个节点为根的子树具有 **相同的结构和节点值** 。 + + **示例 1：** + +![](https://pic.leetcode.cn/1694684670-vwyIgY-two_tree.png) + +``` +输入：tree1 = [1,7,5], tree2 = [6,1] +输出：false +解释：tree2 与 tree1 的一个子树没有相同的结构和节点值。 +``` + + **示例 2：** + +![](https://pic.leetcode.cn/1694685602-myWXCv-two_tree_2.png) + +``` +输入：tree1 = [3,6,7,1,8], tree2 = [6,1] +输出：true +解释：tree2 与 tree1 的一个子树拥有相同的结构和节点值。即 6 - > 1。 +``` + + **提示：** + +`0 <= 节点个数 <= 10000` + +--- + +深度搜索优先： + +```Go +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func isSubStructure(A *TreeNode, B *TreeNode) bool { + if A == nil || B == nil { + return false + } + return dfs(A, B) || isSubStructure(A.Left, B) || isSubStructure(A.Right, B) +} + +func dfs(A *TreeNode, B *TreeNode) bool { + if B == nil { + return true + } + if A == nil || A .Val != B.Val { + return false + } + return dfs(A.Left, B.Left) && dfs(A.Right, B.Right) +} +``` \ No newline at end of file From ca344dd9b4a0d29a4ee0c42a0823650430ab892c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 24 Aug 2024 09:48:31 +0800 Subject: [PATCH 343/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2b5a49e..d8d919e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-24 09:43 | [#LCR 143 子结构判断](https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof) | MEDIUM | 2 | 1 | | 2024-08-20 18:25 | [#43 字符串相乘](https://leetcode.cn/problems/multiply-strings) | MEDIUM | 1 | 1 | | 2024-08-20 14:57 | [#145 二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal) | EASY | 1 | 1 | | 2024-08-20 09:38 | [#138 随机链表的复制](https://leetcode.cn/problems/copy-list-with-random-pointer) | MEDIUM | 3 | **2** | From 79e08d36b52a43e9591eeed91f9b9acac4bbf8fb Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 24 Aug 2024 14:14:28 +0800 Subject: [PATCH 344/373] =?UTF-8?q?Update=20=E6=B1=82=E5=B9=B3=E6=96=B9?= =?UTF-8?q?=E6=A0=B9.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...02\345\271\263\346\226\271\346\240\271.md" | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git "a/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" "b/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" index ea4d2fa..a3da4ed 100644 --- "a/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" +++ "b/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" @@ -31,3 +31,28 @@ public class SquareRoot { ``` + + +Go 语言： + +```go +package main + +import "fmt" + +func main() { + num := 8 + target, left, right := float64(num), float64(0), float64(num) + for right-left > 1e-7 { + mid := (left + right) / 2 + if mid*mid > target { + right = mid + } else { + left = mid + } + } + fmt.Println(left) + fmt.Println(right) +} +``` + From 73165ea863337374c44e33d97d0a9bf964cfa1a8 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 24 Aug 2024 14:17:50 +0800 Subject: [PATCH 345/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d8d919e..f9493ee 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-24 10:22 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 6 | **2** | | 2024-08-24 09:43 | [#LCR 143 子结构判断](https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof) | MEDIUM | 2 | 1 | | 2024-08-20 18:25 | [#43 字符串相乘](https://leetcode.cn/problems/multiply-strings) | MEDIUM | 1 | 1 | | 2024-08-20 14:57 | [#145 二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal) | EASY | 1 | 1 | @@ -134,7 +135,6 @@ | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | | 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | -| 2024-01-23 09:27 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 2 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | From 1f62d20252ab199143e0e01f39bae598491961f3 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 24 Aug 2024 20:29:12 +0800 Subject: [PATCH 346/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index f9493ee..0fa5e8d 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-24 14:51 | [#718 最长重复子数组](https://leetcode.cn/problems/maximum-length-of-repeated-subarray) | MEDIUM | 1 | 1 | | 2024-08-24 10:22 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 6 | **2** | | 2024-08-24 09:43 | [#LCR 143 子结构判断](https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof) | MEDIUM | 2 | 1 | | 2024-08-20 18:25 | [#43 字符串相乘](https://leetcode.cn/problems/multiply-strings) | MEDIUM | 1 | 1 | From ebb86e512378b8c7712469cb4e6f9de6c26b5686 Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 26 Aug 2024 10:52:02 +0800 Subject: [PATCH 347/373] =?UTF-8?q?Create=20=E5=B9=B6=E6=9F=A5=E9=9B=86?= =?UTF-8?q?=EF=BC=88Union-Find=EF=BC=89.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\206\357\274\210Union-Find\357\274\211.md" | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 "Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" diff --git "a/Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" "b/Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" new file mode 100644 index 0000000..ebd9483 --- /dev/null +++ "b/Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" @@ -0,0 +1,34 @@ +# 并查集（Union-Find） + +一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。不交集指的是一系列没有重复元素的集合。主要是支持两种操作： + +- **合并（Union）**：将两个集合合并成一个集合。 +- **查找（Find）**：确定某个元素属于哪个集合。通常是返回集合内的一个「代表元素」。 + +```go +type unionFind struct { + father []int +} + +func (u unionFind) init(nums []int) { + for i := range nums { + u.father[i] = i + } +} + +func (u unionFind) find(x int) int { + if u.father[x] == x { + return x + } + root := u.find(u.father[x]) // 状态压缩，找到根节点，而不是一层一层找父节点 + u.father[x] = root + return root +} +func (u unionFind) union(x, y int) { + xRoot, yRoot := u.find(x), u.find(y) + if xRoot != yRoot { + u.father[yRoot] = xRoot + } +} +``` + From 17c5a7c5fa9965b3d67dfe900da0dea886d5a264 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 26 Aug 2024 20:31:22 +0800 Subject: [PATCH 348/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0fa5e8d..a704754 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-26 15:18 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 10 | **3** | | 2024-08-24 14:51 | [#718 最长重复子数组](https://leetcode.cn/problems/maximum-length-of-repeated-subarray) | MEDIUM | 1 | 1 | | 2024-08-24 10:22 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 6 | **2** | | 2024-08-24 09:43 | [#LCR 143 子结构判断](https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof) | MEDIUM | 2 | 1 | @@ -149,7 +150,6 @@ | 2023-12-14 17:19 | [#226 翻转二叉树](https://leetcode.cn/problems/invert-binary-tree) | EASY | 3 | 1 | | 2023-12-10 12:27 | [#1137 第 N 个泰波那契数](https://leetcode.cn/problems/n-th-tribonacci-number) | EASY | 2 | **2** | | 2023-12-10 12:18 | [#70 爬楼梯](https://leetcode.cn/problems/climbing-stairs) | EASY | 3 | **2** | -| 2023-12-06 11:20 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 8 | **2** | | 2023-12-03 10:34 | [#1423 可获得的最大点数](https://leetcode.cn/problems/maximum-points-you-can-obtain-from-cards) | MEDIUM | 2 | 1 | | 2023-12-02 11:49 | [#1094 拼车](https://leetcode.cn/problems/car-pooling) | MEDIUM | 3 | 1 | | 2023-12-01 15:34 | [#287 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number) | MEDIUM | 1 | 1 | From 35d429fa4455a22d4364b70dab15478284d06d58 Mon Sep 17 00:00:00 2001 From: linze Date: Tue, 27 Aug 2024 13:58:05 +0800 Subject: [PATCH 349/373] Create goroutine.md --- Multi-Thread/goroutine.md | 130 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 Multi-Thread/goroutine.md diff --git a/Multi-Thread/goroutine.md b/Multi-Thread/goroutine.md new file mode 100644 index 0000000..50eb46c --- /dev/null +++ b/Multi-Thread/goroutine.md @@ -0,0 +1,130 @@ +# Goroutine + +1. 两个协程轮流打印 `1, 2` + +```go +package main + +import ( + "fmt" + "sync" +) + +var wg sync.WaitGroup + +func main() { + wg.Add(2) + ch1 := make(chan int) + go func() { + defer wg.Done() + for i := 0; i < 10; i++ { + ch1 <- i + if i%2 == 0 { + fmt.Println("1: ", i) + } + } + }() + go func() { + defer wg.Done() + for i := 0; i < 10; i++ { + <-ch1 + if i%2 == 1 { + fmt.Println("2: ", i) + } + } + }() + wg.Wait() +} +``` + +2. 三个协程轮流打印 `1, 2, 3` + +```go +package main + +import ( + "fmt" + "sync" +) + +func main() { + var wg sync.WaitGroup + wg.Add(2) + ch1 := make(chan int) + ch2 := make(chan int) + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + <-ch1 + <-ch2 + if i%3 == 0 { + fmt.Println(1, ": ", i) + } + } + }() + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + ch1 <- 1 + if i%3 == 1 { + fmt.Println(2, ": ", i) + } + } + }() + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + ch2 <- 1 + if i%3 == 2 { + fmt.Println(3, ": ", i) + } + } + }() + wg.Wait() +} +``` + +3. 生产者消费者模型 + +```go +package main + +import ( + "fmt" + "sync" +) + +var wg sync.WaitGroup +var lock sync.Mutex + +func main() { + ch := make(chan int, 100) + producer(ch) + cnt := 3 + wg.Add(cnt) + for i := 0; i < cnt; i++ { + go consumer(i, ch) + } + wg.Wait() +} + +func producer(ch chan int) { + defer close(ch) + for i := 0; i < 10; i++ { + fmt.Println("producer: ", i) + ch <- i + } +} + +func consumer(i int, ch chan int) { + for { + if v, ok := <-ch; ok { + fmt.Println("consumer ", i, ":", v) + } else { + break + } + } + wg.Done() +} +``` + From 9baf068fd6ca6d98322615de6e773439394d2076 Mon Sep 17 00:00:00 2001 From: linze Date: Fri, 30 Aug 2024 19:29:04 +0800 Subject: [PATCH 350/373] Update goroutine.md --- Multi-Thread/goroutine.md | 57 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/Multi-Thread/goroutine.md b/Multi-Thread/goroutine.md index 50eb46c..37e47c2 100644 --- a/Multi-Thread/goroutine.md +++ b/Multi-Thread/goroutine.md @@ -128,3 +128,60 @@ func consumer(i int, ch chan int) { } ``` + + +## 手写协程池 + +```go +package main + +import ( + "fmt" + "time" +) + +type Task struct { + f func() +} + +func (t *Task) Execute() { + t.f() +} + +type Pool struct { + tasks chan *Task + entry chan *Task + nums int +} + +func (p *Pool) Work(id int) { + for task := range p.tasks { + task.Execute() + fmt.Println("excute id: ", id) + time.Sleep(2 * time.Second) + } +} + +func (p *Pool) Run() { + for i := 1; i <= p.nums; i++ { + go p.Work(i) + } + for task := range p.entry { + p.tasks <- task + } +} + +func main() { + task := &Task{f: func() { + fmt.Println("Execute!", time.Now()) + }} + p := &Pool{nums: 3, entry: make(chan *Task), tasks: make(chan *Task)} + go func() { + for { + p.entry <- task + } + }() + p.Run() +} +``` + From 8d08b73254478e0b683a5167a12a88d4b5de496a Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 30 Aug 2024 19:31:53 +0800 Subject: [PATCH 351/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a704754..21baf8b 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-08-30 15:07 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 3 | **2** | | 2024-08-26 15:18 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 10 | **3** | | 2024-08-24 14:51 | [#718 最长重复子数组](https://leetcode.cn/problems/maximum-length-of-repeated-subarray) | MEDIUM | 1 | 1 | | 2024-08-24 10:22 | [#77 组合](https://leetcode.cn/problems/combinations) | MEDIUM | 6 | **2** | @@ -143,7 +144,6 @@ | 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 15:53 | [#230 二叉搜索树中第 K 小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | -| 2023-12-26 22:24 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | | 2023-12-23 10:30 | [#1962 移除石子使总数最小](https://leetcode.cn/problems/remove-stones-to-minimize-the-total) | MEDIUM | 1 | 1 | | 2023-12-20 20:08 | [#94 二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal) | EASY | 1 | 1 | From cc1f2575e056135f07c685e501c017be7c27f6ce Mon Sep 17 00:00:00 2001 From: linze Date: Wed, 4 Sep 2024 16:23:47 +0800 Subject: [PATCH 352/373] =?UTF-8?q?Create=20105.=20=E4=BB=8E=E5=89=8D?= =?UTF-8?q?=E5=BA=8F=E4=B8=8E=E4=B8=AD=E5=BA=8F=E9=81=8D=E5=8E=86=E5=BA=8F?= =?UTF-8?q?=E5=88=97=E6=9E=84=E9=80=A0=E4=BA=8C=E5=8F=89=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\344\272\214\345\217\211\346\240\221.md" | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 "Depth First Search/105. \344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" diff --git "a/Depth First Search/105. \344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" "b/Depth First Search/105. \344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" new file mode 100644 index 0000000..8a54442 --- /dev/null +++ "b/Depth First Search/105. \344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" @@ -0,0 +1,61 @@ +#### 105. 从前序与中序遍历序列构造二叉树 + +难度：中等 + +--- + +给定两个整数数组 `preorder` 和 `inorder` ，其中 `preorder` 是二叉树的 **先序遍历** ， `inorder` 是同一棵树的 **中序遍历** ，请构造二叉树并返回其根节点。 + + **示例 1:** + +![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg) +``` +输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] +输出: [3,9,20,null,null,15,7] +``` + + **示例 2:** + +``` +输入: preorder = [-1], inorder = [-1] +输出: [-1] +``` + + **提示:** + +* `1 <= preorder.length <= 3000` +* `inorder.length == preorder.length` +* `-3000 <= preorder[i], inorder[i] <= 3000` +* `preorder` 和 `inorder` 均 **无重复** 元素 +* `inorder` 均出现在 `preorder` +* `preorder`  **保证** 为二叉树的前序遍历序列 +* `inorder`  **保证** 为二叉树的中序遍历序列 + +--- + +深度搜索优先： + +每次递归对前序序列和中序序列做切片。具体切到什么位置，拿示例推理一遍。 + +```Go +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func buildTree(preorder []int, inorder []int) *TreeNode { + for i := range inorder { + if inorder[i] == preorder[0] { + return &TreeNode{ + Val: inorder[i], + Left: buildTree(preorder[1:i+1], inorder[:i]), + Right: buildTree(preorder[i+1:], inorder[i+1:]), + } + } + } + return nil +} +``` \ No newline at end of file From 6df650d468739fc85506cf00d8e0e95c6f086a3b Mon Sep 17 00:00:00 2001 From: linze Date: Wed, 4 Sep 2024 16:24:36 +0800 Subject: [PATCH 353/373] =?UTF-8?q?Create=20106.=20=E4=BB=8E=E4=B8=AD?= =?UTF-8?q?=E5=BA=8F=E4=B8=8E=E5=90=8E=E5=BA=8F=E9=81=8D=E5=8E=86=E5=BA=8F?= =?UTF-8?q?=E5=88=97=E6=9E=84=E9=80=A0=E4=BA=8C=E5=8F=89=E6=A0=91.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...40\344\272\214\345\217\211\346\240\221.md" | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 "Depth First Search/106. \344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" diff --git "a/Depth First Search/106. \344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" "b/Depth First Search/106. \344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" new file mode 100644 index 0000000..f08d8bf --- /dev/null +++ "b/Depth First Search/106. \344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" @@ -0,0 +1,62 @@ +#### 106. 从中序与后序遍历序列构造二叉树 + +难度：中等 + +--- + +给定两个整数数组 `inorder` 和 `postorder` ，其中 `inorder` 是二叉树的中序遍历， `postorder` 是同一棵树的后序遍历，请你构造并返回这颗 _二叉树_ 。 + + **示例 1:** + +![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg) +``` +输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3] +输出：[3,9,20,null,null,15,7] +``` + + **示例 2:** + +``` +输入：inorder = [-1], postorder = [-1] +输出：[-1] +``` + + **提示:** + +* `1 <= inorder.length <= 3000` +* `postorder.length == inorder.length` +* `-3000 <= inorder[i], postorder[i] <= 3000` +* `inorder` 和 `postorder` 都由 **不同** 的值组成 +* `postorder` 中每一个值都在 `inorder` 中 +* `inorder`  **保证** 是树的中序遍历 +* `postorder`  **保证** 是树的后序遍历 + +--- + +深度搜索优先： + +每次递归对中序序列和后序序列做切片。具体切到什么位置，拿示例推理一遍。 + +```Go +/** + * Definition for a binary tree node. + * type TreeNode struct { + * Val int + * Left *TreeNode + * Right *TreeNode + * } + */ +func buildTree(inorder []int, postorder []int) *TreeNode { + end := len(postorder) - 1 + for i := range inorder { + if inorder[i] == postorder[end] { + return &TreeNode { + Val: inorder[i], + Left: buildTree(inorder[:i], postorder[:i]), + Right: buildTree(inorder[i+1:], postorder[i:end]), + } + } + } + return nil +} +``` \ No newline at end of file From 86814c0f5ee3a45410642e8806ed4db9882ebbd5 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Wed, 4 Sep 2024 16:27:27 +0800 Subject: [PATCH 354/373] Update changes --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 21baf8b..927a69c 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,9 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-04 16:18 | [#105 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal) | MEDIUM | 1 | 1 | +| 2024-09-04 16:08 | [#106 从中序与后序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal) | MEDIUM | 1 | 1 | +| 2024-09-04 15:06 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 3 | **2** | | 2024-08-30 15:07 | [#1143 最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence) | MEDIUM | 3 | **2** | | 2024-08-26 15:18 | [#3 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters) | MEDIUM | 10 | **3** | | 2024-08-24 14:51 | [#718 最长重复子数组](https://leetcode.cn/problems/maximum-length-of-repeated-subarray) | MEDIUM | 1 | 1 | @@ -219,7 +222,6 @@ | 2023-01-30 19:28 | [#1669 合并两个链表](https://leetcode.cn/problems/merge-in-between-linked-lists) | MEDIUM | 2 | 1 | | 2023-01-28 14:37 | [#1664 生成平衡数组的方案数](https://leetcode.cn/problems/ways-to-make-a-fair-array) | MEDIUM | 2 | 1 | | 2023-01-27 20:38 | [#503 下一个更大元素 II](https://leetcode.cn/problems/next-greater-element-ii) | MEDIUM | 3 | 1 | -| 2023-01-27 19:53 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 2 | 1 | | 2023-01-26 18:25 | [#1663 具有给定数值的最小字符串](https://leetcode.cn/problems/smallest-string-with-a-given-numeric-value) | MEDIUM | 2 | 1 | | 2023-01-23 22:32 | [#199 二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view) | MEDIUM | 2 | 1 | | 2023-01-16 22:39 | [#1813 句子相似性 III](https://leetcode.cn/problems/sentence-similarity-iii) | MEDIUM | 3 | 1 | From 3256bfd7d06243e5d6dc4762d7180cb02281a645 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 5 Sep 2024 20:32:08 +0800 Subject: [PATCH 355/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 927a69c..f7825cb 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-05 09:08 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 8 | **4** | | 2024-09-04 16:18 | [#105 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal) | MEDIUM | 1 | 1 | | 2024-09-04 16:08 | [#106 从中序与后序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal) | MEDIUM | 1 | 1 | | 2024-09-04 15:06 | [#42 接雨水](https://leetcode.cn/problems/trapping-rain-water) | HARD | 3 | **2** | @@ -144,7 +145,6 @@ | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | -| 2024-01-03 09:18 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 7 | **3** | | 2023-12-29 15:53 | [#230 二叉搜索树中第 K 小的元素](https://leetcode.cn/problems/kth-smallest-element-in-a-bst) | MEDIUM | 1 | 1 | | 2023-12-29 15:01 | [#78 子集](https://leetcode.cn/problems/subsets) | MEDIUM | 2 | 1 | | 2023-12-24 12:30 | [#567 字符串的排列](https://leetcode.cn/problems/permutation-in-string) | MEDIUM | 3 | 1 | From 8a6bebc1db45f64ffa1ea6385aa0dec255a5f3b6 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 6 Sep 2024 20:31:19 +0800 Subject: [PATCH 356/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f7825cb..2dafd94 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-06 11:31 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 5 | **2** | | 2024-09-05 09:08 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 8 | **4** | | 2024-09-04 16:18 | [#105 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal) | MEDIUM | 1 | 1 | | 2024-09-04 16:08 | [#106 从中序与后序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal) | MEDIUM | 1 | 1 | @@ -262,7 +263,6 @@ | 2022-11-24 15:03 | [#795 区间子数组个数](https://leetcode.cn/problems/number-of-subarrays-with-bounded-maximum) | MEDIUM | 3 | 1 | | 2022-11-23 21:31 | [#878 第 N 个神奇数字](https://leetcode.cn/problems/nth-magical-number) | HARD | 9 | **2** | | 2022-11-23 17:30 | [#1742 盒子中小球的最大数量](https://leetcode.cn/problems/maximum-number-of-balls-in-a-box) | EASY | 1 | 1 | -| 2022-11-21 20:32 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 4 | 1 | | 2022-11-21 19:47 | [#16 最接近的三数之和](https://leetcode.cn/problems/3sum-closest) | MEDIUM | 2 | 1 | | 2022-11-21 18:17 | [#1 两数之和](https://leetcode.cn/problems/two-sum) | EASY | 11 | **2** | | 2022-11-21 14:35 | [#692 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words) | MEDIUM | 2 | 1 | From b8011630ec3e6ba42861a8e56071ce7c19321d5b Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Fri, 13 Sep 2024 20:31:40 +0800 Subject: [PATCH 357/373] Update changes --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2dafd94..55ce364 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-13 19:45 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 4 | **3** | | 2024-09-06 11:31 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 5 | **2** | | 2024-09-05 09:08 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 8 | **4** | | 2024-09-04 16:18 | [#105 从前序与中序遍历序列构造二叉树](https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal) | MEDIUM | 1 | 1 | @@ -136,7 +137,6 @@ | 2024-03-15 14:19 | [#2487 从链表中移除节点](https://leetcode.cn/problems/remove-nodes-from-linked-list) | MEDIUM | 1 | 1 | | 2024-03-12 18:00 | [#1261 在受污染的二叉树中查找元素](https://leetcode.cn/problems/find-elements-in-a-contaminated-binary-tree) | MEDIUM | 1 | 1 | | 2024-03-10 10:17 | [#299 猜数字游戏](https://leetcode.cn/problems/bulls-and-cows) | MEDIUM | 2 | 1 | -| 2024-02-09 10:42 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 3 | **2** | | 2024-01-26 15:56 | [#91 解码方法](https://leetcode.cn/problems/decode-ways) | MEDIUM | 2 | 1 | | 2024-01-26 10:13 | [#235 二叉搜索树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree) | MEDIUM | 3 | 1 | | 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | From 3d7b2b39f68c802b8c1563f091a63ca025af59de Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 21 Sep 2024 12:41:56 +0800 Subject: [PATCH 358/373] Create Software Design Pattern.md --- Software Design Pattern.md | 51 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 Software Design Pattern.md diff --git a/Software Design Pattern.md b/Software Design Pattern.md new file mode 100644 index 0000000..97d4ec0 --- /dev/null +++ b/Software Design Pattern.md @@ -0,0 +1,51 @@ +# 设计模式 + +1. 责任链模式 + +```go +package main + +import "fmt" + +type person struct { +} + +type chain interface { + check(person) + setNext(chain) +} + +type check1 struct { + next chain +} + +func (c check1) check(p person) { + fmt.Println("check1") + c.next.check(p) +} + +func (c check1) setNext(ch chain) { + c.next = ch +} + +type check2 struct { + next chain +} + +func (c check2) check(p person) { + fmt.Println("check2") +} + +func (c check2) setNext(ch chain) { + c.next = ch +} + +func main() { + p := person{} + + c1 := &check1{next: check2{}} + c1.check(p) +} + +``` + From e2bb1757f9f93dc9934f53b0ad8177652ce2858f Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 21 Sep 2024 19:57:05 +0800 Subject: [PATCH 359/373] =?UTF-8?q?Create=20=E5=88=87=E6=9C=A8=E5=A4=B4.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../\345\210\207\346\234\250\345\244\264.md" | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 "Dichotomy/\345\210\207\346\234\250\345\244\264.md" diff --git "a/Dichotomy/\345\210\207\346\234\250\345\244\264.md" "b/Dichotomy/\345\210\207\346\234\250\345\244\264.md" new file mode 100644 index 0000000..5366f85 --- /dev/null +++ "b/Dichotomy/\345\210\207\346\234\250\345\244\264.md" @@ -0,0 +1,69 @@ +#### 问题描述 + +给定长度为n的数组，每个元素代表一个木头的长度，木头可以任意截断，从这堆木头中截出至少k个相同长度为m的木块。已知k，求max(m)。 + +输入两行，第一行n, k，第二行为数组序列。输出最大值。数据保证有解，即结果至少是1。 + +**输入** + +``` +5 5 +4 7 2 10 5 +``` + +**输出** + +``` +4 +``` + +**解释** + +如图，最多可以把它分成5段长度为4的木头 + +![](https://raw.githubusercontent.com/CompetitiveLin/ImageHostingService/picgo/imgs/202409211952291.png) + +--- + +对结果二分：从一到木棍最长的长度进行二分遍历，每次遍历的长度作为 `i`，检查是否可以将所有木头截出来 `k` 个长度为 `i` 的木块 + +```go +package main + +import "fmt" + +func main() { + n, k := 5, 5 + arrays := []int{4, 7, 2, 10, 5} + fmt.Println(wood(n, k, arrays)) +} + +func check(arrays []int, m int) int { + res := 0 + for i := range arrays { + res += arrays[i] / m + } + return res +} + +func wood(n, k int, arrays []int) int { + l, r := 1, 1 + for i := range arrays { + if r < arrays[i] { + r = arrays[i] + } + } + r++ + for l < r { + mid := (l + r + 1) >> 1 + if check(arrays, mid) >= k { + l = mid + } else { + r = mid - 1 + } + } + return l +} + +``` + From 877b15750f60e5580fadbcbd0988365c847b9cdc Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 21 Sep 2024 19:57:57 +0800 Subject: [PATCH 360/373] move --- ...0\345\244\264.md" => "\345\210\207\346\234\250\345\244\264.md" | 0 ...272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" | 0 ...1.md" => "\346\261\202\345\271\263\346\226\271\346\240\271.md" | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename "Dichotomy/\345\210\207\346\234\250\345\244\264.md" => "\345\210\207\346\234\250\345\244\264.md" (100%) rename "Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" => "\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" (100%) rename "Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" => "\346\261\202\345\271\263\346\226\271\346\240\271.md" (100%) diff --git "a/Dichotomy/\345\210\207\346\234\250\345\244\264.md" "b/\345\210\207\346\234\250\345\244\264.md" similarity index 100% rename from "Dichotomy/\345\210\207\346\234\250\345\244\264.md" rename to "\345\210\207\346\234\250\345\244\264.md" diff --git "a/Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" "b/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" similarity index 100% rename from "Dichotomy/\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" rename to "\345\260\217\344\272\216 N \347\232\204\346\234\200\345\244\247\346\225\260.md" diff --git "a/Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" "b/\346\261\202\345\271\263\346\226\271\346\240\271.md" similarity index 100% rename from "Dichotomy/\346\261\202\345\271\263\346\226\271\346\240\271.md" rename to "\346\261\202\345\271\263\346\226\271\346\240\271.md" From b73305fe18f797a3fc7f06910085fbc0d2e0e2b4 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 21 Sep 2024 20:00:57 +0800 Subject: [PATCH 361/373] Update changes --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 55ce364..58abafc 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,8 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-21 19:34 | [#124 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum) | HARD | 1 | 1 | +| 2024-09-21 15:54 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 2 | **2** | | 2024-09-13 19:45 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 4 | **3** | | 2024-09-06 11:31 | [#18 四数之和](https://leetcode.cn/problems/4sum) | MEDIUM | 5 | **2** | | 2024-09-05 09:08 | [#15 三数之和](https://leetcode.cn/problems/3sum) | MEDIUM | 8 | **4** | @@ -142,7 +144,6 @@ | 2024-01-24 11:25 | [#274 H 指数](https://leetcode.cn/problems/h-index) | MEDIUM | 3 | 1 | | 2024-01-23 22:15 | [#26 删除有序数组中的重复项](https://leetcode.cn/problems/remove-duplicates-from-sorted-array) | EASY | 2 | 1 | | 2024-01-23 22:05 | [#80 删除有序数组中的重复项 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii) | MEDIUM | 1 | 1 | -| 2024-01-23 16:34 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 1 | 1 | | 2024-01-22 11:10 | [#670 最大交换](https://leetcode.cn/problems/maximum-swap) | MEDIUM | 13 | **2** | | 2024-01-20 15:18 | [#82 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii) | MEDIUM | 3 | **2** | | 2024-01-20 13:17 | [#373 查找和最小的 K 对数字](https://leetcode.cn/problems/find-k-pairs-with-smallest-sums) | MEDIUM | 3 | **2** | From b5fc22b00efc5b06158f162b788f3fe3419652af Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 23 Sep 2024 10:40:18 +0800 Subject: [PATCH 362/373] =?UTF-8?q?Create=20=E4=B8=AD=E6=96=87=E6=95=B0?= =?UTF-8?q?=E5=AD=97=E8=BD=AC=E9=98=BF=E6=8B=89=E4=BC=AF=E6=95=B0=E5=AD=97?= =?UTF-8?q?.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...11\344\274\257\346\225\260\345\255\227.md" | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 "\344\270\255\346\226\207\346\225\260\345\255\227\350\275\254\351\230\277\346\213\211\344\274\257\346\225\260\345\255\227.md" diff --git "a/\344\270\255\346\226\207\346\225\260\345\255\227\350\275\254\351\230\277\346\213\211\344\274\257\346\225\260\345\255\227.md" "b/\344\270\255\346\226\207\346\225\260\345\255\227\350\275\254\351\230\277\346\213\211\344\274\257\346\225\260\345\255\227.md" new file mode 100644 index 0000000..c20a98d --- /dev/null +++ "b/\344\270\255\346\226\207\346\225\260\345\255\227\350\275\254\351\230\277\346\213\211\344\274\257\346\225\260\345\255\227.md" @@ -0,0 +1,45 @@ +# 中文数字转阿拉伯数字 + + + +字符串处理问题，需要考虑 `万亿`， `十万` 等情况。 + +```go +package main + +import "fmt" + +func main() { + fmt.Println(solution("二百")) +} + +func solution(chineseNum string) int { + res, part, temp := 0, 0, 0 + numberDict := map[string]int{"零": 0, "一": 1, "二": 2, "三": 3, "四": 4, "五": 5, "六": 6, "七": 7, "八": 8, "九": 9} + unitDict := map[string]int{"十": 10, "百": 100, "千": 1000} + largeUnitDict := map[string]int{"万": 10000} // “十万” + largerUnitDict := map[string]int{"亿": 100000000} // “万亿” + for _, ch := range chineseNum { + if val, ok := numberDict[string(ch)]; ok { + temp = val + } else if val, ok := unitDict[string(ch)]; ok { + part += temp * val + temp = 0 + } else if val, ok := largeUnitDict[string(ch)]; ok { + part += temp + temp = 0 + part *= val + } else if val, ok := largerUnitDict[string(ch)]; ok { + part += temp + temp = 0 + part *= val + res += part // 亿之前的数直接加到 res 里 + part = 0 + } + + } + res += part + temp + return res +} +``` + From b23d8d7e4dbbb2bba06ed241dea6de6da13aab62 Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 23 Sep 2024 13:07:31 +0800 Subject: [PATCH 363/373] move --- Multi-Thread/goroutine.md => goroutine.md | 0 "Heap/\345\240\206.md" => "\345\240\206.md" | 0 ...\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" | 0 ...1\345\240\206.md" => "\346\211\213\345\206\231\345\240\206.md" | 0 ...rn.md => "\350\256\276\350\256\241\346\250\241\345\274\217.md" | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename Multi-Thread/goroutine.md => goroutine.md (100%) rename "Heap/\345\240\206.md" => "\345\240\206.md" (100%) rename "Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" => "\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" (100%) rename "Heap/\346\211\213\345\206\231\345\240\206.md" => "\346\211\213\345\206\231\345\240\206.md" (100%) rename Software Design Pattern.md => "\350\256\276\350\256\241\346\250\241\345\274\217.md" (100%) diff --git a/Multi-Thread/goroutine.md b/goroutine.md similarity index 100% rename from Multi-Thread/goroutine.md rename to goroutine.md diff --git "a/Heap/\345\240\206.md" "b/\345\240\206.md" similarity index 100% rename from "Heap/\345\240\206.md" rename to "\345\240\206.md" diff --git "a/Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" "b/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" similarity index 100% rename from "Union-Find/\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" rename to "\345\271\266\346\237\245\351\233\206\357\274\210Union-Find\357\274\211.md" diff --git "a/Heap/\346\211\213\345\206\231\345\240\206.md" "b/\346\211\213\345\206\231\345\240\206.md" similarity index 100% rename from "Heap/\346\211\213\345\206\231\345\240\206.md" rename to "\346\211\213\345\206\231\345\240\206.md" diff --git a/Software Design Pattern.md "b/\350\256\276\350\256\241\346\250\241\345\274\217.md" similarity index 100% rename from Software Design Pattern.md rename to "\350\256\276\350\256\241\346\250\241\345\274\217.md" From f4a1937f86379da3b9cde7f59f7e2fb6390c83cd Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 23 Sep 2024 13:08:22 +0800 Subject: [PATCH 364/373] =?UTF-8?q?Update=20=E8=AE=BE=E8=AE=A1=E6=A8=A1?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...76\350\256\241\346\250\241\345\274\217.md" | 33 ++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git "a/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/\350\256\276\350\256\241\346\250\241\345\274\217.md" index 97d4ec0..1196bfe 100644 --- "a/\350\256\276\350\256\241\346\250\241\345\274\217.md" +++ "b/\350\256\276\350\256\241\346\250\241\345\274\217.md" @@ -1,6 +1,8 @@ # 设计模式 -1. 责任链模式 + + +## 责任链模式 ```go package main @@ -49,3 +51,32 @@ func main() { ``` + + + + +## 单例模式 + +```go +package main + +import "sync" + +type people struct { +} + +var instance *people +var once sync.Once + +func getInstance() *people { + once.Do(func() { + instance = &people{} + }) + return instance +} + +func main() { + +} +``` + From de1b08d1f99489b0844541025d30654f0229d750 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Mon, 23 Sep 2024 20:33:37 +0800 Subject: [PATCH 365/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 58abafc..d67467e 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-23 13:50 | [#1002 查找共用字符](https://leetcode.cn/problems/find-common-characters) | EASY | 1 | 1 | | 2024-09-21 19:34 | [#124 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum) | HARD | 1 | 1 | | 2024-09-21 15:54 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 2 | **2** | | 2024-09-13 19:45 | [#236 二叉树的最近公共祖先](https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree) | MEDIUM | 4 | **3** | From 79ea466d56d63002f0b7ec5d68954caef189d42b Mon Sep 17 00:00:00 2001 From: linze Date: Thu, 26 Sep 2024 15:47:24 +0800 Subject: [PATCH 366/373] =?UTF-8?q?Create=2076.=20=E6=9C=80=E5=B0=8F?= =?UTF-8?q?=E8=A6=86=E7=9B=96=E5=AD=90=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...06\347\233\226\345\255\220\344\270\262.md" | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 "Sliding Window/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" diff --git "a/Sliding Window/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" "b/Sliding Window/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" new file mode 100644 index 0000000..abf3238 --- /dev/null +++ "b/Sliding Window/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" @@ -0,0 +1,88 @@ +#### 76. 最小覆盖子串 + +难度：困难 + +--- + +给你一个字符串 `s` 、一个字符串 `t` 。返回 `s` 中涵盖 `t` 所有字符的最小子串。如果 `s` 中不存在涵盖 `t` 所有字符的子串，则返回空字符串 `""` 。 + + **注意：** + +* 对于 `t` 中重复字符，我们寻找的子字符串中该字符数量必须不少于 `t` 中该字符数量。 +* 如果 `s` 中存在这样的子串，我们保证它是唯一的答案。 + + **示例 1：** + +``` +输入：s = "ADOBECODEBANC", t = "ABC" +输出："BANC" +解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。 +``` + + **示例 2：** + +``` +输入：s = "a", t = "a" +输出："a" +解释：整个字符串 s 是最小覆盖子串。 +``` + + **示例 3:** + +``` +输入: s = "a", t = "aa" +输出: "" +解释: t 中两个字符 'a' 均应包含在 s 的子串中， +因此没有符合条件的子字符串，返回空字符串。 +``` + + **提示：** + +* `^m == s.length` +* `^n == t.length` +* `1 <= m, n <= 10^5` +* `s` 和 `t` 由英文字母组成 + + **进阶：** 你能设计一个在 `o(m+n)` 时间内解决此问题的算法吗？ + +--- + +滑动窗口： + +每次循环移动右移一次右指针，移动的过程中根据字符是否完全覆盖的情况循环右移左指针。第二个循环的过程中记录窗口长度是否为最小值。 + +```Go +func minWindow(s string, t string) string { + alphabet, count := map[byte]int{}, map[byte]int{} + for i := range t { + alphabet[t[i]]++ + } + ansLeft, ansRight := -1, -1 + ansLen := math.MaxInt32 + for left, right := 0, 0; right < len(s); right++ { + count[s[right]]++ + for check(alphabet, count) && left <= right { + if right - left + 1 < ansLen { + ansLen = right - left + 1 + ansLeft = left + ansRight = right + 1 + } + count[s[left]]-- + left++ + } + } + if ansLeft == -1 { + return "" + } + return s[ansLeft:ansRight] +} + +func check(alphabet, count map[byte]int) bool { + for k, v := range alphabet { + if count[k] < v { + return false + } + } + return true +} +``` \ No newline at end of file From d7f9b120e76822cce7b2e22a781f27e907521ca0 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Thu, 26 Sep 2024 15:50:19 +0800 Subject: [PATCH 367/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index d67467e..484e9ed 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-09-26 15:39 | [#76 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring) | HARD | 1 | 1 | | 2024-09-23 13:50 | [#1002 查找共用字符](https://leetcode.cn/problems/find-common-characters) | EASY | 1 | 1 | | 2024-09-21 19:34 | [#124 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum) | HARD | 1 | 1 | | 2024-09-21 15:54 | [#25 K 个一组翻转链表](https://leetcode.cn/problems/reverse-nodes-in-k-group) | HARD | 2 | **2** | From 0749f83afe12faf257b33880568296f32d706c4f Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Tue, 8 Oct 2024 20:32:07 +0800 Subject: [PATCH 368/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 484e9ed..2af3ae8 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-10-08 12:53 | [#463 岛屿的周长](https://leetcode.cn/problems/island-perimeter) | EASY | 1 | 1 | | 2024-09-26 15:39 | [#76 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring) | HARD | 1 | 1 | | 2024-09-23 13:50 | [#1002 查找共用字符](https://leetcode.cn/problems/find-common-characters) | EASY | 1 | 1 | | 2024-09-21 19:34 | [#124 二叉树中的最大路径和](https://leetcode.cn/problems/binary-tree-maximum-path-sum) | HARD | 1 | 1 | From b4db7e49b7167866e86b5c1a33ecaeb513d78075 Mon Sep 17 00:00:00 2001 From: linze Date: Sat, 12 Oct 2024 11:07:34 +0800 Subject: [PATCH 369/373] =?UTF-8?q?Create=20131.=20=E5=88=86=E5=89=B2?= =?UTF-8?q?=E5=9B=9E=E6=96=87=E4=B8=B2.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...62\345\233\236\346\226\207\344\270\262.md" | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 "Depth First Search/131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" diff --git "a/Depth First Search/131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" "b/Depth First Search/131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" new file mode 100644 index 0000000..026e05f --- /dev/null +++ "b/Depth First Search/131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" @@ -0,0 +1,68 @@ +#### 131. 分割回文串 + +难度：中等 + +--- + +给你一个字符串 `s`，请你将 `s` 分割成一些子串，使每个子串都是 + + **回文串** + +。返回 `s` 所有可能的分割方案。 + + **示例 1：** + +``` +输入：s = "aab" +输出：[["a","a","b"],["aa","b"]] +``` + + **示例 2：** + +``` +输入：s = "a" +输出：[["a"]] +``` + + **提示：** + +* `1 <= s.length <= 16` +* `s` 仅由小写英文字母组成 + +--- + +回溯： + +```Go +func partition(s string) (ans [][]string) { + n := len(s) + path := []string{} + var dfs func(int) + dfs = func(i int) { + if i == n { + ans = append(ans, append([]string(nil), path...)) + return + } + for j := i; j < n; j++ { // 枚举子串的结束位置 + if isPalindrome(s, i, j) { + path = append(path, s[i : j + 1]) + dfs(j + 1) + path = path[:len(path) - 1] + } + } + } + dfs(0) + return +} + +func isPalindrome(s string, left, right int) bool { + for left < right { + if s[left] != s[right] { + return false + } + left++ + right-- + } + return true +} +``` \ No newline at end of file From 36a3c40357e00b0c6f59873f11a0ae4e3657fc20 Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 12 Oct 2024 11:10:28 +0800 Subject: [PATCH 370/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 2af3ae8..93ddfba 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-10-12 10:34 | [#131 分割回文串](https://leetcode.cn/problems/palindrome-partitioning) | MEDIUM | 3 | 1 | | 2024-10-08 12:53 | [#463 岛屿的周长](https://leetcode.cn/problems/island-perimeter) | EASY | 1 | 1 | | 2024-09-26 15:39 | [#76 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring) | HARD | 1 | 1 | | 2024-09-23 13:50 | [#1002 查找共用字符](https://leetcode.cn/problems/find-common-characters) | EASY | 1 | 1 | From aadd3cce8acf5627a1b26a84bc0c749f29ee1116 Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 14 Oct 2024 09:12:32 +0800 Subject: [PATCH 371/373] =?UTF-8?q?Update=20=E8=AE=BE=E8=AE=A1=E6=A8=A1?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...76\350\256\241\346\250\241\345\274\217.md" | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git "a/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/\350\256\276\350\256\241\346\250\241\345\274\217.md" index 1196bfe..5c68deb 100644 --- "a/\350\256\276\350\256\241\346\250\241\345\274\217.md" +++ "b/\350\256\276\350\256\241\346\250\241\345\274\217.md" @@ -80,3 +80,43 @@ func main() { } ``` + + +```java +public class DoubleCheckedLock { + + // 使用volatile修饰禁止重排序 + private volatile static DoubleCheckedLock instance; + + private DoubleCheckedLock() { + //构造器必须私有 不然直接new就可以创建 + } + + + public static DoubleCheckedLock getInstance() { + //第一次判断，假设会有好多线程，如果doubleLock没有被实例化，那么就会到下一步获取锁，只有一个能获取到， + //如果已经实例化，那么直接返回了，减少除了初始化时之外的所有锁获取等待过程 + if (instance == null) { + //同步 + synchronized (DoubleCheckedLock.class) { + //第二次判断是因为假设有两个线程A、B,两个同时通过了第一个if，然后A获取了锁，进入然后判断doubleLock是null， + // 他就实例化了doubleLock，然后他出了锁，这时候线程B经过等待A释放的锁，B获取锁了， + // 如果没有第二个判断，那么他还是会去new DoubleLock()，再创建一个实例，所以为了防止这种情况，需要第二次判断 + if (instance == null) { + //下面这句代码其实分为三步： + //1.开辟内存分配给这个对象 + //2.初始化对象 + //3.将内存地址赋给虚拟机栈内存中的doubleLock变量 + //注意上面这三步，第2步和第3步的顺序是随机的，这是计算机指令重排序的问题 + //假设有两个线程，其中一个线程执行下面这行代码，如果第三步先执行了，就会把没有初始化的内存赋值给doubleLock + //然后恰好这时候有另一个线程执行了第一个判断if(doubleLock == null)，然后就会发现doubleLock指向了一个内存地址 + //这另一个线程就直接返回了这个没有初始化的内存，所以要防止第2步和第3步重排序 + instance = new DoubleCheckedLock(); + } + } + } + return instance; + } +} +``` + From 33ae7fd916f9db2ab4f6f86154222e46f343cfec Mon Sep 17 00:00:00 2001 From: linze Date: Mon, 14 Oct 2024 09:12:35 +0800 Subject: [PATCH 372/373] =?UTF-8?q?Create=20=E5=A4=9A=E7=BA=BF=E7=A8=8B.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "\345\244\232\347\272\277\347\250\213.md" | 116 ++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 "\345\244\232\347\272\277\347\250\213.md" diff --git "a/\345\244\232\347\272\277\347\250\213.md" "b/\345\244\232\347\272\277\347\250\213.md" new file mode 100644 index 0000000..0137fdd --- /dev/null +++ "b/\345\244\232\347\272\277\347\250\213.md" @@ -0,0 +1,116 @@ +# Java + +两个交替打印数字 + +```java +package src.MultiThreading.AlternatePrint; + + +public class AP1 { + + private static int num = 0; + + public static void main(String[] args) { + Object lock = new Object(); + Thread thread1 = new Thread(() -> { + while(true){ + synchronized (lock){ + lock.notify(); + System.out.println("THREAD1 " + num++); + try { + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + } + }); + Thread thread2 = new Thread(() -> { + while(true){ + synchronized (lock){ + lock.notify(); + System.out.println("THREAD2 " + num++); + try { + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + } + }); + thread1.start(); + thread2.start(); + } +} +``` + +三个线程交替打印 + +```java +package src.MultiThreading.AlternatePrint; + +class ThreeThreadAP2 { + + + private static int num = 0; + + private static Object lock = new Object(); + + + public static void main(String[] args) { + + new Thread(() -> { + while(true){ + synchronized (lock){ + if(num % 3 == 0){ + lock.notifyAll(); + System.out.println("Thread1 " + num++); + try { + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + + } + } + }).start(); + new Thread(() -> { + while(true){ + synchronized (lock){ + if(num % 3 == 1){ + lock.notifyAll(); + System.out.println("Thread2 " + num++); + try { + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + } + } + }).start(); + new Thread(() -> { + while(true){ + synchronized (lock){ + if(num % 3 == 2){ + lock.notifyAll(); + System.out.println("Thread3 " + num++); + try { + Thread.sleep(1000); + lock.wait(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + } + } + }).start(); + } +} +``` + From afa0d202590192ecb3e7812f0511d5d50bedee9c Mon Sep 17 00:00:00 2001 From: CompetitiveLin Date: Sat, 19 Oct 2024 20:32:13 +0800 Subject: [PATCH 373/373] Update changes --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 93ddfba..da01bbd 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,7 @@ | 最近提交时间 | 题目 | 题目难度 | 提交次数| 重刷次数 | | ---- | ---- | ---- | ---- | ---- | +| 2024-10-19 20:18 | [#2165 重排数字的最小值](https://leetcode.cn/problems/smallest-value-of-the-rearranged-number) | MEDIUM | 1 | 1 | | 2024-10-12 10:34 | [#131 分割回文串](https://leetcode.cn/problems/palindrome-partitioning) | MEDIUM | 3 | 1 | | 2024-10-08 12:53 | [#463 岛屿的周长](https://leetcode.cn/problems/island-perimeter) | EASY | 1 | 1 | | 2024-09-26 15:39 | [#76 最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring) | HARD | 1 | 1 |