给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。
两个网格块属于同一 连通分量 需满足下述全部条件：
+如果两个方块在任意 4 个方向上相邻，则称它们 相邻 。
-如果两个方块具有相同的颜色且相邻，它们则属于同一个 连通分量 。
连通分量的边界 是指连通分量中满足下述条件之一的所有网格块：
@@ -24,23 +21,25 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 数组,请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色，并返回最终的网格 grid 。
请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色。
并返回最终的网格 grid 。
-
示例 1：
+示例 1：
输入：grid = [[1,1],[1,2]], row = 0, col = 0, color = 3 输出：[[3,3],[3,2]]-
示例 2：
+示例 2：
输入：grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3 输出：[[1,3,3],[2,3,3]]-
示例 3：
+示例 3：
输入：grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2 @@ -59,7 +58,5 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 数组,
0 <= col < n- \ No newline at end of file diff --git "a/AllProblems/104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md" "b/AllProblems/104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md" index 1dc8c01981b..da0c3deb282 100644 --- "a/AllProblems/104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md" +++ "b/AllProblems/104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md" @@ -8,22 +8,38 @@ tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 广度优先搜索, 力扣题目链接：[https://leetcode.cn/problems/maximum-depth-of-binary-tree/](https://leetcode.cn/problems/maximum-depth-of-binary-tree/) -
给定一个二叉树，找出其最大深度。
+给定一个二叉树 root ，返回其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
-说明: 叶子节点是指没有子节点的节点。
+-
示例：
-给定二叉树 [3,9,20,null,null,15,7]，
示例 1：
-3 - / \ - 9 20 - / \ - 15 7+
返回它的最大深度 3 。
++ +
+输入：root = [3,9,20,null,null,15,7] +输出：3 ++ +
示例 2：
+ ++输入：root = [1,null,2] +输出：2 ++ +
+ +
提示：
+ +[0, 104] 区间内。-100 <= Node.val <= 100Customer 表：
+-------------+---------+ +++-------------+---------+ | Column Name | Type | +-------------+---------+ | customer_id | int | | product_key | int | +-------------+---------+ -product_key 是Customer 表的外键。 +该表可能包含重复的行。 +customer_id 不为 NULL。 +product_key 是 Product 表的外键(reference 列)。-
Product表：+-------------+---------+ +++-------------+---------+ | Column Name | Type | +-------------+---------+ | product_key | int | +-------------+---------+ -product_key 是这张表的主键。 +product_key 是这张表的主键（具有唯一值的列）。-
写一条 SQL 查询语句，从
+Customer表中查询购买了Product表中所有产品的客户的 id。编写解决方案，报告
+ +Customer表中购买了Product表中所有产品的客户的 id。返回结果表 无顺序要求 。
+ +返回结果格式如下所示。
-示例：
++ +
示例 1：
-Customer 表： ++输入： +Customer 表： +-------------+-------------+ | customer_id | product_key | +-------------+-------------+ @@ -45,7 +57,6 @@ product_key 是这张表的主键。 | 3 | 6 | | 1 | 6 | +-------------+-------------+ - Product 表： +-------------+ | product_key | @@ -53,14 +64,14 @@ Product 表： | 5 | | 6 | +-------------+ - -Result 表： +输出： +-------------+ | customer_id | +-------------+ | 1 | | 3 | +-------------+ +解释： 购买了所有产品（5 和 6）的客户的 id 是 1 和 3 。diff --git "a/AllProblems/1050.\345\220\210\344\275\234\350\277\207\350\207\263\345\260\221\344\270\211\346\254\241\347\232\204\346\274\224\345\221\230\345\222\214\345\257\274\346\274\224.md" "b/AllProblems/1050.\345\220\210\344\275\234\350\277\207\350\207\263\345\260\221\344\270\211\346\254\241\347\232\204\346\274\224\345\221\230\345\222\214\345\257\274\346\274\224.md" index 05ee13dc2c7..5e5e443c21e 100644 --- "a/AllProblems/1050.\345\220\210\344\275\234\350\277\207\350\207\263\345\260\221\344\270\211\346\254\241\347\232\204\346\274\224\345\221\230\345\222\214\345\257\274\346\274\224.md" +++ "b/AllProblems/1050.\345\220\210\344\275\234\350\277\207\350\207\263\345\260\221\344\270\211\346\254\241\347\232\204\346\274\224\345\221\230\345\222\214\345\257\274\346\274\224.md" @@ -18,16 +18,19 @@ tags: [题解, LeetCode, 简单, 数据库] | director_id | int | | timestamp | int | +-------------+---------+ -timestamp 是这张表的主键. +timestamp 是这张表的主键(具有唯一值的列).-
写一条SQL查询语句获取合作过至少三次的演员和导演的 id 对
+(actor_id, director_id)编写解决方案找出合作过至少三次的演员和导演的 id 对
-(actor_id, director_id)示例：
++ +
示例 1：
+输入： ActorDirector 表： +-------------+-------------+-------------+ | actor_id | director_id | timestamp | @@ -40,13 +43,13 @@ ActorDirector 表： | 2 | 1 | 5 | | 2 | 1 | 6 | +-------------+-------------+-------------+ - -Result 表： +输出： +-------------+-------------+ | actor_id | director_id | +-------------+-------------+ | 1 | 1 | +-------------+-------------+ +解释： 唯一的 id 对是 (1, 1)，他们恰好合作了 3 次。diff --git "a/AllProblems/1068.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 I.md" "b/AllProblems/1068.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 I.md" index d65a927c1b7..049efa1b9df 100644 --- "a/AllProblems/1068.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 I.md" +++ "b/AllProblems/1068.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 I.md" @@ -20,9 +20,10 @@ tags: [题解, LeetCode, 简单, 数据库] | quantity | int | | price | int | +-------------+-------+ -(sale_id, year) 是销售表 Sales 的主键. -product_id 是关联到产品表 Product 的外键. -注意: price 表示每单位价格 +(sale_id, year) 是销售表 Sales 的主键（具有唯一值的列的组合）。 +product_id 是关联到产品表 Product 的外键（reference 列）。 +该表的每一行显示 product_id 在某一年的销售情况。 +注意: price 表示每单位价格。产品表
@@ -34,21 +35,25 @@ product_id 是关联到产品表 Product 的外键. | product_id | int | | product_name | varchar | +--------------+---------+ -product_id 是表的主键. +product_id 是表的主键（具有唯一值的列）。 +该表的每一行表示每种产品的产品名称。Product：
-
写一条SQL 查询语句获取 Sales 表中所有产品对应的 产品名称 product_name 以及该产品的所有 售卖年份 year 和 价格 price 。
编写解决方案，以获取 Sales 表中所有 sale_id 对应的 product_name 以及该产品的所有 year 和 price 。
查询结果中的顺序无特定要求。
+返回结果表 无顺序要求 。
-查询结果格式示例如下：
+结果格式示例如下。
+
示例 1：
+-@@ -37,16 +37,16 @@ product_id 是产品表的外键。 | product_id | int | | product_name | varchar | +--------------+---------+ -product_id 是这张表的主键。 +product_id 是这张表的主键（具有唯一值的列）。 这张表的每一行都标识：每个产品的 id 和 产品名称。Sales表： +输入： +Sales表： +---------+------------+------+----------+-------+ | sale_id | product_id | year | quantity | price | +---------+------------+------+----------+-------+ @@ -56,7 +61,6 @@ product_id 是表的主键. | 2 | 100 | 2009 | 12 | 5000 | | 7 | 200 | 2011 | 15 | 9000 | +---------+------------+------+----------+-------+ - Product 表： +------------+--------------+ | product_id | product_name | @@ -65,8 +69,7 @@ Product 表： | 200 | Apple | | 300 | Samsung | +------------+--------------+ - -Result 表： +输出： +--------------+-------+-------+ | product_name | year | price | +--------------+-------+-------+ diff --git "a/AllProblems/1070.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 III.md" "b/AllProblems/1070.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 III.md" index 1d861a4159c..52daed4cfed 100644 --- "a/AllProblems/1070.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 III.md" +++ "b/AllProblems/1070.\344\272\247\345\223\201\351\224\200\345\224\256\345\210\206\346\236\220 III.md" @@ -20,8 +20,8 @@ tags: [题解, LeetCode, 中等, 数据库] | quantity | int | | price | int | +-------------+-------+ -(sale_id, year) 是这张表的主键。 -product_id 是产品表的外键。 +(sale_id, year) 是这张表的主键（具有唯一值的列的组合）。 +product_id 是产品表的外键（reference 列）。 这张表的每一行都表示：编号 product_id 的产品在某一年的销售额。 请注意，价格是按每单位计的。
-
编写一个 SQL 查询，选出每个销售产品 第一年 销售的 产品 id、年份、数量 和 价格。
+编写解决方案，选出每个售出过的产品 第一年 销售的 产品 id、年份、数量 和 价格。
结果表中的条目可以按 任意顺序 排列。
-查询结果格式如下例所示：
+结果格式如下例所示：
diff --git "a/AllProblems/1081.\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\345\260\217\345\255\220\345\272\217\345\210\227.md" "b/AllProblems/1081.\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\345\260\217\345\255\220\345\272\217\345\210\227.md" index c4224555fb6..22b8df6d0f3 100644 --- "a/AllProblems/1081.\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\345\260\217\345\255\220\345\272\217\345\210\227.md" +++ "b/AllProblems/1081.\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\345\260\217\345\255\220\345\272\217\345\210\227.md" @@ -10,9 +10,7 @@ tags: [题解, LeetCode, 中等, 栈, 贪心, 字符串, 单调栈]
返回 s 字典序最小的子序列，该子序列包含 s 的所有不同字符，且只包含一次。
注意：该题与 316 https://leetcode.com/problems/remove-duplicate-letters/ 相同
- -+
示例 1：
@@ -27,14 +25,18 @@ tags: [题解, LeetCode, 中等, 栈, 贪心, 字符串, 单调栈] 输入：s = "cbacdcbc"
输出："acdb"
-+
提示：
1 <= s.length <= 10001 <= s.length <= 1000s 由小写英文字母组成+ +
注意：该题与 316 https://leetcode.cn/problems/remove-duplicate-letters/ 相同
+ \ No newline at end of file diff --git "a/AllProblems/1084.\351\224\200\345\224\256\345\210\206\346\236\220III.md" "b/AllProblems/1084.\351\224\200\345\224\256\345\210\206\346\236\220III.md" index 67008a6e222..68410cc0bf3 100644 --- "a/AllProblems/1084.\351\224\200\345\224\256\345\210\206\346\236\220III.md" +++ "b/AllProblems/1084.\351\224\200\345\224\256\345\210\206\346\236\220III.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/sales-analysis-iii/](https://leetcode.cn/problems/sales-analysis-iii/) -Table: Product
表： Product
+--------------+---------+ @@ -18,11 +18,11 @@ tags: [题解, LeetCode, 简单, 数据库] | product_name | varchar | | unit_price | int | +--------------+---------+ -Product_id是该表的主键。 +product_id 是该表的主键（具有唯一值的列）。 该表的每一行显示每个产品的名称和价格。-
Table: Sales
表：Sales
+-------------+---------+ @@ -35,18 +35,18 @@ Product_id是该表的主键。 | quantity | int | | price | int | +------ ------+---------+ -这个表没有主键，它可以有重复的行。 -product_id 是 Product 表的外键。 +这个表可能有重复的行。 +product_id 是 Product 表的外键（reference 列）。 该表的每一行包含关于一个销售的一些信息。
-
编写一个SQL查询，报告2019年春季才售出的产品。即仅在2019-01-01至2019-03-31（含）之间出售的商品。
编写解决方案，报告2019年春季才售出的产品。即仅在2019-01-01至2019-03-31（含）之间出售的商品。
以 任意顺序 返回结果表。
-查询结果格式如下所示。
+结果格式如下所示。
diff --git "a/AllProblems/1140.\347\237\263\345\255\220\346\270\270\346\210\217 II.md" "b/AllProblems/1140.\347\237\263\345\255\220\346\270\270\346\210\217 II.md" index 361d8e40ad5..a9e10635e6d 100644 --- "a/AllProblems/1140.\347\237\263\345\255\220\346\270\270\346\210\217 II.md" +++ "b/AllProblems/1140.\347\237\263\345\255\220\346\270\270\346\210\217 II.md" @@ -1,7 +1,7 @@ --- title: 1140.石子游戏 II date: 2022-06-02 20-03-47 -tags: [题解, LeetCode, 中等, 数组, 数学, 动态规划, 博弈] +tags: [题解, LeetCode, 中等, 数组, 数学, 动态规划, 博弈, 前缀和] --- # 【LetMeFly】1140.石子游戏 II diff --git "a/AllProblems/1141.\346\237\245\350\257\242\350\277\22130\345\244\251\346\264\273\350\267\203\347\224\250\346\210\267\346\225\260.md" "b/AllProblems/1141.\346\237\245\350\257\242\350\277\22130\345\244\251\346\264\273\350\267\203\347\224\250\346\210\267\346\225\260.md" index 743b9de1173..6cbc49fa965 100644 --- "a/AllProblems/1141.\346\237\245\350\257\242\350\277\22130\345\244\251\346\264\273\350\267\203\347\224\250\346\210\267\346\225\260.md" +++ "b/AllProblems/1141.\346\237\245\350\257\242\350\277\22130\345\244\251\346\264\273\350\267\203\347\224\250\346\210\267\346\225\260.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/user-activity-for-the-past-30-days-i/](https://leetcode.cn/problems/user-activity-for-the-past-30-days-i/) -
活动记录表：Activity
表：Activity
+---------------+---------+
@@ -19,19 +19,19 @@ tags: [题解, LeetCode, 简单, 数据库]
| activity_date | date |
| activity_type | enum |
+---------------+---------+
-该表是用户在社交网站的活动记录。
-该表没有主键，可能包含重复数据。
-activity_type 字段为以下四种值 ('open_session', 'end_session', 'scroll_down', 'send_message')。
-每个 session_id 只属于一个用户。
+该表没有包含重复数据。
+activity_type 列是 ENUM(category) 类型， 从 ('open_session'， 'end_session'， 'scroll_down'， 'send_message') 取值。
+该表记录社交媒体网站的用户活动。
+注意，每个会话只属于一个用户。
-
请写SQL查询出截至 2019-07-27（包含2019-07-27），近 30 天的每日活跃用户数（当天只要有一条活动记录，即为活跃用户）。
编写解决方案，统计截至 2019-07-27（包含2019-07-27），近 30 天的每日活跃用户数（当天只要有一条活动记录，即为活跃用户）。
以 任意顺序 返回结果表。
-查询结果示例如下。
+结果示例如下。
diff --git "a/AllProblems/1147.\346\256\265\345\274\217\345\233\236\346\226\207.md" "b/AllProblems/1147.\346\256\265\345\274\217\345\233\236\346\226\207.md" index bbef62c8a73..fec2b17c0ce 100644 --- "a/AllProblems/1147.\346\256\265\345\274\217\345\233\236\346\226\207.md" +++ "b/AllProblems/1147.\346\256\265\345\274\217\345\233\236\346\226\207.md" @@ -41,7 +41,7 @@ tags: [题解, LeetCode, 困难, 贪心, 双指针, 字符串, 动态规划, 哈
输入：text = "antaprezatepzapreanta" 输出：11 -解释：我们可以把字符串拆分成 "(a)(nt)(a)(pre)(za)(tpe)(za)(pre)(a)(nt)(a)"。 +解释：我们可以把字符串拆分成 "(a)(nt)(a)(pre)(za)(tep)(za)(pre)(a)(nt)(a)"。
diff --git "a/AllProblems/1148.\346\226\207\347\253\240\346\265\217\350\247\210 I.md" "b/AllProblems/1148.\346\226\207\347\253\240\346\265\217\350\247\210 I.md" index 8bab3f5738c..681a7cf3989 100644 --- "a/AllProblems/1148.\346\226\207\347\253\240\346\265\217\350\247\210 I.md" +++ "b/AllProblems/1148.\346\226\207\347\253\240\346\265\217\350\247\210 I.md" @@ -19,18 +19,25 @@ tags: [题解, LeetCode, 简单, 数据库] | viewer_id | int | | view_date | date | +---------------+---------+ -此表无主键，因此可能会存在重复行。 +此表可能会存在重复行。（换句话说，在 SQL 中这个表没有主键） 此表的每一行都表示某人在某天浏览了某位作者的某篇文章。 请注意，同一人的 author_id 和 viewer_id 是相同的。
-
请编写一条 SQL 查询以找出所有浏览过自己文章的作者，结果按照 id 升序排列。
+请查询出所有浏览过自己文章的作者
+ +结果按照 id 升序排列。
查询结果的格式如下所示：
++ +
示例 1：
++输入： Views 表： +------------+-----------+-----------+------------+ | article_id | author_id | viewer_id | view_date | @@ -44,7 +51,7 @@ Views 表： | 3 | 4 | 4 | 2019-07-21 | +------------+-----------+-----------+------------+ -结果表： +输出： +------+ | id | +------+ diff --git "a/AllProblems/115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" "b/AllProblems/115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" index ccc4f9d14c8..1d2d7463868 100644 --- "a/AllProblems/115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" +++ "b/AllProblems/115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" @@ -8,9 +8,7 @@ tags: [题解, LeetCode, 困难, 字符串, 动态规划] 力扣题目链接：[https://leetcode.cn/problems/distinct-subsequences/](https://leetcode.cn/problems/distinct-subsequences/) -给你两个字符串
- -s和t，统计并返回在s的 子序列 中t出现的个数。题目数据保证答案符合 32 位带符号整数范围。
+给你两个字符串
s和t，统计并返回在s的 子序列 中t出现的个数，结果需要对 109 + 7 取模。diff --git "a/AllProblems/1155.\346\216\267\351\252\260\345\255\220\347\255\211\344\272\216\347\233\256\346\240\207\345\222\214\347\232\204\346\226\271\346\263\225\346\225\260.md" "b/AllProblems/1155.\346\216\267\351\252\260\345\255\220\347\255\211\344\272\216\347\233\256\346\240\207\345\222\214\347\232\204\346\226\271\346\263\225\346\225\260.md" index 769ac10ca5c..bd73db5701e 100644 --- "a/AllProblems/1155.\346\216\267\351\252\260\345\255\220\347\255\211\344\272\216\347\233\256\346\240\207\345\222\214\347\232\204\346\226\271\346\263\225\346\225\260.md" +++ "b/AllProblems/1155.\346\216\267\351\252\260\345\255\220\347\255\211\344\272\216\347\233\256\346\240\207\345\222\214\347\232\204\346\226\271\346\263\225\346\225\260.md" @@ -21,8 +21,8 @@ tags: [题解, LeetCode, 中等, 动态规划]
输入：n = 1, k = 6, target = 3 输出：1 -解释：你扔一个有6张脸的骰子。 -得到3的和只有一种方法。 +解释：你扔一个有 6 个面的骰子。 +得到 3 的和只有一种方法。示例 2：
@@ -30,8 +30,8 @@ tags: [题解, LeetCode, 中等, 动态规划]输入：n = 2, k = 6, target = 7 输出：6 -解释：你扔两个骰子，每个骰子有6个面。 -得到7的和有6种方法1+6 2+5 3+4 4+3 5+2 6+1。 +解释：你扔两个骰子，每个骰子有 6 个面。 +得到 7 的和有 6 种方法：1+6 2+5 3+4 4+3 5+2 6+1。示例 3：
diff --git "a/AllProblems/1158.\345\270\202\345\234\272\345\210\206\346\236\220 I.md" "b/AllProblems/1158.\345\270\202\345\234\272\345\210\206\346\236\220 I.md" index 932152e0df1..9f33f664323 100644 --- "a/AllProblems/1158.\345\270\202\345\234\272\345\210\206\346\236\220 I.md" +++ "b/AllProblems/1158.\345\270\202\345\234\272\345\210\206\346\236\220 I.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 中等, 数据库] 力扣题目链接：[https://leetcode.cn/problems/market-analysis-i/](https://leetcode.cn/problems/market-analysis-i/) -Table:
+Users表：
Users+----------------+---------+ @@ -18,13 +18,13 @@ tags: [题解, LeetCode, 中等, 数据库] | join_date | date | | favorite_brand | varchar | +----------------+---------+ -此表主键是 user_id。 +user_id 是此表主键（具有唯一值的列）。 表中描述了购物网站的用户信息，用户可以在此网站上进行商品买卖。-
Table:
+Orders表：
Orders+---------------+---------+ @@ -36,13 +36,14 @@ tags: [题解, LeetCode, 中等, 数据库] | buyer_id | int | | seller_id | int | +---------------+---------+ -此表主键是 order_id。 -外键是 item_id 和（buyer_id，seller_id）。 +order_id 是此表主键（具有唯一值的列）。 +item_id 是 Items 表的外键（reference 列）。 +（buyer_id，seller_id）是 User 表的外键。-
Table:
+Items表：
Items+---------------+---------+ @@ -51,12 +52,12 @@ tags: [题解, LeetCode, 中等, 数据库] | item_id | int | | item_brand | varchar | +---------------+---------+ -此表主键是 item_id。 +item_id 是此表的主键（具有唯一值的列）。-
请写出一条SQL语句以查询每个用户的注册日期和在
+2019年作为买家的订单总数。编写解决方案找出每个用户的注册日期和在
2019年作为买家的订单总数。以 任意顺序 返回结果表。
diff --git "a/AllProblems/1164.\346\214\207\345\256\232\346\227\245\346\234\237\347\232\204\344\272\247\345\223\201\344\273\267\346\240\274.md" "b/AllProblems/1164.\346\214\207\345\256\232\346\227\245\346\234\237\347\232\204\344\272\247\345\223\201\344\273\267\346\240\274.md" index 8d36ad2bc05..0ce5f44eaa2 100644 --- "a/AllProblems/1164.\346\214\207\345\256\232\346\227\245\346\234\237\347\232\204\344\272\247\345\223\201\344\273\267\346\240\274.md" +++ "b/AllProblems/1164.\346\214\207\345\256\232\346\227\245\346\234\237\347\232\204\344\272\247\345\223\201\344\273\267\346\240\274.md" @@ -18,24 +18,24 @@ tags: [题解, LeetCode, 中等, 数据库] | new_price | int | | change_date | date | +---------------+---------+ -这张表的主键是 (product_id, change_date)。 +(product_id, change_date) 是此表的主键（具有唯一值的列组合）。 这张表的每一行分别记录了 某产品 在某个日期 更改后 的新价格。
-
写一段 SQL来查找在 2019-08-16 时全部产品的价格，假设所有产品在修改前的价格都是 10 。
编写一个解决方案，找出在 2019-08-16 时全部产品的价格，假设所有产品在修改前的价格都是 10 。
以 任意顺序 返回结果表。
-查询结果格式如下例所示。
+结果格式如下例所示。
示例 1:
-输入： -Products表: +输入： +Products 表: +------------+-----------+-------------+ | product_id | new_price | change_date | +------------+-----------+-------------+ diff --git "a/AllProblems/1174.\345\215\263\346\227\266\351\243\237\347\211\251\351\205\215\351\200\201 II.md" "b/AllProblems/1174.\345\215\263\346\227\266\351\243\237\347\211\251\351\205\215\351\200\201 II.md" index 426038a23b3..666953d617c 100644 --- "a/AllProblems/1174.\345\215\263\346\227\266\351\243\237\347\211\251\351\205\215\351\200\201 II.md" +++ "b/AllProblems/1174.\345\215\263\346\227\266\351\243\237\347\211\251\351\205\215\351\200\201 II.md" @@ -10,7 +10,8 @@ tags: [题解, LeetCode, 中等, 数据库]配送表:
-Delivery+-----------------------------+---------+ +++-----------------------------+---------+ | Column Name | Type | +-----------------------------+---------+ | delivery_id | int | @@ -18,23 +19,27 @@ tags: [题解, LeetCode, 中等, 数据库] | order_date | date | | customer_pref_delivery_date | date | +-----------------------------+---------+ -delivery_id 是表的主键。 +delivery_id 是该表中具有唯一值的列。 该表保存着顾客的食物配送信息，顾客在某个日期下了订单，并指定了一个期望的配送日期（和下单日期相同或者在那之后）。-
如果顾客期望的配送日期和下单日期相同，则该订单称为 「即时订单」，否则称为「计划订单」。
+如果顾客期望的配送日期和下单日期相同，则该订单称为 「即时订单」，否则称为「计划订单」。
+ +「首次订单」是顾客最早创建的订单。我们保证一个顾客只会有一个「首次订单」。
-「首次订单」是顾客最早创建的订单。我们保证一个顾客只会有一个「首次订单」。
+编写解决方案以获取即时订单在所有用户的首次订单中的比例。保留两位小数。
-写一条 SQL 查询语句获取即时订单在所有用户的首次订单中的比例。保留两位小数。
+结果示例如下所示：
-
查询结果如下所示：
+示例 1：
-Delivery 表： ++输入： +Delivery 表： +-------------+-------------+------------+-----------------------------+ | delivery_id | customer_id | order_date | customer_pref_delivery_date | +-------------+-------------+------------+-----------------------------+ @@ -46,13 +51,13 @@ delivery_id 是表的主键。 | 6 | 2 | 2019-08-11 | 2019-08-13 | | 7 | 4 | 2019-08-09 | 2019-08-09 | +-------------+-------------+------------+-----------------------------+ - -Result 表： +输出： +----------------------+ | immediate_percentage | +----------------------+ | 50.00 | +----------------------+ +解释： 1 号顾客的 1 号订单是首次订单，并且是计划订单。 2 号顾客的 2 号订单是首次订单，并且是即时订单。 3 号顾客的 5 号订单是首次订单，并且是计划订单。 diff --git "a/AllProblems/1177.\346\236\204\345\273\272\345\233\236\346\226\207\344\270\262\346\243\200\346\265\213.md" "b/AllProblems/1177.\346\236\204\345\273\272\345\233\236\346\226\207\344\270\262\346\243\200\346\265\213.md" index 01e27aad50b..6c6138b11ce 100644 --- "a/AllProblems/1177.\346\236\204\345\273\272\345\233\236\346\226\207\344\270\262\346\243\200\346\265\213.md" +++ "b/AllProblems/1177.\346\236\204\345\273\272\345\233\236\346\226\207\344\270\262\346\243\200\346\265\213.md" @@ -1,7 +1,7 @@ --- title: 1177.构建回文串检测 date: 2022-06-02 20-04-06 -tags: [题解, LeetCode, 中等, 位运算, 哈希表, 字符串, 前缀和] +tags: [题解, LeetCode, 中等, 位运算, 数组, 哈希表, 字符串, 前缀和] --- # 【LetMeFly】1177.构建回文串检测 diff --git "a/AllProblems/1179.\351\207\215\346\226\260\346\240\274\345\274\217\345\214\226\351\203\250\351\227\250\350\241\250.md" "b/AllProblems/1179.\351\207\215\346\226\260\346\240\274\345\274\217\345\214\226\351\203\250\351\227\250\350\241\250.md" index 3ec084caa0e..3006f904a79 100644 --- "a/AllProblems/1179.\351\207\215\346\226\260\346\240\274\345\274\217\345\214\226\351\203\250\351\227\250\350\241\250.md" +++ "b/AllProblems/1179.\351\207\215\346\226\260\346\240\274\345\274\217\345\214\226\351\203\250\351\227\250\350\241\250.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/reformat-department-table/](https://leetcode.cn/problems/reformat-department-table/) -\ No newline at end of file diff --git "a/AllProblems/1187.\344\275\277\346\225\260\347\273\204\344\270\245\346\240\274\351\200\222\345\242\236.md" "b/AllProblems/1187.\344\275\277\346\225\260\347\273\204\344\270\245\346\240\274\351\200\222\345\242\236.md" index cf2107bee65..1db50756ae9 100644 --- "a/AllProblems/1187.\344\275\277\346\225\260\347\273\204\344\270\245\346\240\274\351\200\222\345\242\236.md" +++ "b/AllProblems/1187.\344\275\277\346\225\260\347\273\204\344\270\245\346\240\274\351\200\222\345\242\236.md" @@ -16,23 +16,26 @@ tags: [题解, LeetCode, 困难, 数组, 二分查找, 动态规划, 排序]部门表
+Department：表
Department：+---------------+---------+ @@ -18,19 +18,26 @@ tags: [题解, LeetCode, 简单, 数据库] | revenue | int | | month | varchar | +---------------+---------+ -(id, month) 是表的联合主键。 +在 SQL 中，(id, month) 是表的联合主键。 这个表格有关于每个部门每月收入的信息。 -月份（month）可以取下列值 ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]。 +月份（month）可以取下列值 ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]。-
编写一个 SQL 查询来重新格式化表，使得新的表中有一个部门 id 列和一些对应 每个月 的收入（revenue）列。
+重新格式化表格，使得 每个月 都有一个部门 id 列和一个收入列。
-查询结果格式如下面的示例所示：
+以 任意顺序 返回结果表。
+ +结果格式如以下示例所示。
+ ++ +
示例 1：
-Department 表： +输入： +Department table: +------+---------+-------+ | id | revenue | month | +------+---------+-------+ @@ -40,8 +47,7 @@ Department 表： | 1 | 7000 | Feb | | 1 | 6000 | Mar | +------+---------+-------+ - -查询得到的结果表： +输出： +------+-------------+-------------+-------------+-----+-------------+ | id | Jan_Revenue | Feb_Revenue | Mar_Revenue | ... | Dec_Revenue | +------+-------------+-------------+-------------+-----+-------------+ @@ -49,9 +55,8 @@ Department 表： | 2 | 9000 | null | null | ... | null | | 3 | null | 10000 | null | ... | null | +------+-------------+-------------+-------------+-----+-------------+ - -注意，结果表有 13 列 (1个部门 id 列 + 12个月份的收入列)。 -+解释：四月到十二月的收入为空。 +请注意，结果表共有 13 列（1 列用于部门 ID，其余 12 列用于各个月份）。-
示例 1：
+示例 1：
-输入：arr1 = [1,5,3,6,7], arr2 = [1,3,2,4] ++输入：arr1 = [1,5,3,6,7], arr2 = [1,3,2,4] 输出：1 解释：用 2 来替换-5，之后arr1 = [1, 2, 3, 6, 7]。示例 2：
+示例 2：
-输入：arr1 = [1,5,3,6,7], arr2 = [4,3,1] ++输入：arr1 = [1,5,3,6,7], arr2 = [4,3,1] 输出：2 解释：用 3 来替换-5，然后用 4 来替换 3，得到arr1 = [1, 3, 4, 6, 7]。示例 3：
+示例 3：
-输入：arr1 = [1,5,3,6,7], arr2 = [1,6,3,3] ++输入：arr1 = [1,5,3,6,7], arr2 = [1,6,3,3] 输出：-1 解释：无法使diff --git "a/AllProblems/1193.\346\257\217\346\234\210\344\272\244\346\230\223 I.md" "b/AllProblems/1193.\346\257\217\346\234\210\344\272\244\346\230\223 I.md" index 33751df8d16..f56fef21137 100644 --- "a/AllProblems/1193.\346\257\217\346\234\210\344\272\244\346\230\223 I.md" +++ "b/AllProblems/1193.\346\257\217\346\234\210\344\272\244\346\230\223 I.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 中等, 数据库] 力扣题目链接：[https://leetcode.cn/problems/monthly-transactions-i/](https://leetcode.cn/problems/monthly-transactions-i/) -arr1 严格递增。Table:
+Transactions表：
Transactions+---------------+---------+ @@ -22,7 +22,7 @@ tags: [题解, LeetCode, 中等, 数据库] +---------------+---------+ id 是这个表的主键。 该表包含有关传入事务的信息。 -state 列类型为 “[”批准“，”拒绝“] 之一。 +state 列类型为 ["approved", "declined"] 之一。diff --git "a/AllProblems/1202.\344\272\244\346\215\242\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\205\203\347\264\240.md" "b/AllProblems/1202.\344\272\244\346\215\242\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\205\203\347\264\240.md" index ebc6f6a8cfb..95155b26c74 100644 --- "a/AllProblems/1202.\344\272\244\346\215\242\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\205\203\347\264\240.md" +++ "b/AllProblems/1202.\344\272\244\346\215\242\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\205\203\347\264\240.md" @@ -1,7 +1,7 @@ --- title: 1202.交换字符串中的元素 date: 2022-06-02 20-04-20 -tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 哈希表, 字符串] +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 数组, 哈希表, 字符串, 排序] --- # 【LetMeFly】1202.交换字符串中的元素 diff --git "a/AllProblems/1204.\346\234\200\345\220\216\344\270\200\344\270\252\350\203\275\350\277\233\345\205\245\345\267\264\345\243\253\347\232\204\344\272\272.md" "b/AllProblems/1204.\346\234\200\345\220\216\344\270\200\344\270\252\350\203\275\350\277\233\345\205\245\345\267\264\345\243\253\347\232\204\344\272\272.md" new file mode 100644 index 00000000000..6c9b842b0e9 --- /dev/null +++ "b/AllProblems/1204.\346\234\200\345\220\216\344\270\200\344\270\252\350\203\275\350\277\233\345\205\245\345\267\264\345\243\253\347\232\204\344\272\272.md" @@ -0,0 +1,74 @@ +--- +title: 1204.最后一个能进入巴士的人 +date: 2023-10-10 14-27-55 +tags: [题解, LeetCode, 中等, 数据库] +--- + +# 【LetMeFly】1204.最后一个能进入巴士的人 + +力扣题目链接：[https://leetcode.cn/problems/last-person-to-fit-in-the-bus/](https://leetcode.cn/problems/last-person-to-fit-in-the-bus/) + +
表:
+ +Queue++-------------+---------+ +| Column Name | Type | ++-------------+---------+ +| person_id | int | +| person_name | varchar | +| weight | int | +| turn | int | ++-------------+---------+ +person_id 是这个表具有唯一值的列。 +该表展示了所有候车乘客的信息。 +表中 person_id 和 turn 列将包含从 1 到 n 的所有数字，其中 n 是表中的行数。 +turn 决定了候车乘客上巴士的顺序，其中 turn=1 表示第一个上巴士，turn=n 表示最后一个上巴士。 +weight 表示候车乘客的体重，以千克为单位。 ++ ++ +
有一队乘客在等着上巴士。然而，巴士有
+ +1000千克 的重量限制，所以其中一部分乘客可能无法上巴士。编写解决方案找出 最后一个 上巴士且不超过重量限制的乘客，并报告
+ +person_name。题目测试用例确保顺位第一的人可以上巴士且不会超重。返回结果格式如下所示。
+ ++ +
示例 1：
+ ++输入： +Queue 表 ++-----------+-------------+--------+------+ +| person_id | person_name | weight | turn | ++-----------+-------------+--------+------+ +| 5 | Alice | 250 | 1 | +| 4 | Bob | 175 | 5 | +| 3 | Alex | 350 | 2 | +| 6 | John Cena | 400 | 3 | +| 1 | Winston | 500 | 6 | +| 2 | Marie | 200 | 4 | ++-----------+-------------+--------+------+ +输出： ++-------------+ +| person_name | ++-------------+ +| John Cena | ++-------------+ +解释： +为了简化，Queue 表按 turn 列由小到大排序。 ++------+----+-----------+--------+--------------+ +| Turn | ID | Name | Weight | Total Weight | ++------+----+-----------+--------+--------------+ +| 1 | 5 | Alice | 250 | 250 | +| 2 | 3 | Alex | 350 | 600 | +| 3 | 6 | John Cena | 400 | 1000 | (最后一个上巴士) +| 4 | 2 | Marie | 200 | 1200 | (无法上巴士) +| 5 | 4 | Bob | 175 | ___ | +| 6 | 1 | Winston | 500 | ___ | ++------+----+-----------+--------+--------------++ + + \ No newline at end of file diff --git "a/AllProblems/1211.\346\237\245\350\257\242\347\273\223\346\236\234\347\232\204\350\264\250\351\207\217\345\222\214\345\215\240\346\257\224.md" "b/AllProblems/1211.\346\237\245\350\257\242\347\273\223\346\236\234\347\232\204\350\264\250\351\207\217\345\222\214\345\215\240\346\257\224.md" index ff7416a7b2f..4ad34d20eaa 100644 --- "a/AllProblems/1211.\346\237\245\350\257\242\347\273\223\346\236\234\347\232\204\350\264\250\351\207\217\345\222\214\345\215\240\346\257\224.md" +++ "b/AllProblems/1211.\346\237\245\350\257\242\347\273\223\346\236\234\347\232\204\350\264\250\351\207\217\345\222\214\345\215\240\346\257\224.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/queries-quality-and-percentage/](https://leetcode.cn/problems/queries-quality-and-percentage/) -查询表
+Queries：
Queries表：+-------------+---------+ @@ -19,10 +19,10 @@ tags: [题解, LeetCode, 简单, 数据库] | position | int | | rating | int | +-------------+---------+ -此表没有主键，并可能有重复的行。 +此表可能有重复的行。 此表包含了一些从数据库中收集的查询信息。 -“位置”（position）列的值为 1 到 500 。 -“评分”（rating）列的值为 1 到 5 。评分小于 3 的查询被定义为质量很差的查询。 +“位置”（position）列的值为 1 到 500 。 +“评分”（rating）列的值为 1 到 5 。评分小于 3 的查询被定义为质量很差的查询。@@ -39,13 +39,20 @@ tags: [题解, LeetCode, 简单, 数据库]
评分小于 3 的查询结果占全部查询结果的百分比。
-编写一组 SQL 来查找每次查询的
+名称(query_name)、质量(quality) 和劣质查询百分比(poor_query_percentage)。编写解决方案，找出每次的
-query_name、quality和poor_query_percentage。+
质量(quality) 和劣质查询百分比(poor_query_percentage) 都应四舍五入到小数点后两位。-
quality和poor_query_percentage都应 四舍五入到小数点后两位 。查询结果格式如下所示：
+以 任意顺序 返回结果表。
+ +结果格式如下所示：
+ ++ +
示例 1：
+输入： Queries table: +------------+-------------------+----------+--------+ | query_name | result | position | rating | @@ -57,15 +64,14 @@ Queries table: | Cat | Siamese | 3 | 3 | | Cat | Sphynx | 7 | 4 | +------------+-------------------+----------+--------+ - -Result table: +输出： +------------+---------+-----------------------+ | query_name | quality | poor_query_percentage | +------------+---------+-----------------------+ | Dog | 2.50 | 33.33 | | Cat | 0.66 | 33.33 | +------------+---------+-----------------------+ - +解释： Dog 查询结果的质量为 ((5 / 1) + (5 / 2) + (1 / 200)) / 3 = 2.50 Dog 查询结果的劣质查询百分比为 (1 / 3) * 100 = 33.33 diff --git "a/AllProblems/1232.\347\274\200\347\202\271\346\210\220\347\272\277.md" "b/AllProblems/1232.\347\274\200\347\202\271\346\210\220\347\272\277.md" index 82c9555d293..7862e52fb0a 100644 --- "a/AllProblems/1232.\347\274\200\347\202\271\346\210\220\347\272\277.md" +++ "b/AllProblems/1232.\347\274\200\347\202\271\346\210\220\347\272\277.md" @@ -12,7 +12,7 @@ tags: [题解, LeetCode, 简单, 几何, 数组, 数学]--
示例 1：
+示例 1：
@@ -21,7 +21,7 @@ tags: [题解, LeetCode, 简单, 几何, 数组, 数学] 输出：true
示例 2：
+示例 2：
diff --git "a/AllProblems/1233.\345\210\240\351\231\244\345\255\220\346\226\207\344\273\266\345\244\271.md" "b/AllProblems/1233.\345\210\240\351\231\244\345\255\220\346\226\207\344\273\266\345\244\271.md" index fc08002f05a..a6bd9d746ff 100644 --- "a/AllProblems/1233.\345\210\240\351\231\244\345\255\220\346\226\207\344\273\266\345\244\271.md" +++ "b/AllProblems/1233.\345\210\240\351\231\244\345\255\220\346\226\207\344\273\266\345\244\271.md" @@ -1,7 +1,7 @@ --- title: 1233.删除子文件夹 date: 2022-06-02 20-04-37 -tags: [题解, LeetCode, 中等, 字典树, 数组, 字符串] +tags: [题解, LeetCode, 中等, 深度优先搜索, 字典树, 数组, 字符串] --- # 【LetMeFly】1233.删除子文件夹 diff --git "a/AllProblems/1240.\351\223\272\347\223\267\347\240\226.md" "b/AllProblems/1240.\351\223\272\347\223\267\347\240\226.md" index 375dbaa3728..bdc991f7694 100644 --- "a/AllProblems/1240.\351\223\272\347\223\267\347\240\226.md" +++ "b/AllProblems/1240.\351\223\272\347\223\267\347\240\226.md" @@ -1,7 +1,7 @@ --- title: 1240.铺瓷砖 date: 2022-06-02 20-04-41 -tags: [题解, LeetCode, 困难, 动态规划, 回溯] +tags: [题解, LeetCode, 困难, 回溯] --- # 【LetMeFly】1240.铺瓷砖 diff --git "a/AllProblems/1251.\345\271\263\345\235\207\345\224\256\344\273\267.md" "b/AllProblems/1251.\345\271\263\345\235\207\345\224\256\344\273\267.md" index 20e9a2dac07..74280a6980c 100644 --- "a/AllProblems/1251.\345\271\263\345\235\207\345\224\256\344\273\267.md" +++ "b/AllProblems/1251.\345\271\263\345\235\207\345\224\256\344\273\267.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/average-selling-price/](https://leetcode.cn/problems/average-selling-price/) -
Table:
+Prices表：
Prices+---------------+---------+ @@ -19,13 +19,13 @@ tags: [题解, LeetCode, 简单, 数据库] | end_date | date | | price | int | +---------------+---------+ -(product_id，start_date，end_date) 是Prices表的主键。 -Prices表的每一行表示的是某个产品在一段时期内的价格。 +(product_id，start_date，end_date) 是prices表的主键（具有唯一值的列的组合）。 +prices表的每一行表示的是某个产品在一段时期内的价格。 每个产品的对应时间段是不会重叠的，这也意味着同一个产品的价格时段不会出现交叉。-
Table:
+UnitsSold表：
UnitsSold+---------------+---------+ @@ -35,16 +35,23 @@ tags: [题解, LeetCode, 简单, 数据库] | purchase_date | date | | units | int | +---------------+---------+ -+该表可能包含重复数据。 +该表的每一行表示的是每种产品的出售日期，单位和产品 id。UnitsSold表没有主键，它可能包含重复项。 -UnitsSold表的每一行表示的是每种产品的出售日期，单位和产品 id。-
编写SQL查询以查找每种产品的平均售价。
+
-average_price应该四舍五入到小数点后两位。
-查询结果格式如下例所示：编写解决方案以查找每种产品的平均售价。
+ +average_price应该 四舍五入到小数点后两位。返回结果表 无顺序要求 。
+ +结果格式如下例所示。
+ ++ +
示例 1：
+输入： Prices table: +------------+------------+------------+--------+ | product_id | start_date | end_date | price | @@ -54,7 +61,6 @@ Prices table: | 2 | 2019-02-01 | 2019-02-20 | 15 | | 2 | 2019-02-21 | 2019-03-31 | 30 | +------------+------------+------------+--------+ - UnitsSold table: +------------+---------------+-------+ | product_id | purchase_date | units | @@ -64,14 +70,14 @@ UnitsSold table: | 2 | 2019-02-10 | 200 | | 2 | 2019-03-22 | 30 | +------------+---------------+-------+ - -Result table: +输出： +------------+---------------+ | product_id | average_price | +------------+---------------+ | 1 | 6.96 | | 2 | 16.96 | +------------+---------------+ +解释： 平均售价 = 产品总价 / 销售的产品数量。 产品 1 的平均售价 = ((100 * 5)+(15 * 20) )/ 115 = 6.96 产品 2 的平均售价 = ((200 * 15)+(30 * 30) )/ 230 = 16.96diff --git "a/AllProblems/1262.\345\217\257\350\242\253\344\270\211\346\225\264\351\231\244\347\232\204\346\234\200\345\244\247\345\222\214.md" "b/AllProblems/1262.\345\217\257\350\242\253\344\270\211\346\225\264\351\231\244\347\232\204\346\234\200\345\244\247\345\222\214.md" index 47121366e7f..0f2505dfcc3 100644 --- "a/AllProblems/1262.\345\217\257\350\242\253\344\270\211\346\225\264\351\231\244\347\232\204\346\234\200\345\244\247\345\222\214.md" +++ "b/AllProblems/1262.\345\217\257\350\242\253\344\270\211\346\225\264\351\231\244\347\232\204\346\234\200\345\244\247\345\222\214.md" @@ -1,7 +1,7 @@ --- title: 1262.可被三整除的最大和 date: 2022-06-02 20-04-52 -tags: [题解, LeetCode, 中等, 贪心, 数组, 动态规划] +tags: [题解, LeetCode, 中等, 贪心, 数组, 动态规划, 排序] --- # 【LetMeFly】1262.可被三整除的最大和 diff --git "a/AllProblems/1268.\346\220\234\347\264\242\346\216\250\350\215\220\347\263\273\347\273\237.md" "b/AllProblems/1268.\346\220\234\347\264\242\346\216\250\350\215\220\347\263\273\347\273\237.md" index 222f5512ac4..65ed61579e1 100644 --- "a/AllProblems/1268.\346\220\234\347\264\242\346\216\250\350\215\220\347\263\273\347\273\237.md" +++ "b/AllProblems/1268.\346\220\234\347\264\242\346\216\250\350\215\220\347\263\273\347\273\237.md" @@ -1,7 +1,7 @@ --- title: 1268.搜索推荐系统 date: 2022-06-02 20-04-56 -tags: [题解, LeetCode, 中等, 字典树, 数组, 字符串] +tags: [题解, LeetCode, 中等, 字典树, 数组, 字符串, 二分查找, 排序, 堆（优先队列）] --- # 【LetMeFly】1268.搜索推荐系统 diff --git "a/AllProblems/1280.\345\255\246\347\224\237\344\273\254\345\217\202\345\212\240\345\220\204\347\247\221\346\265\213\350\257\225\347\232\204\346\254\241\346\225\260.md" "b/AllProblems/1280.\345\255\246\347\224\237\344\273\254\345\217\202\345\212\240\345\220\204\347\247\221\346\265\213\350\257\225\347\232\204\346\254\241\346\225\260.md" index 66a52b68529..fb4bd392aee 100644 --- "a/AllProblems/1280.\345\255\246\347\224\237\344\273\254\345\217\202\345\212\240\345\220\204\347\247\221\346\265\213\350\257\225\347\232\204\346\254\241\346\225\260.md" +++ "b/AllProblems/1280.\345\255\246\347\224\237\344\273\254\345\217\202\345\212\240\345\220\204\347\247\221\346\265\213\350\257\225\347\232\204\346\254\241\346\225\260.md" @@ -10,48 +10,60 @@ tags: [题解, LeetCode, 简单, 数据库]学生表:
-Students+---------------+---------+ +++---------------+---------+ | Column Name | Type | +---------------+---------+ | student_id | int | | student_name | varchar | +---------------+---------+ -主键为 student_id（学生ID），该表内的每一行都记录有学校一名学生的信息。 +在 SQL 中，主键为 student_id（学生ID）。 +该表内的每一行都记录有学校一名学生的信息。
科目表:
-Subjects+--------------+---------+ +++--------------+---------+ | Column Name | Type | +--------------+---------+ | subject_name | varchar | +--------------+---------+ -主键为 subject_name（科目名称），每一行记录学校的一门科目名称。 +在 SQL 中，主键为 subject_name（科目名称）。 +每一行记录学校的一门科目名称。
考试表:
-Examinations+--------------+---------+ +++--------------+---------+ | Column Name | Type | +--------------+---------+ | student_id | int | | subject_name | varchar | +--------------+---------+ -这张表压根没有主键，可能会有重复行。 -学生表里的一个学生修读科目表里的每一门科目，而这张考试表的每一行记录就表示学生表里的某个学生参加了一次科目表里某门科目的测试。 +这个表可能包含重复数据（换句话说，在 SQL 中，这个表没有主键）。 +学生表里的一个学生修读科目表里的每一门科目。 +这张考试表的每一行记录就表示学生表里的某个学生参加了一次科目表里某门科目的测试。-
要求写一段 SQL 语句，查询出每个学生参加每一门科目测试的次数，结果按
+student_id和subject_name排序。查询出每个学生参加每一门科目测试的次数，结果按
+ +student_id和subject_name排序。查询结构格式如下所示。
+ +-
查询结构格式如下所示：
+示例 1：
-Students table: ++输入： +Students table: +------------+--------------+ | student_id | student_name | +------------+--------------+ @@ -84,7 +96,7 @@ Examinations table: | 2 | Math | | 1 | Math | +------------+--------------+ -Result table: +输出： +------------+--------------+--------------+----------------+ | student_id | student_name | subject_name | attended_exams | +------------+--------------+--------------+----------------+ @@ -101,6 +113,7 @@ Result table: | 13 | John | Physics | 1 | | 13 | John | Programming | 1 | +------------+--------------+--------------+----------------+ +解释： 结果表需包含所有学生和所有科目（即便测试次数为0）： Alice 参加了 3 次数学测试, 2 次物理测试，以及 1 次编程测试； Bob 参加了 1 次数学测试, 1 次编程测试，没有参加物理测试； diff --git "a/AllProblems/1289.\344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214 II.md" "b/AllProblems/1289.\344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214 II.md" new file mode 100644 index 00000000000..c0a7384811f --- /dev/null +++ "b/AllProblems/1289.\344\270\213\351\231\215\350\267\257\345\276\204\346\234\200\345\260\217\345\222\214 II.md" @@ -0,0 +1,50 @@ +--- +title: 1289.下降路径最小和 II +date: 2023-10-10 14-28-33 +tags: [题解, LeetCode, 困难, 数组, 动态规划, 矩阵] +--- + +# 【LetMeFly】1289.下降路径最小和 II + +力扣题目链接：[https://leetcode.cn/problems/minimum-falling-path-sum-ii/](https://leetcode.cn/problems/minimum-falling-path-sum-ii/) + +给你一个
+ +n x n整数矩阵grid，请你返回 非零偏移下降路径 数字和的最小值。非零偏移下降路径 定义为：从
+ +grid数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。+ +
示例 1：
+ ++ +
+输入：grid = [[1,2,3],[4,5,6],[7,8,9]] +输出：13 +解释： +所有非零偏移下降路径包括： +[1,5,9], [1,5,7], [1,6,7], [1,6,8], +[2,4,8], [2,4,9], [2,6,7], [2,6,8], +[3,4,8], [3,4,9], [3,5,7], [3,5,9] +下降路径中数字和最小的是 [1,5,7] ，所以答案是 13 。 ++ +示例 2：
+ ++输入：grid = [[7]] +输出：7 ++ ++ +
提示：
+ +
n == grid.length == grid[i].length1 <= n <= 200-99 <= grid[i][j] <= 99你是餐馆的老板，现在你想分析一下可能的营业额变化增长（每天至少有一位顾客）。
-写一条 SQL 查询计算以 7 天（某日期 + 该日期前的 6 天）为一个时间段的顾客消费平均值。average_amount 要 保留两位小数。
计算以 7 天（某日期 + 该日期前的 6 天）为一个时间段的顾客消费平均值。average_amount 要 保留两位小数。
查询结果按 visited_on 排序。
结果按 visited_on 升序排序。
查询结果格式的例子如下。
+返回结果格式的例子如下。
diff --git "a/AllProblems/1327.\345\210\227\345\207\272\346\214\207\345\256\232\346\227\266\351\227\264\346\256\265\345\206\205\346\211\200\346\234\211\347\232\204\344\270\213\345\215\225\344\272\247\345\223\201.md" "b/AllProblems/1327.\345\210\227\345\207\272\346\214\207\345\256\232\346\227\266\351\227\264\346\256\265\345\206\205\346\211\200\346\234\211\347\232\204\344\270\213\345\215\225\344\272\247\345\223\201.md" index 91dffab7eaa..eca44a9aff5 100644 --- "a/AllProblems/1327.\345\210\227\345\207\272\346\214\207\345\256\232\346\227\266\351\227\264\346\256\265\345\206\205\346\211\200\346\234\211\347\232\204\344\270\213\345\215\225\344\272\247\345\223\201.md" +++ "b/AllProblems/1327.\345\210\227\345\207\272\346\214\207\345\256\232\346\227\266\351\227\264\346\256\265\345\206\205\346\211\200\346\234\211\347\232\204\344\270\213\345\215\225\344\272\247\345\223\201.md" @@ -18,7 +18,7 @@ tags: [题解, LeetCode, 简单, 数据库] | product_name | varchar | | product_category | varchar | +------------------+---------+ -product_id 是该表主键。 +product_id 是该表主键(具有唯一值的列)。 该表包含该公司产品的数据。 @@ -34,14 +34,14 @@ product_id 是该表主键。 | order_date | date | | unit | int | +---------------+---------+ -该表无主键，可能包含重复行。 -product_id 是表单 Products 的外键。 +该表可能包含重复行。 +product_id 是表单 Products 的外键（reference 列）。 unit 是在日期 order_date 内下单产品的数目。
-
写一个 SQL 语句，要求获取在 2020 年 2 月份下单的数量不少于 100 的产品的名字和数目。
+写一个解决方案，要求获取在 2020 年 2 月份下单的数量不少于 100 的产品的名字和数目。
返回结果表单的 顺序无要求 。
diff --git "a/AllProblems/134.\345\212\240\346\262\271\347\253\231.md" "b/AllProblems/134.\345\212\240\346\262\271\347\253\231.md" index 97d588a3f0b..42bc715ad30 100644 --- "a/AllProblems/134.\345\212\240\346\262\271\347\253\231.md" +++ "b/AllProblems/134.\345\212\240\346\262\271\347\253\231.md" @@ -12,7 +12,7 @@ tags: [题解, LeetCode, 中等, 贪心, 数组]你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
diff --git "a/AllProblems/1341.\347\224\265\345\275\261\350\257\204\345\210\206.md" "b/AllProblems/1341.\347\224\265\345\275\261\350\257\204\345\210\206.md" index 0abb1552718..6a3efdf4eef 100644 --- "a/AllProblems/1341.\347\224\265\345\275\261\350\257\204\345\210\206.md" +++ "b/AllProblems/1341.\347\224\265\345\275\261\350\257\204\345\210\206.md" @@ -17,7 +17,7 @@ tags: [题解, LeetCode, 中等, 数据库] | movie_id | int | | title | varchar | +---------------+---------+ -movie_id 是这个表的主键。 +movie_id 是这个表的主键(具有唯一值的列)。 title 是电影的名字。 @@ -30,7 +30,7 @@ title 是电影的名字。 | user_id | int | | name | varchar | +---------------+---------+ -user_id 是表的主键。 +user_id 是表的主键(具有唯一值的列)。
表：MovieRating
-
请你编写一组 SQL 查询：
+请你编写一个解决方案：
字典序 ，即按字母在字典中出现顺序对字符串排序，字典序较小则意味着排序靠前。
-查询结果格式如下例所示。
+返回结果格式如下例所示。
-
示例：
+示例 1：
输入： diff --git "a/AllProblems/1359.\346\234\211\346\225\210\347\232\204\345\277\253\351\200\222\345\272\217\345\210\227\346\225\260\347\233\256.md" "b/AllProblems/1359.\346\234\211\346\225\210\347\232\204\345\277\253\351\200\222\345\272\217\345\210\227\346\225\260\347\233\256.md" index a6d484561dc..bb22eee93f8 100644 --- "a/AllProblems/1359.\346\234\211\346\225\210\347\232\204\345\277\253\351\200\222\345\272\217\345\210\227\346\225\260\347\233\256.md" +++ "b/AllProblems/1359.\346\234\211\346\225\210\347\232\204\345\277\253\351\200\222\345\272\217\345\210\227\346\225\260\347\233\256.md" @@ -10,22 +10,24 @@ tags: [题解, LeetCode, 困难, 数学, 动态规划, 组合数学]给你
-n笔订单，每笔订单都需要快递服务。请你统计所有有效的 收件/配送 序列的数目，确保第
+i个物品的配送服务delivery(i)总是在其收件服务pickup(i)之后。计算所有有效的 取货 / 交付 可能的顺序，使 delivery(i) 总是在 pickup(i) 之后。
-由于答案可能很大，请返回答案对
+10^9 + 7取余的结果。由于答案可能很大，请返回答案对 10^9 + 7 取余的结果。
示例 1：
-输入：n = 1 ++输入：n = 1 输出：1 解释：只有一种序列 (P1, D1)，物品 1 的配送服务（D1）在物品 1 的收件服务（P1）后。示例 2：
-输入：n = 2 ++输入：n = 2 输出：6 解释：所有可能的序列包括： (P1,P2,D1,D2)，(P1,P2,D2,D1)，(P1,D1,P2,D2)，(P2,P1,D1,D2)，(P2,P1,D2,D1) 和 (P2,D2,P1,D1)。 @@ -34,7 +36,8 @@ tags: [题解, LeetCode, 困难, 数学, 动态规划, 组合数学]示例 3：
-输入：n = 3 ++输入：n = 3 输出：90diff --git "a/AllProblems/1363.\345\275\242\346\210\220\344\270\211\347\232\204\346\234\200\345\244\247\345\200\215\346\225\260.md" "b/AllProblems/1363.\345\275\242\346\210\220\344\270\211\347\232\204\346\234\200\345\244\247\345\200\215\346\225\260.md" index ca65a034863..adff5ae9156 100644 --- "a/AllProblems/1363.\345\275\242\346\210\220\344\270\211\347\232\204\346\234\200\345\244\247\345\200\215\346\225\260.md" +++ "b/AllProblems/1363.\345\275\242\346\210\220\344\270\211\347\232\204\346\234\200\345\244\247\345\200\215\346\225\260.md" @@ -8,36 +8,38 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 动态规划] 力扣题目链接：[https://leetcode.cn/problems/largest-multiple-of-three/](https://leetcode.cn/problems/largest-multiple-of-three/) -给你一个整数数组
+digits，你可以通过按任意顺序连接其中某些数字来形成 3 的倍数，请你返回所能得到的最大的 3 的倍数。给你一个整数数组
-digits，你可以通过按 任意顺序 连接其中某些数字来形成 3 的倍数，请你返回所能得到的最大的 3 的倍数。由于答案可能不在整数数据类型范围内，请以字符串形式返回答案。
- -如果无法得到答案，请返回一个空字符串。
+由于答案可能不在整数数据类型范围内，请以字符串形式返回答案。如果无法得到答案，请返回一个空字符串。返回的结果不应包含不必要的前导零。
示例 1：
-输入：digits = [8,1,9] -输出："981" ++输入：digits = [8,1,9] +输出："981"示例 2：
-输入：digits = [8,6,7,1,0] -输出："8760" ++输入：digits = [8,6,7,1,0] +输出："8760"示例 3：
-输入：digits = [1] -输出："" ++输入：digits = [1] +输出：""示例 4：
-输入：digits = [0,0,0,0,0,0] -输出："0" ++输入：digits = [0,0,0,0,0,0] +输出："0"@@ -47,7 +49,6 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 动态规划]
1 <= digits.length <= 10^40 <= digits[i] <= 9给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。
你必须设计并实现线性时间复杂度的算法且不使用额外空间来解决此问题。
+你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。
diff --git "a/AllProblems/1378.\344\275\277\347\224\250\345\224\257\344\270\200\346\240\207\350\257\206\347\240\201\346\233\277\346\215\242\345\221\230\345\267\245ID.md" "b/AllProblems/1378.\344\275\277\347\224\250\345\224\257\344\270\200\346\240\207\350\257\206\347\240\201\346\233\277\346\215\242\345\221\230\345\267\245ID.md" index df87db5e008..a8b80a27fc1 100644 --- "a/AllProblems/1378.\344\275\277\347\224\250\345\224\257\344\270\200\346\240\207\350\257\206\347\240\201\346\233\277\346\215\242\345\221\230\345\267\245ID.md" +++ "b/AllProblems/1378.\344\275\277\347\224\250\345\224\257\344\270\200\346\240\207\350\257\206\347\240\201\346\233\277\346\215\242\345\221\230\345\267\245ID.md" @@ -17,7 +17,7 @@ tags: [题解, LeetCode, 简单, 数据库] | id | int | | name | varchar | +---------------+---------+ -id 是这张表的主键。 +在 SQL 中，id 是这张表的主键。 这张表的每一行分别代表了某公司其中一位员工的名字和 ID 。 @@ -32,21 +32,21 @@ id 是这张表的主键。 | id | int | | unique_id | int | +---------------+---------+ -(id, unique_id) 是这张表的主键。 +在 SQL 中，(id, unique_id) 是这张表的主键。 这张表的每一行包含了该公司某位员工的 ID 和他的唯一标识码（unique ID）。
-
写一段SQL查询来展示每位用户的 唯一标识码（unique ID ）；如果某位员工没有唯一标识码，使用 null 填充即可。
+展示每位用户的 唯一标识码（unique ID ）；如果某位员工没有唯一标识码，使用 null 填充即可。
你可以以 任意 顺序返回结果表。
-查询结果的格式如下例所示。
+返回结果的格式如下例所示。
-
示例 1：
+示例 1：
输入：
diff --git "a/AllProblems/138.\351\232\217\346\234\272\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" "b/AllProblems/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 00000000000..24d97bd7d90
--- /dev/null
+++ "b/AllProblems/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,70 @@
+---
+title: 138.随机链表的复制
+date: 2023-10-10 14-19-57
+tags: [题解, LeetCode, 中等, 哈希表, 链表]
+---
+
+# 【LetMeFly】138.随机链表的复制
+
+力扣题目链接：[https://leetcode.cn/problems/copy-list-with-random-pointer/](https://leetcode.cn/problems/copy-list-with-random-pointer/)
+
+给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
+
+构造这个链表的 深拷贝。 深拷贝应该正好由 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：
+
+
+
+
+输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
+
+
+示例 2：
+
+
+
+
+输入：head = [[1,1],[2,1]]
+输出：[[1,1],[2,1]]
+
+
+示例 3：
+
+
+
+
+输入：head = [[3,null],[3,0],[3,null]]
+输出：[[3,null],[3,0],[3,null]]
+
+
+
+
+提示：
+
+
+ 0 <= n <= 1000-104 <= Node.val <= 104Node.random 为 null 或指向链表中的节点。
+
+
+
+
+
\ No newline at end of file
diff --git "a/AllProblems/1383.\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274.md" "b/AllProblems/1383.\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274.md"
index 5859c02275d..837da4befa9 100644
--- "a/AllProblems/1383.\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274.md"
+++ "b/AllProblems/1383.\346\234\200\345\244\247\347\232\204\345\233\242\351\230\237\350\241\250\347\216\260\345\200\274.md"
@@ -8,15 +8,20 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 排序, 堆（优先队列）]
力扣题目链接：[https://leetcode.cn/problems/maximum-performance-of-a-team/](https://leetcode.cn/problems/maximum-performance-of-a-team/)
-公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。
+给定两个整数 n 和 k，以及两个长度为 n 的整数数组 speed 和 efficiency。现有 n 名工程师，编号从 1 到 n。其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。
+
+从这 n 名工程师中最多选择 k 名不同的工程师，使其组成的团队具有最大的团队表现值。
团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。
+请你返回该团队的最大团队表现值，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。
+
示例 1：
-输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
+
+输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。
@@ -24,7 +29,8 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 排序, 堆（优先队列）]
示例 2：
-输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
+
+输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
输出：68
解释：
此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。
@@ -32,7 +38,8 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 排序, 堆（优先队列）]
示例 3：
-输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
+
+输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
输出：72
@@ -41,12 +48,11 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 排序, 堆（优先队列）]
提示：
- 1 <= n <= 10^51 <= k <= n <= 10^5speed.length == nefficiency.length == n1 <= speed[i] <= 10^51 <= efficiency[i] <= 10^81 <= k <= n
diff --git "a/AllProblems/139.\345\215\225\350\257\215\346\213\206\345\210\206.md" "b/AllProblems/139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
index 3f9179276c9..62bec45c675 100644
--- "a/AllProblems/139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
+++ "b/AllProblems/139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
@@ -46,7 +46,7 @@ tags: [题解, LeetCode, 中等, 字典树, 记忆化搜索, 数组, 哈希表,
1 <= s.length <= 3001 <= wordDict.length <= 10001 <= wordDict[i].length <= 20s 和 wordDict[i] 仅有小写英文字母组成s 和 wordDict[i] 仅由小写英文字母组成wordDict 中的所有字符串 互不相同Stocks 表：
-+---------------+---------+
+
++---------------+---------+
| Column Name | Type |
+---------------+---------+
| stock_name | varchar |
@@ -18,23 +19,29 @@ tags: [题解, LeetCode, 中等, 数据库]
| operation_day | int |
| price | int |
+---------------+---------+
-(stock_name, day) 是这张表的主键
-operation 列使用的是一种枚举类型，包括：('Sell','Buy')
+(stock_name, day) 是这张表的主键(具有唯一值的列的组合)
+operation 列使用的是一种枚举类型，包括：('Sell','Buy')
此表的每一行代表了名为 stock_name 的某支股票在 operation_day 这一天的操作价格。
-保证股票的每次'Sell'操作前，都有相应的'Buy'操作。
+此表可以保证，股票的每个“卖出”操作在前一天都有相应的“买入”操作。并且，股票的每个“买入”操作在即将到来的一天都有相应的“卖出”操作。
-编写一个SQL查询来报告每支股票的资本损益。
+编写解决方案报告每只股票的 资本损益。
+
+股票的 资本利得/损失 是指一次或多次买卖该股票后的总收益或损失。
-股票的资本损益是一次或多次买卖股票后的全部收益或损失。
+以 任意顺序 返回结果表。
-以任意顺序返回结果即可。
+结果格式如下所示。
-SQL查询结果的格式如下例所示：
+
-Stocks 表:
+示例 1：
+
+
+输入：
+Stocks 表:
+---------------+-----------+---------------+--------+
| stock_name | operation | operation_day | price |
+---------------+-----------+---------------+--------+
@@ -49,8 +56,7 @@ operation 列使用的是一种枚举类型，包括：('Sell','Buy&
| Handbags | Sell | 29 | 7000 |
| Corona Masks | Sell | 10 | 10000 |
+---------------+-----------+---------------+--------+
-
-Result 表:
+输出：
+---------------+-------------------+
| stock_name | capital_gain_loss |
+---------------+-------------------+
@@ -58,9 +64,10 @@ Result 表:
| Leetcode | 8000 |
| Handbags | -23000 |
+---------------+-------------------+
+解释：
Leetcode 股票在第一天以1000美元的价格买入，在第五天以9000美元的价格卖出。资本收益=9000-1000=8000美元。
Handbags 股票在第17天以30000美元的价格买入，在第29天以7000美元的价格卖出。资本损失=7000-30000=-23000美元。
-Corona Masks 股票在第1天以10美元的价格买入，在第3天以1010美元的价格卖出。在第4天以1000美元的价格再次购买，在第5天以500美元的价格出售。最后，它在第6天以1000美元的价格被买走，在第10天以10000美元的价格被卖掉。资本损益是每次（’Buy'->'Sell'）操作资本收益或损失的和=（1010-10）+（500-1000）+（10000-1000）=1000-500+9000=9500美元。
+Corona Masks 股票在第1天以10美元的价格买入，在第3天以1010美元的价格卖出。在第4天以1000美元的价格再次购买，在第5天以500美元的价格出售。最后，它在第6天以1000美元的价格被买走，在第10天以10000美元的价格被卖掉。资本损益是每次（’Buy'->'Sell'）操作资本收益或损失的和=（1010-10）+（500-1000）+（10000-1000）=1000-500+9000=9500美元。
diff --git "a/AllProblems/1406.\347\237\263\345\255\220\346\270\270\346\210\217 III.md" "b/AllProblems/1406.\347\237\263\345\255\220\346\270\270\346\210\217 III.md"
index 5ec29555958..fcf4ed1718e 100644
--- "a/AllProblems/1406.\347\237\263\345\255\220\346\270\270\346\210\217 III.md"
+++ "b/AllProblems/1406.\347\237\263\345\255\220\346\270\270\346\210\217 III.md"
@@ -8,27 +8,33 @@ tags: [题解, LeetCode, 困难, 数组, 数学, 动态规划, 博弈]
力扣题目链接：[https://leetcode.cn/problems/stone-game-iii/](https://leetcode.cn/problems/stone-game-iii/)
-Alice 和 Bob 用几堆石子在做游戏。几堆石子排成一行，每堆石子都对应一个得分，由数组 stoneValue 给出。
+Alice 和 Bob 继续他们的石子游戏。几堆石子 排成一行 ，每堆石子都对应一个得分，由数组 stoneValue 给出。
Alice 和 Bob 轮流取石子，Alice 总是先开始。在每个玩家的回合中，该玩家可以拿走剩下石子中的的前 1、2 或 3 堆石子 。比赛一直持续到所有石头都被拿走。
-每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 0 。比赛的目标是决出最高分，得分最高的选手将会赢得比赛，比赛也可能会出现平局。
+每个玩家的最终得分为他所拿到的每堆石子的对应得分之和。每个玩家的初始分数都是 0 。
-假设 Alice 和 Bob 都采取 最优策略 。如果 Alice 赢了就返回 "Alice" ，Bob 赢了就返回 "Bob"，平局（分数相同）返回 "Tie" 。
+比赛的目标是决出最高分，得分最高的选手将会赢得比赛，比赛也可能会出现平局。
+
+假设 Alice 和 Bob 都采取 最优策略 。
+
+如果 Alice 赢了就返回 "Alice" ，Bob 赢了就返回 "Bob"，分数相同返回 "Tie" 。
示例 1：
-输入：values = [1,2,3,7]
-输出："Bob"
+
+输入：values = [1,2,3,7]
+输出："Bob"
解释：Alice 总是会输，她的最佳选择是拿走前三堆，得分变成 6 。但是 Bob 的得分为 7，Bob 获胜。
示例 2：
-输入：values = [1,2,3,-9]
-输出："Alice"
+
+输入：values = [1,2,3,-9]
+输出："Alice"
解释：Alice 要想获胜就必须在第一个回合拿走前三堆石子，给 Bob 留下负分。
如果 Alice 只拿走第一堆，那么她的得分为 1，接下来 Bob 拿走第二、三堆，得分为 5 。之后 Alice 只能拿到分数 -9 的石子堆，输掉比赛。
如果 Alice 拿走前两堆，那么她的得分为 3，接下来 Bob 拿走第三堆，得分为 3 。之后 Alice 只能拿到分数 -9 的石子堆，同样会输掉比赛。
@@ -36,30 +42,19 @@ tags: [题解, LeetCode, 困难, 数组, 数学, 动态规划, 博弈]
示例 3：
-输入：values = [1,2,3,6]
-输出："Tie"
+
+输入：values = [1,2,3,6]
+输出："Tie"
解释：Alice 无法赢得比赛。如果她决定选择前三堆，她可以以平局结束比赛，否则她就会输。
-示例 4：
-
-输入：values = [1,2,3,-1,-2,-3,7]
-输出："Alice"
-
-
-示例 5：
-
-输入：values = [-1,-2,-3]
-输出："Tie"
-
-
提示：
- 1 <= values.length <= 50000-1000 <= values[i] <= 10001 <= stoneValue.length <= 5 * 104-1000 <= stoneValue[i] <= 1000
diff --git "a/AllProblems/1407.\346\216\222\345\220\215\351\235\240\345\211\215\347\232\204\346\227\205\350\241\214\350\200\205.md" "b/AllProblems/1407.\346\216\222\345\220\215\351\235\240\345\211\215\347\232\204\346\227\205\350\241\214\350\200\205.md"
index 9e72f8c9497..af2be31e3fa 100644
--- "a/AllProblems/1407.\346\216\222\345\220\215\351\235\240\345\211\215\347\232\204\346\227\205\350\241\214\350\200\205.md"
+++ "b/AllProblems/1407.\346\216\222\345\220\215\351\235\240\345\211\215\347\232\204\346\227\205\350\241\214\350\200\205.md"
@@ -17,10 +17,10 @@ tags: [题解, LeetCode, 简单, 数据库]
| id | int |
| name | varchar |
+---------------+---------+
-id 是该表单主键。
+id 是该表中具有唯一值的列。
name 是用户名字。
-+
表：Rides
+
-
写一段 SQL , 报告每个用户的旅行距离。
+编写解决方案，报告每个用户的旅行距离。
-返回的结果表单，以 travelled_distance 降序排列 ，如果有两个或者更多的用户旅行了相同的距离, 那么再以 name 升序排列 。
返回的结果表单，以 travelled_distance 降序排列 ，如果有两个或者更多的用户旅行了相同的距离, 那么再以 name 升序排列 。
查询结果格式如下例所示。
+返回结果格式如下例所示。
+ ++ +
示例 1：
+输入： Users 表： +------+-----------+ | id | name | @@ -72,8 +77,7 @@ Rides 表： | 8 | 19 | 400 | | 9 | 7 | 230 | +------+----------+----------+ - -Result 表： +输出： +----------+--------------------+ | name | travelled_distance | +----------+--------------------+ @@ -85,6 +89,7 @@ Result 表： | Alice | 120 | | Donald | 0 | +----------+--------------------+ +解释： Elvis 和 Lee 旅行了 450 英里，Elvis 是排名靠前的旅行者，因为他的名字在字母表上的排序比 Lee 更小。 Bob, Jonathan, Alex 和 Alice 只有一次行程，我们只按此次行程的全部距离对他们排序。 Donald 没有任何行程, 他的旅行距离为 0。 diff --git "a/AllProblems/1409.\346\237\245\350\257\242\345\270\246\351\224\256\347\232\204\346\216\222\345\210\227.md" "b/AllProblems/1409.\346\237\245\350\257\242\345\270\246\351\224\256\347\232\204\346\216\222\345\210\227.md" index 7ebfc5553fc..776180f25a0 100644 --- "a/AllProblems/1409.\346\237\245\350\257\242\345\270\246\351\224\256\347\232\204\346\216\222\345\210\227.md" +++ "b/AllProblems/1409.\346\237\245\350\257\242\345\270\246\351\224\256\347\232\204\346\216\222\345\210\227.md" @@ -8,38 +8,41 @@ tags: [题解, LeetCode, 中等, 树状数组, 数组, 模拟] 力扣题目链接：[https://leetcode.cn/problems/queries-on-a-permutation-with-key/](https://leetcode.cn/problems/queries-on-a-permutation-with-key/) -给你一个待查数组
+queries，数组中的元素为1到m之间的正整数。 请你根据以下规则处理所有待查项queries[i]（从i=0到i=queries.length-1）：给定一个正整数数组
queries，其取值范围在1到m之间。 请你根据以下规则按顺序处理所有queries[i]（从i=0到i=queries.length-1）：
P=[1,2,3,...,m]。i ，请你找出待查项 queries[i] 在排列 P 中的位置（下标从 0 开始），然后将其从原位置移动到排列 P 的起始位置（即下标为 0 处）。注意， queries[i] 在 P 中的位置就是 queries[i] 的查询结果。P=[1,2,3,...,m]。i ，找到 queries[i] 在排列 P 中的位置（从 0 开始索引），然后将它移到排列 P 的开头（即下标为 0 处）。注意， queries[i] 的查询结果是 queries[i] 在 P 中移动前的位置。请你以数组形式返回待查数组 queries 的查询结果。
返回一个数组，包含从给定 queries 中查询到的结果。
示例 1：
-输入：queries = [3,1,2,1], m = 5 ++输入：queries = [3,1,2,1], m = 5 输出：[2,1,2,1] -解释：待查数组 queries 处理如下： -对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 2，接着我们把 3 移动到 P 的起始位置，得到 P=[3,1,2,4,5] 。 -对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,3,2,4,5] 。 -对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 2，接着我们把 2 移动到 P 的起始位置，得到 P=[2,1,3,4,5] 。 -对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,2,3,4,5] 。 -因此，返回的结果数组为 [2,1,2,1] 。 +解释：处理 queries 的过程如下： +对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 2，然后我们把 3 移动到 P 的开头，得到 P=[3,1,2,4,5] 。 +对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 1，然后我们把 1 移动到 P 的开头，得到 P=[1,3,2,4,5] 。 +对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 2，然后我们把 2 移动到 P 的开头，得到 P=[2,1,3,4,5] 。 +对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 1，然后我们把 1 移动到 P 的开头，得到 P=[1,2,3,4,5] 。 +因此，包含结果的数组为 [2,1,2,1] 。示例 2：
-输入：queries = [4,1,2,2], m = 4 ++输入：queries = [4,1,2,2], m = 4 输出：[3,1,2,0]示例 3：
-输入：queries = [7,5,5,8,3], m = 8 ++输入：queries = [7,5,5,8,3], m = 8 输出：[6,5,0,7,5]diff --git "a/AllProblems/1462.\350\257\276\347\250\213\350\241\250 IV.md" "b/AllProblems/1462.\350\257\276\347\250\213\350\241\250 IV.md" index 63687a3c2fd..b19e400d4d4 100644 --- "a/AllProblems/1462.\350\257\276\347\250\213\350\241\250 IV.md" +++ "b/AllProblems/1462.\350\257\276\347\250\213\350\241\250 IV.md" @@ -63,6 +63,7 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 图,
ai != bi[ai, bi] 都 不同1 <= queries.length <= 1040 <= ui, vi <= n - 1ui != vi-
编写一个 SQL 查询来查找每个日期、销售的不同产品的数量及其名称。
+
编写解决方案找出每个日期、销售的不同产品的数量及其名称。
每个日期的销售产品名称应按词典序排列。
返回按 sell_date 排序的结果表。
-查询结果格式如下例所示。
@@ -57,7 +57,8 @@ Activities 表： 解释： 对于2020-05-30，出售的物品是 (Headphone, Basketball, T-shirt)，按词典序排列，并用逗号 ',' 分隔。 对于2020-06-01，出售的物品是 (Pencil, Bible)，按词典序排列，并用逗号分隔。 -对于2020-06-02，出售的物品是 (Mask)，只需返回该物品名。 +对于2020-06-02，出售的物品是 (Mask)，只需返回该物品名。 + \ No newline at end of file diff --git "a/AllProblems/1509.\344\270\211\346\254\241\346\223\215\344\275\234\345\220\216\346\234\200\345\244\247\345\200\274\344\270\216\346\234\200\345\260\217\345\200\274\347\232\204\346\234\200\345\260\217\345\267\256.md" "b/AllProblems/1509.\344\270\211\346\254\241\346\223\215\344\275\234\345\220\216\346\234\200\345\244\247\345\200\274\344\270\216\346\234\200\345\260\217\345\200\274\347\232\204\346\234\200\345\260\217\345\267\256.md" index a869396db61..3e36ead10f3 100644 --- "a/AllProblems/1509.\344\270\211\346\254\241\346\223\215\344\275\234\345\220\216\346\234\200\345\244\247\345\200\274\344\270\216\346\234\200\345\260\217\345\200\274\347\232\204\346\234\200\345\260\217\345\267\256.md" +++ "b/AllProblems/1509.\344\270\211\346\254\241\346\223\215\344\275\234\345\220\216\346\234\200\345\244\247\345\200\274\344\270\216\346\234\200\345\260\217\345\200\274\347\232\204\346\234\200\345\260\217\345\267\256.md" @@ -46,9 +46,9 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 排序] 输入：nums = [3,100,20] 输出：0 解释：我们最多可以走 3 步。 -第一步，将 100 改为 7 。 nums 变成 [4,7,20] 。 -第二步，将 20 改为 7 。 nums 变成 [4,7,7] 。 -第三步，将 4 改为 3 。 nums 变成 [7,7,7] 。 +第一步，将 100 改为 7 。 nums 变成 [3,7,20] 。 +第二步，将 20 改为 7 。 nums 变成 [3,7,7] 。 +第三步，将 3 改为 7 。 nums 变成 [7,7,7] 。 执行 3 步后，最小值和最大值之间的差值是 7 - 7 = 0。
diff --git "a/AllProblems/1517.\346\237\245\346\211\276\346\213\245\346\234\211\346\234\211\346\225\210\351\202\256\347\256\261\347\232\204\347\224\250\346\210\267.md" "b/AllProblems/1517.\346\237\245\346\211\276\346\213\245\346\234\211\346\234\211\346\225\210\351\202\256\347\256\261\347\232\204\347\224\250\346\210\267.md" index 137ea75d9c5..7b46ac8b39f 100644 --- "a/AllProblems/1517.\346\237\245\346\211\276\346\213\245\346\234\211\346\234\211\346\225\210\351\202\256\347\256\261\347\232\204\347\224\250\346\210\267.md" +++ "b/AllProblems/1517.\346\237\245\346\211\276\346\213\245\346\234\211\346\234\211\346\225\210\351\202\256\347\256\261\347\232\204\347\224\250\346\210\267.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/find-users-with-valid-e-mails/](https://leetcode.cn/problems/find-users-with-valid-e-mails/) -
用户表： Users
+表: Users
+---------------+---------+ @@ -16,30 +16,34 @@ tags: [题解, LeetCode, 简单, 数据库] +---------------+---------+ | user_id | int | | name | varchar | -| mail | varchar | +| mail | varchar | +---------------+---------+ -user_id （用户 ID）是该表的主键。 -这个表包含用户在某网站上注册的信息。有些邮箱是无效的。+user_id 是该表的主键（具有唯一值的列）。 +该表包含了网站已注册用户的信息。有一些电子邮件是无效的。 +
-
写一条 SQL 语句，查询拥有有效邮箱的用户。
+编写一个解决方案，以查找具有有效电子邮件的用户。
+ +一个有效的电子邮件具有前缀名称和域，其中：
-有效的邮箱包含符合下列条件的前缀名和域名：
+'_' ，点 '.' 和/或破折号 '-' 。前缀名称 必须 以字母开头。'@leetcode.com' 。'_'、句点 '.' 和/或横杠 '-' 的字符串。前缀名必须以字母开头。'@leetcode.com' 。以任何顺序返回结果表。
-按任意顺序返回结果表。
+结果的格式如以下示例所示：
-
查询格式如下所示：
+示例 1：
-Users
+输入：
+Users 表:
+---------+-----------+-------------------------+
| user_id | name | mail |
+---------+-----------+-------------------------+
@@ -51,8 +55,7 @@ user_id （用户 ID）是该表的主键。
| 6 | David | david69@gmail.com |
| 7 | Shapiro | .shapo@leetcode.com |
+---------+-----------+-------------------------+
-
-结果表：
+输出：
+---------+-----------+-------------------------+
| user_id | name | mail |
+---------+-----------+-------------------------+
@@ -60,10 +63,11 @@ user_id （用户 ID）是该表的主键。
| 3 | Annabelle | bella-@leetcode.com |
| 4 | Sally | sally.come@leetcode.com |
+---------+-----------+-------------------------+
-2 号用户的邮箱没有域名。
-5 号用户的邮箱包含非法字符 #。
-6 号用户的邮箱的域名不是 leetcode。
-7 号用户的邮箱以句点（.）开头。
+解释：
+用户 2 的电子邮件没有域。
+用户 5 的电子邮件带有不允许的 '#' 符号。
+用户 6 的电子邮件没有 leetcode 域。
+用户 7 的电子邮件以点开头。
diff --git "a/AllProblems/1527.\346\202\243\346\237\220\347\247\215\347\226\276\347\227\205\347\232\204\346\202\243\350\200\205.md" "b/AllProblems/1527.\346\202\243\346\237\220\347\247\215\347\226\276\347\227\205\347\232\204\346\202\243\350\200\205.md"
index 52936820f13..fd9a39a3863 100644
--- "a/AllProblems/1527.\346\202\243\346\237\220\347\247\215\347\226\276\347\227\205\347\232\204\346\202\243\350\200\205.md"
+++ "b/AllProblems/1527.\346\202\243\346\237\220\347\247\215\347\226\276\347\227\205\347\232\204\346\202\243\350\200\205.md"
@@ -18,13 +18,13 @@ tags: [题解, LeetCode, 简单, 数据库]
| patient_name | varchar |
| conditions | varchar |
+--------------+---------+
-patient_id （患者 ID）是该表的主键。
+在 SQL 中，patient_id （患者 ID）是该表的主键。
'conditions' （疾病）包含 0 个或以上的疾病代码，以空格分隔。
这个表包含医院中患者的信息。
-
写一条 SQL 语句，查询患有 I 类糖尿病的患者 ID （patient_id）、患者姓名（patient_name）以及其患有的所有疾病代码（conditions）。I 类糖尿病的代码总是包含前缀 DIAB1 。
查询患有 I 类糖尿病的患者 ID （patient_id）、患者姓名（patient_name）以及其患有的所有疾病代码（conditions）。I 类糖尿病的代码总是包含前缀 DIAB1 。
按 任意顺序 返回结果表。
diff --git "a/AllProblems/1581.\350\277\233\345\272\227\345\215\264\346\234\252\350\277\233\350\241\214\350\277\207\344\272\244\346\230\223\347\232\204\351\241\276\345\256\242.md" "b/AllProblems/1581.\350\277\233\345\272\227\345\215\264\346\234\252\350\277\233\350\241\214\350\277\207\344\272\244\346\230\223\347\232\204\351\241\276\345\256\242.md" index f859a8ca1c4..ae10f624138 100644 --- "a/AllProblems/1581.\350\277\233\345\272\227\345\215\264\346\234\252\350\277\233\350\241\214\350\277\207\344\272\244\346\230\223\347\232\204\351\241\276\345\256\242.md" +++ "b/AllProblems/1581.\350\277\233\345\272\227\345\215\264\346\234\252\350\277\233\350\241\214\350\277\207\344\272\244\346\230\223\347\232\204\351\241\276\345\256\242.md" @@ -17,7 +17,7 @@ tags: [题解, LeetCode, 简单, 数据库] | visit_id | int | | customer_id | int | +-------------+---------+ -visit_id 是该表的主键。 +visit_id 是该表中具有唯一值的列。 该表包含有关光临过购物中心的顾客的信息。 @@ -33,17 +33,17 @@ visit_id 是该表的主键。 | visit_id | int | | amount | int | +----------------+---------+ -transaction_id 是此表的主键。 +transaction_id 是该表中具有唯一值的列。 此表包含 visit_id 期间进行的交易的信息。-
有一些顾客可能光顾了购物中心但没有进行交易。请你编写一个 SQL 查询，来查找这些顾客的 ID ，以及他们只光顾不交易的次数。
+有一些顾客可能光顾了购物中心但没有进行交易。请你编写一个解决方案，来查找这些顾客的 ID ，以及他们只光顾不交易的次数。
返回以 任何顺序 排序的结果表。
-查询结果格式如下例所示。
+返回结果格式如下例所示。
diff --git "a/AllProblems/1587.\351\223\266\350\241\214\350\264\246\346\210\267\346\246\202\350\246\201 II.md" "b/AllProblems/1587.\351\223\266\350\241\214\350\264\246\346\210\267\346\246\202\350\246\201 II.md" index 0b2f3596729..6d2fd49bf01 100644 --- "a/AllProblems/1587.\351\223\266\350\241\214\350\264\246\346\210\267\346\246\202\350\246\201 II.md" +++ "b/AllProblems/1587.\351\223\266\350\241\214\350\264\246\346\210\267\346\246\202\350\246\201 II.md" @@ -10,21 +10,24 @@ tags: [题解, LeetCode, 简单, 数据库]
表: Users
+--------------+---------+ +++--------------+---------+ | Column Name | Type | +--------------+---------+ | account | int | | name | varchar | +--------------+---------+ -account 是该表的主键. -表中的每一行包含银行里中每一个用户的账号. +account 是该表的主键(具有唯一值的列)。 +该表的每一行都包含银行中每个用户的帐号。 +表中不会有两个用户具有相同的名称。
表:
-Transactions+---------------+---------+ +++---------------+---------+ | Column Name | Type | +---------------+---------+ | trans_id | int | @@ -32,23 +35,27 @@ account 是该表的主键. | amount | int | | transacted_on | date | +---------------+---------+ -trans_id 是该表主键. -该表的每一行包含了所有账户的交易改变情况. -如果用户收到了钱, 那么金额是正的; 如果用户转了钱, 那么金额是负的. -所有账户的起始余额为 0. +trans_id 是该表主键(具有唯一值的列)。 +该表的每一行包含了所有账户的交易改变情况。 +如果用户收到了钱, 那么金额是正的; 如果用户转了钱, 那么金额是负的。 +所有账户的起始余额为 0。-
写一个 SQL, 报告余额高于 10000 的所有用户的名字和余额. 账户的余额等于包含该账户的所有交易的总和.
+编写解决方案, 报告余额高于 10000 的所有用户的名字和余额. 账户的余额等于包含该账户的所有交易的总和。
-返回结果表单没有顺序要求.
+返回结果表单 无顺序要求 。
-查询结果格式如下例所示.
+查询结果格式如下例所示。
-
Userstable: +示例 1：
+ ++输入： +Userstable: +------------+--------------+ | account | name | +------------+--------------+ @@ -69,13 +76,13 @@ trans_id 是该表主键. | 6 | 900003 | 6000 | 2020-09-07 | | 7 | 900003 | -4000 | 2020-09-11 | +------------+------------+------------+---------------+ - -Result table: +输出： +------------+------------+ |name|balance| +------------+------------+ | Alice | 11000 | +------------+------------+ +解释： Alice 的余额为(7000 + 7000 - 3000) = 11000. Bob 的余额为1000. Charlie 的余额为(6000 + 6000 - 4000) = 8000. diff --git "a/AllProblems/1625.\346\211\247\350\241\214\346\223\215\344\275\234\345\220\216\345\255\227\345\205\270\345\272\217\346\234\200\345\260\217\347\232\204\345\255\227\347\254\246\344\270\262.md" "b/AllProblems/1625.\346\211\247\350\241\214\346\223\215\344\275\234\345\220\216\345\255\227\345\205\270\345\272\217\346\234\200\345\260\217\347\232\204\345\255\227\347\254\246\344\270\262.md" index 37d9b9d3847..0f255627e6b 100644 --- "a/AllProblems/1625.\346\211\247\350\241\214\346\223\215\344\275\234\345\220\216\345\255\227\345\205\270\345\272\217\346\234\200\345\260\217\347\232\204\345\255\227\347\254\246\344\270\262.md" +++ "b/AllProblems/1625.\346\211\247\350\241\214\346\223\215\344\275\234\345\220\216\345\255\227\345\205\270\345\272\217\346\234\200\345\260\217\347\232\204\345\255\227\347\254\246\344\270\262.md" @@ -13,7 +13,7 @@ tags: [题解, LeetCode, 中等, 广度优先搜索, 字符串]你可以在
s上按任意顺序多次执行下面两个操作之一：
a 加到 s 中所有下标为奇数的元素上（下标从 0 开始）。数字一旦超过 9 就会变成 0，如此循环往复。例如，s = "3456" 且 a = 5，则执行此操作后 s 变成 "3951"。a 加到 s 中所有下标为奇数的元素上（下标从 0 开始）。数字一旦超过 9 就会变成 0，如此循环往复。例如，s = "3456" 且 a = 5，则执行此操作后 s 变成 "3951"。s 向右轮转 b 位。例如，s = "3456" 且 b = 1，则执行此操作后 s 变成 "6345"。如果两个字符串长度相同，那么字符串 a 字典序比字符串 b 小可以这样定义：在 a 和 b 出现不同的第一个位置上，字符串 a 中的字符出现在字母表中的时间早于 b 中的对应字符。例如，"0158” 字典序比 "0190" 小，因为不同的第一个位置是在第三个字符，显然 '5' 出现在 '9' 之前。
+
示例 1：
@@ -37,7 +37,7 @@ tags: [题解, LeetCode, 中等, 广度优先搜索, 字符串] 累加："5222" 累加："5121" 轮转："2151" -累加："2050" +累加："2050" 无法获得字典序小于 "2050" 的字符串。 @@ -50,7 +50,7 @@ tags: [题解, LeetCode, 中等, 广度优先搜索, 字符串] 初态："74" 轮转："47" 累加："42" -轮转："24" +轮转："24" 无法获得字典序小于 "24" 的字符串。 @@ -62,23 +62,16 @@ tags: [题解, LeetCode, 中等, 广度优先搜索, 字符串] 解释：无法获得字典序小于 "0011" 的字符串。 -示例 4：
- --输入：s = "43987654", a = 7, b = 3 -输出："00553311" -- -
+
提示：
2 <= s.length <= 1002 <= s.length <= 100s.length 是偶数s 仅由数字 0 到 9 组成1 <= a <= 91 <= b <= s.length - 11 <= a <= 91 <= b <= s.length - 1@@ -31,16 +31,16 @@ user_id 是该表的主键。 | contest_id | int | | user_id | int | +-------------+---------+ -(contest_id, user_id) 是该表的主键。 +(contest_id, user_id) 是该表的主键(具有唯一值的列的组合)。 该表中的每行包含用户的 ID 和他们注册的赛事。
-
写一条 SQL 语句，查询各赛事的用户注册百分率，保留两位小数。
+编写解决方案统计出各赛事的用户注册百分率，保留两位小数。
返回的结果表按 percentage 的 降序 排序，若相同则按 contest_id 的 升序 排序。
查询结果如下示例所示。
+返回结果如下示例所示。
diff --git "a/AllProblems/164.\346\234\200\345\244\247\351\227\264\350\267\235.md" "b/AllProblems/164.\346\234\200\345\244\247\351\227\264\350\267\235.md" index 2d5336517ac..ac11411cf7e 100644 --- "a/AllProblems/164.\346\234\200\345\244\247\351\227\264\350\267\235.md" +++ "b/AllProblems/164.\346\234\200\345\244\247\351\227\264\350\267\235.md" @@ -1,7 +1,7 @@ --- title: 164.最大间距 date: 2022-06-02 19-55-19 -tags: [题解, LeetCode, 困难, 数组, 桶排序, 基数排序, 排序] +tags: [题解, LeetCode, 中等, 数组, 桶排序, 基数排序, 排序] --- # 【LetMeFly】164.最大间距 diff --git "a/AllProblems/1661.\346\257\217\345\217\260\346\234\272\345\231\250\347\232\204\350\277\233\347\250\213\345\271\263\345\235\207\350\277\220\350\241\214\346\227\266\351\227\264.md" "b/AllProblems/1661.\346\257\217\345\217\260\346\234\272\345\231\250\347\232\204\350\277\233\347\250\213\345\271\263\345\235\207\350\277\220\350\241\214\346\227\266\351\227\264.md" index 0a0242612f3..1db362f5150 100644 --- "a/AllProblems/1661.\346\257\217\345\217\260\346\234\272\345\231\250\347\232\204\350\277\233\347\250\213\345\271\263\345\235\207\350\277\220\350\241\214\346\227\266\351\227\264.md" +++ "b/AllProblems/1661.\346\257\217\345\217\260\346\234\272\345\231\250\347\232\204\350\277\233\347\250\213\345\271\263\345\235\207\350\277\220\350\241\214\346\227\266\351\227\264.md" @@ -19,22 +19,22 @@ tags: [题解, LeetCode, 简单, 数据库] | activity_type | enum | | timestamp | float | +----------------+---------+ -该表展示了一家工厂网站的用户活动. -(machine_id, process_id, activity_type) 是当前表的主键. -machine_id 是一台机器的ID号. -process_id 是运行在各机器上的进程ID号. -activity_type 是枚举类型 ('start', 'end'). -timestamp 是浮点类型,代表当前时间(以秒为单位). -'start' 代表该进程在这台机器上的开始运行时间戳 , 'end' 代表该进程在这台机器上的终止运行时间戳. -同一台机器，同一个进程都有一对开始时间戳和结束时间戳，而且开始时间戳永远在结束时间戳前面. +该表展示了一家工厂网站的用户活动。 +(machine_id, process_id, activity_type) 是当前表的主键（具有唯一值的列的组合）。 +machine_id 是一台机器的ID号。 +process_id 是运行在各机器上的进程ID号。 +activity_type 是枚举类型 ('start', 'end')。 +timestamp 是浮点类型,代表当前时间(以秒为单位)。 +'start' 代表该进程在这台机器上的开始运行时间戳 , 'end' 代表该进程在这台机器上的终止运行时间戳。 +同一台机器，同一个进程都有一对开始时间戳和结束时间戳，而且开始时间戳永远在结束时间戳前面。
-
现在有一个工厂网站由几台机器运行，每台机器上运行着相同数量的进程. 请写出一条SQL计算每台机器各自完成一个进程任务的平均耗时.
+现在有一个工厂网站由几台机器运行，每台机器上运行着 相同数量的进程 。编写解决方案，计算每台机器各自完成一个进程任务的平均耗时。
-完成一个进程任务的时间指进程的'end' 时间戳 减去 'start' 时间戳. 平均耗时通过计算每台机器上所有进程任务的总耗费时间除以机器上的总进程数量获得.
完成一个进程任务的时间指进程的'end' 时间戳 减去 'start' 时间戳。平均耗时通过计算每台机器上所有进程任务的总耗费时间除以机器上的总进程数量获得。
结果表必须包含machine_id（机器ID） 和对应的 average time（平均耗时） 别名 processing_time, 且四舍五入保留3位小数.
结果表必须包含machine_id（机器ID） 和对应的 average time（平均耗时） 别名 processing_time，且四舍五入保留3位小数。
以 任意顺序 返回表。
diff --git "a/AllProblems/1667.\344\277\256\345\244\215\350\241\250\344\270\255\347\232\204\345\220\215\345\255\227.md" "b/AllProblems/1667.\344\277\256\345\244\215\350\241\250\344\270\255\347\232\204\345\220\215\345\255\227.md" index f873665ec27..21c5548c8f2 100644 --- "a/AllProblems/1667.\344\277\256\345\244\215\350\241\250\344\270\255\347\232\204\345\220\215\345\255\227.md" +++ "b/AllProblems/1667.\344\277\256\345\244\215\350\241\250\344\270\255\347\232\204\345\220\215\345\255\227.md" @@ -17,21 +17,21 @@ tags: [题解, LeetCode, 简单, 数据库] | user_id | int | | name | varchar | +----------------+---------+ -user_id 是该表的主键。 +user_id 是该表的主键(具有唯一值的列)。 该表包含用户的 ID 和名字。名字仅由小写和大写字符组成。-
编写一个 SQL 查询来修复名字，使得只有第一个字符是大写的，其余都是小写的。
+编写解决方案，修复名字，使得只有第一个字符是大写的，其余都是小写的。
返回按 user_id 排序的结果表。
查询结果格式示例如下。
+返回结果格式示例如下。
-
示例 1：
+示例 1：
输入： diff --git "a/AllProblems/1683.\346\227\240\346\225\210\347\232\204\346\216\250\346\226\207.md" "b/AllProblems/1683.\346\227\240\346\225\210\347\232\204\346\216\250\346\226\207.md" index 1d23ca77770..263432e7129 100644 --- "a/AllProblems/1683.\346\227\240\346\225\210\347\232\204\346\216\250\346\226\207.md" +++ "b/AllProblems/1683.\346\227\240\346\225\210\347\232\204\346\216\250\346\226\207.md" @@ -10,26 +10,31 @@ tags: [题解, LeetCode, 简单, 数据库]表：
-Tweets+----------------+---------+ +++----------------+---------+ | Column Name | Type | +----------------+---------+ | tweet_id | int | | content | varchar | +----------------+---------+ -tweet_id 是这个表的主键。 +在 SQL 中，tweet_id 是这个表的主键。 这个表包含某社交媒体 App 中所有的推文。-+
-
写一条 SQL 语句，查询所有无效推文的编号（ID）。当推文内容中的字符数严格大于
+15时，该推文是无效的。查询所有无效推文的编号（ID）。当推文内容中的字符数严格大于
15时，该推文是无效的。以任意顺序返回结果表。
-查询结果格式如下示例所示：
+查询结果格式如下所示：
+ +-
+
示例 1：
-Tweets 表： ++输入： +Tweets 表： +----------+----------------------------------+ | tweet_id | content | +----------+----------------------------------+ @@ -37,12 +42,13 @@ tweet_id 是这个表的主键。 | 2 | Let us make America great again! | +----------+----------------------------------+ -结果表： +输出： +----------+ | tweet_id | +----------+ | 2 | +----------+ +解释： 推文 1 的长度 length = 14。该推文是有效的。 推文 2 的长度 length = 32。该推文是无效的。diff --git "a/AllProblems/1693.\346\257\217\345\244\251\347\232\204\351\242\206\345\257\274\345\222\214\345\220\210\344\274\231\344\272\272.md" "b/AllProblems/1693.\346\257\217\345\244\251\347\232\204\351\242\206\345\257\274\345\222\214\345\220\210\344\274\231\344\272\272.md" index 5112eadaf30..c58ce12763a 100644 --- "a/AllProblems/1693.\346\257\217\345\244\251\347\232\204\351\242\206\345\257\274\345\222\214\345\220\210\344\274\231\344\272\272.md" +++ "b/AllProblems/1693.\346\257\217\345\244\251\347\232\204\351\242\206\345\257\274\345\222\214\345\220\210\344\274\231\344\272\272.md" @@ -19,17 +19,17 @@ tags: [题解, LeetCode, 简单, 数据库] | lead_id | int | | partner_id | int | +-------------+---------+ -该表没有主键。 +该表没有主键(具有唯一值的列)。它可能包含重复项。 该表包含日期、产品的名称，以及售给的领导和合伙人的编号。 名称只包含小写英文字母。-
写一条 SQL 语句，使得对于每一个
+date_id和make_name，返回不同的lead_id以及不同的partner_id的数量。对于每一个
date_id和make_name，找出 不同 的lead_id以及 不同 的partner_id的数量。按 任意顺序 返回结果表。
-查询结果格式如下示例所示。
+返回结果格式如下示例所示。
diff --git "a/AllProblems/1696.\350\267\263\350\267\203\346\270\270\346\210\217 VI.md" "b/AllProblems/1696.\350\267\263\350\267\203\346\270\270\346\210\217 VI.md" index 80f3727cc52..935f4edee8d 100644 --- "a/AllProblems/1696.\350\267\263\350\267\203\346\270\270\346\210\217 VI.md" +++ "b/AllProblems/1696.\350\267\263\350\267\203\346\270\270\346\210\217 VI.md" @@ -1,7 +1,7 @@ --- title: 1696.跳跃游戏 VI date: 2022-06-02 20-08-59 -tags: [题解, LeetCode, 中等, 队列, 数组, 动态规划, 滑动窗口, 单调队列, 堆（优先队列）] +tags: [题解, LeetCode, 中等, 队列, 数组, 动态规划, 单调队列, 堆（优先队列）] --- # 【LetMeFly】1696.跳跃游戏 VI diff --git "a/AllProblems/1697.\346\243\200\346\237\245\350\276\271\351\225\277\345\272\246\351\231\220\345\210\266\347\232\204\350\267\257\345\276\204\346\230\257\345\220\246\345\255\230\345\234\250.md" "b/AllProblems/1697.\346\243\200\346\237\245\350\276\271\351\225\277\345\272\246\351\231\220\345\210\266\347\232\204\350\267\257\345\276\204\346\230\257\345\220\246\345\255\230\345\234\250.md" index b84daba0e57..56340f24867 100644 --- "a/AllProblems/1697.\346\243\200\346\237\245\350\276\271\351\225\277\345\272\246\351\231\220\345\210\266\347\232\204\350\267\257\345\276\204\346\230\257\345\220\246\345\255\230\345\234\250.md" +++ "b/AllProblems/1697.\346\243\200\346\237\245\350\276\271\351\225\277\345\272\246\351\231\220\345\210\266\347\232\204\350\267\257\345\276\204\346\230\257\345\220\246\345\255\230\345\234\250.md" @@ -1,7 +1,7 @@ --- title: 1697.检查边长度限制的路径是否存在 date: 2022-06-02 20-09-00 -tags: [题解, LeetCode, 困难, 并查集, 图, 数组, 排序] +tags: [题解, LeetCode, 困难, 并查集, 图, 数组, 双指针, 排序] --- # 【LetMeFly】1697.检查边长度限制的路径是否存在 diff --git "a/AllProblems/1729.\346\261\202\345\205\263\346\263\250\350\200\205\347\232\204\346\225\260\351\207\217.md" "b/AllProblems/1729.\346\261\202\345\205\263\346\263\250\350\200\205\347\232\204\346\225\260\351\207\217.md" index dee75f1899f..fc6731da36c 100644 --- "a/AllProblems/1729.\346\261\202\345\205\263\346\263\250\350\200\205\347\232\204\346\225\260\351\207\217.md" +++ "b/AllProblems/1729.\346\261\202\345\205\263\346\263\250\350\200\205\347\232\204\346\225\260\351\207\217.md" @@ -17,12 +17,12 @@ tags: [题解, LeetCode, 简单, 数据库] | user_id | int | | follower_id | int | +-------------+------+ -(user_id, follower_id) 是这个表的主键。 +(user_id, follower_id) 是这个表的主键（具有唯一值的列的组合）。 该表包含一个关注关系中关注者和用户的编号，其中关注者关注用户。
-
写出 SQL 语句，对于每一个用户，返回该用户的关注者数量。
+编写解决方案，对于每一个用户，返回该用户的关注者数量。
按
diff --git "a/AllProblems/1741.\346\237\245\346\211\276\346\257\217\344\270\252\345\221\230\345\267\245\350\212\261\350\264\271\347\232\204\346\200\273\346\227\266\351\227\264.md" "b/AllProblems/1741.\346\237\245\346\211\276\346\257\217\344\270\252\345\221\230\345\267\245\350\212\261\350\264\271\347\232\204\346\200\273\346\227\266\351\227\264.md" index 6d4fa5078fb..29178f814cd 100644 --- "a/AllProblems/1741.\346\237\245\346\211\276\346\257\217\344\270\252\345\221\230\345\267\245\350\212\261\350\264\271\347\232\204\346\200\273\346\227\266\351\227\264.md" +++ "b/AllProblems/1741.\346\237\245\346\211\276\346\257\217\344\270\252\345\221\230\345\267\245\350\212\261\350\264\271\347\232\204\346\200\273\346\227\266\351\227\264.md" @@ -10,7 +10,8 @@ tags: [题解, LeetCode, 简单, 数据库]user_id的顺序返回结果表。表:
-Employees+-------------+------+ +++-------------+------+ | Column Name | Type | +-------------+------+ | emp_id | int | @@ -18,21 +19,27 @@ tags: [题解, LeetCode, 简单, 数据库] | in_time | int | | out_time | int | +-------------+------+ -(emp_id, event_day, in_time) 是这个表的主键。 +在 SQL 中，(emp_id, event_day, in_time) 是这个表的主键。 该表显示了员工在办公室的出入情况。 event_day 是此事件发生的日期，in_time 是员工进入办公室的时间，而 out_time 是他们离开办公室的时间。 in_time 和 out_time 的取值在1到1440之间。 题目保证同一天没有两个事件在时间上是相交的，并且保证 in_time 小于 out_time。-+
-
编写一个SQL查询以计算每位员工每天在办公室花费的总时间（以分钟为单位）。 请注意，在一天之内，同一员工是可以多次进入和离开办公室的。 在办公室里一次进出所花费的时间为out_time 减去 in_time。
+计算每位员工每天在办公室花费的总时间（以分钟为单位）。 请注意，在一天之内，同一员工是可以多次进入和离开办公室的。 在办公室里一次进出所花费的时间为out_time 减去 in_time。
-返回结果表单的顺序无要求。
+返回结果表单的顺序无要求。
-
查询结果的格式如下：Employees table: ++ +
示例 1：
+ ++输入： +Employees table: +--------+------------+---------+----------+ | emp_id | event_day | in_time | out_time | +--------+------------+---------+----------+ @@ -42,7 +49,7 @@ in_time 和 out_time 的取值在1到1440之间。 | 2 | 2020-11-28 | 3 | 33 | | 2 | 2020-12-09 | 47 | 74 | +--------+------------+---------+----------+ -Result table: +输出： +------------+--------+------------+ | day | emp_id | total_time | +------------+--------+------------+ @@ -51,6 +58,7 @@ Result table: | 2020-12-03 | 1 | 41 | | 2020-12-09 | 2 | 27 | +------------+--------+------------+ +解释： 雇员 1 有三次进出: 有两次发生在 2020-11-28 花费的时间为 (32 - 4) + (200 - 55) = 173, 有一次发生在 2020-12-03 花费的时间为 (42 - 1) = 41。 雇员 2 有两次进出: 有一次发生在 2020-11-28 花费的时间为 (33 - 3) = 30, 有一次发生在 2020-12-09 花费的时间为 (74 - 47) = 27。diff --git "a/AllProblems/1745.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 IV.md" "b/AllProblems/1745.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 IV.md" new file mode 100644 index 00000000000..e27793e627c --- /dev/null +++ "b/AllProblems/1745.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 IV.md" @@ -0,0 +1,43 @@ +--- +title: 1745.分割回文串 IV +date: 2023-10-10 14-32-02 +tags: [题解, LeetCode, 困难, 字符串, 动态规划] +--- + +# 【LetMeFly】1745.分割回文串 IV + +力扣题目链接：[https://leetcode.cn/problems/palindrome-partitioning-iv/](https://leetcode.cn/problems/palindrome-partitioning-iv/) + +给你一个字符串
+ +s，如果可以将它分割成三个 非空 回文子字符串，那么返回true，否则返回false。当一个字符串正着读和反着读是一模一样的，就称其为 回文字符串 。
+ ++ +
示例 1：
+ ++输入：s = "abcbdd" +输出：true +解释："abcbdd" = "a" + "bcb" + "dd"，三个子字符串都是回文的。 ++ +示例 2：
+ ++输入：s = "bcbddxy" +输出：false +解释：s 没办法被分割成 3 个回文子字符串。 ++ ++ +
提示：
+ +
3 <= s.length <= 2000s 只包含小写英文字母。编写一个SQL查询来报告 Person 表中每个人的姓、名、城市和州。如果 personId 的地址不在 Address 表中，则报告为空 null 。
+ +
编写解决方案，报告 Person 表中每个人的姓、名、城市和州。如果 personId 的地址不在 Address 表中，则报告为 null 。
以 任意顺序 返回结果表。
-查询结果格式如下所示。
+结果格式如下所示。
diff --git "a/AllProblems/1757.\345\217\257\345\233\236\346\224\266\344\270\224\344\275\216\350\204\202\347\232\204\344\272\247\345\223\201.md" "b/AllProblems/1757.\345\217\257\345\233\236\346\224\266\344\270\224\344\275\216\350\204\202\347\232\204\344\272\247\345\223\201.md" index db2e711e4ac..02378bde764 100644 --- "a/AllProblems/1757.\345\217\257\345\233\236\346\224\266\344\270\224\344\275\216\350\204\202\347\232\204\344\272\247\345\223\201.md" +++ "b/AllProblems/1757.\345\217\257\345\233\236\346\224\266\344\270\224\344\275\216\350\204\202\347\232\204\344\272\247\345\223\201.md" @@ -18,19 +18,24 @@ tags: [题解, LeetCode, 简单, 数据库] | low_fats | enum | | recyclable | enum | +-------------+---------+ -product_id 是这个表的主键。 +
product_id 是该表的主键（具有唯一值的列）。
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。
recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。
-+
-
写出 SQL 语句，查找既是低脂又是可回收的产品编号。
+编写解决方案找出既是低脂又是可回收的产品编号。
返回结果 无顺序要求 。
-查询结果格式如下例所示：
+返回结果格式如下例所示：
+ ++ +
示例 1：
+输入： Products 表： +-------------+----------+------------+ | product_id | low_fats | recyclable | @@ -41,13 +46,14 @@ Products 表： | 3 | Y | Y | | 4 | N | N | +-------------+----------+------------+ -Result 表： +输出： +-------------+ | product_id | +-------------+ | 1 | | 3 | +-------------+ +解释： 只有产品 id 为 1 和 3 的产品，既是低脂又是可回收的产品。diff --git "a/AllProblems/176.\347\254\254\344\272\214\351\253\230\347\232\204\350\226\252\346\260\264.md" "b/AllProblems/176.\347\254\254\344\272\214\351\253\230\347\232\204\350\226\252\346\260\264.md" index 56162022b4e..7679c3fc339 100644 --- "a/AllProblems/176.\347\254\254\344\272\214\351\253\230\347\232\204\350\226\252\346\260\264.md" +++ "b/AllProblems/176.\347\254\254\344\272\214\351\253\230\347\232\204\350\226\252\346\260\264.md" @@ -18,13 +18,13 @@ tags: [题解, LeetCode, 中等, 数据库] | id | int | | salary | int | +-------------+------+ -id 是这个表的主键。 +在 SQL 中，id 是这个表的主键。 表的每一行包含员工的工资信息。
-
编写一个 SQL 查询，获取并返回 Employee 表中第二高的薪水 。如果不存在第二高的薪水，查询应该返回 null 。
查询并返回 Employee 表中第二高的薪水 。如果不存在第二高的薪水，查询应该返回 null(Pandas 则返回 None) 。
查询结果如下例所示。
diff --git "a/AllProblems/177.\347\254\254N\351\253\230\347\232\204\350\226\252\346\260\264.md" "b/AllProblems/177.\347\254\254N\351\253\230\347\232\204\350\226\252\346\260\264.md" index f6e37ea6e4b..fa9ea30a05d 100644 --- "a/AllProblems/177.\347\254\254N\351\253\230\347\232\204\350\226\252\346\260\264.md" +++ "b/AllProblems/177.\347\254\254N\351\253\230\347\232\204\350\226\252\346\260\264.md" @@ -17,13 +17,13 @@ tags: [题解, LeetCode, 中等, 数据库] | id | int | | salary | int | +-------------+------+ -Id是该表的主键列。 +在 SQL 中，id 是该表的主键。 该表的每一行都包含有关员工工资的信息。-
编写一个SQL查询来报告 Employee 表中第 n 高的工资。如果没有第 n 个最高工资，查询应该报告为 null 。
查询 Employee 表中第 n 高的工资。如果没有第 n 个最高工资，查询结果应该为 null 。
查询结果格式如下所示。
diff --git "a/AllProblems/178.\345\210\206\346\225\260\346\216\222\345\220\215.md" "b/AllProblems/178.\345\210\206\346\225\260\346\216\222\345\220\215.md" index 2c261127c4e..ef158c2ed46 100644 --- "a/AllProblems/178.\345\210\206\346\225\260\346\216\222\345\220\215.md" +++ "b/AllProblems/178.\345\210\206\346\225\260\346\216\222\345\220\215.md" @@ -17,13 +17,13 @@ tags: [题解, LeetCode, 中等, 数据库] | id | int | | score | decimal | +-------------+---------+ -Id是该表的主键。 -该表的每一行都包含了一场比赛的分数。Score是一个有两位小数点的浮点值。 +在 SQL 中，id 是该表的主键。 +该表的每一行都包含了一场比赛的分数。Score 是一个有两位小数点的浮点值。-
编写 SQL 查询对分数进行排序。排名按以下规则计算:
+查询并对分数进行排序。排名按以下规则计算:
给你一个无向图，无向图由整数 n ，表示图中节点的数目，和 edges 组成，其中 edges[i] = [ui, vi] 表示 ui 和 vi 之间有一条无向边。同时给你一个代表查询的整数数组 queries 。
给你一个无向图，无向图由整数 n ，表示图中节点的数目，和 edges 组成，其中 edges[i] = [ui, vi] 表示 ui 和 vi 之间有一条无向边。同时给你一个代表查询的整数数组 queries 。
第 j 个查询的答案是满足如下条件的点对 (a, b) 的数目：
a < bcnt 是与 a 或者 b 相连的边的数目，且 cnt 严格大于 queries[j] 。a < bcnt 是与 a 或者 b 相连的边的数目，且 cnt 严格大于 queries[j] 。请你返回一个数组 answers ，其中 answers.length == queries.length 且 answers[j] 是第 j 个查询的答案。
请你返回一个数组 answers ，其中 answers.length == queries.length 且 answers[j] 是第 j 个查询的答案。
请注意，图中可能会有 重复边 。
+请注意，图中可能会有 多重边 。
-+
示例 1：
-
+
+
输入：n = 4, edges = [[1,2],[2,4],[1,3],[2,3],[2,1]], queries = [2,3] 输出：[6,5] 解释：每个点对中，与至少一个点相连的边的数目如上图所示。 +answers[0] = 6。所有的点对(a, b)中边数和都大于2，故有6个； +answers[1] = 5。所有的点对(a, b)中除了(3,4)边数等于3，其它点对边数和都大于3，故有5个。
示例 2：
@@ -38,17 +42,17 @@ tags: [题解, LeetCode, 困难, 图, 双指针, 二分查找] 输出：[10,10,9,8,6] -+
提示：
2 <= n <= 2 * 1041 <= edges.length <= 1051 <= ui, vi <= n2 <= n <= 2 * 1041 <= edges.length <= 1051 <= ui, vi <= nui != vi1 <= queries.length <= 200 <= queries[j] < edges.length1 <= queries.length <= 200 <= queries[j] < edges.lengthTable: Employee
表：Employee
+---------------+---------+ +++---------------+---------+ | Column Name | Type | +---------------+---------+ | employee_id | int | | department_id | int | | primary_flag | varchar | +---------------+---------+ -这张表的主键为 employee_id, department_id +这张表的主键为 employee_id, department_id (具有唯一值的列的组合) employee_id 是员工的ID department_id 是部门的ID，表示员工与该部门有关系 primary_flag 是一个枚举类型，值分别为('Y', 'N'). 如果值为'Y',表示该部门是员工的直属部门。 如果值是'N',则否-- -
一个员工可以属于多个部门。
+-
当一个员工加入超过一个部门的时候，他需要决定哪个部门是他的直属部门。
+一个员工可以属于多个部门。当一个员工加入超过一个部门的时候，他需要决定哪个部门是他的直属部门。请注意，当员工只加入一个部门的时候，那这个部门将默认为他的直属部门，虽然表记录的值为
-'N'.请注意，当员工只加入一个部门的时候，那这个部门将默认为他的直属部门，虽然表记录的值为
+'N'.请编写解决方案，查出员工所属的直属部门。
-请编写一段SQL，查出员工所属的直属部门。
+返回结果 没有顺序要求 。
-返回结果没有顺序要求。
+返回结果格式如下例子所示：
-+
-
示例：
+示例 1：
-Employee table: +-+输入： +Employee table: +-------------+---------------+--------------+ | employee_id | department_id | primary_flag | +-------------+---------------+--------------+ @@ -51,8 +52,7 @@ primary_flag 是一个枚举类型，值分别为('Y', 'N'). 如果值为'Y',表 | 4 | 3 | Y | | 4 | 4 | N | +-------------+---------------+--------------+ - -Result table: +输出： +-------------+---------------+ | employee_id | department_id | +-------------+---------------+ @@ -61,12 +61,13 @@ Result table: | 3 | 3 | | 4 | 3 | +-------------+---------------+ -- 员工1的直属部门是1 -- 员工2的直属部门是1 -- 员工3的直属部门是3 -- 员工4的直属部门是3+解释： +- 员工 1 的直属部门是 1 +- 员工 2 的直属部门是 1 +- 员工 3 的直属部门是 3 +- 员工 4 的直属部门是 3+
\ No newline at end of file diff --git "a/AllProblems/1795.\346\257\217\344\270\252\344\272\247\345\223\201\345\234\250\344\270\215\345\220\214\345\225\206\345\272\227\347\232\204\344\273\267\346\240\274.md" "b/AllProblems/1795.\346\257\217\344\270\252\344\272\247\345\223\201\345\234\250\344\270\215\345\220\214\345\225\206\345\272\227\347\232\204\344\273\267\346\240\274.md" index ec9c8b1f568..aa1c0d571f4 100644 --- "a/AllProblems/1795.\346\257\217\344\270\252\344\272\247\345\223\201\345\234\250\344\270\215\345\220\214\345\225\206\345\272\227\347\232\204\344\273\267\346\240\274.md" +++ "b/AllProblems/1795.\346\257\217\344\270\252\344\272\247\345\223\201\345\234\250\344\270\215\345\220\214\345\225\206\345\272\227\347\232\204\344\273\267\346\240\274.md" @@ -19,9 +19,9 @@ tags: [题解, LeetCode, 简单, 数据库] | store2 | int | | store3 | int | +-------------+---------+ -这张表的主键是product_id（产品Id）。 -每行存储了这一产品在不同商店store1, store2, store3的价格。 -如果这一产品在商店里没有出售，则值将为null。 +在 SQL 中，这张表的主键是 product_id（产品Id）。 +每行存储了这一产品在不同商店 store1, store2, store3 的价格。 +如果这一产品在商店里没有出售，则值将为 null。
@@ -56,8 +56,8 @@ Products table: | 1 | store3 | 80 | +------------+--------+-------+ 解释： -产品0在store1，store2,store3的价格分别为95,100,105。 -产品1在store1，store3的价格分别为70,80。在store2无法买到。 +产品 0 在 store1、store2、store3 的价格分别为 95、100、105。 +产品 1 在 store1、store3 的价格分别为 70、80。在 store2 无法买到。 \ No newline at end of file diff --git "a/AllProblems/180.\350\277\236\347\273\255\345\207\272\347\216\260\347\232\204\346\225\260\345\255\227.md" "b/AllProblems/180.\350\277\236\347\273\255\345\207\272\347\216\260\347\232\204\346\225\260\345\255\227.md" index fc975ea06df..3a538258510 100644 --- "a/AllProblems/180.\350\277\236\347\273\255\345\207\272\347\216\260\347\232\204\346\225\260\345\255\227.md" +++ "b/AllProblems/180.\350\277\236\347\273\255\345\207\272\347\216\260\347\232\204\346\225\260\345\255\227.md" @@ -17,15 +17,16 @@ tags: [题解, LeetCode, 中等, 数据库] | id | int | | num | varchar | +-------------+---------+ -id 是这个表的主键。 +在 SQL 中，id 是该表的主键。 +id 是一个自增列。
-
编写一个 SQL 查询，查找所有至少连续出现三次的数字。
+找出所有至少连续出现三次的数字。
返回的结果表中的数据可以按 任意顺序 排列。
-查询结果格式如下面的例子所示：
+结果格式如下面的例子所示：
@@ -35,7 +36,7 @@ id 是这个表的主键。 输入： Logs 表： +----+-----+ -| Id | Num | +| id | num | +----+-----+ | 1 | 1 | | 2 | 1 | diff --git "a/AllProblems/181.\350\266\205\350\277\207\347\273\217\347\220\206\346\224\266\345\205\245\347\232\204\345\221\230\345\267\245.md" "b/AllProblems/181.\350\266\205\350\277\207\347\273\217\347\220\206\346\224\266\345\205\245\347\232\204\345\221\230\345\267\245.md" index 456eb715b88..26502ceb542 100644 --- "a/AllProblems/181.\350\266\205\350\277\207\347\273\217\347\220\206\346\224\266\345\205\245\347\232\204\345\221\230\345\267\245.md" +++ "b/AllProblems/181.\350\266\205\350\277\207\347\273\217\347\220\206\346\224\266\345\205\245\347\232\204\345\221\230\345\267\245.md" @@ -19,17 +19,17 @@ tags: [题解, LeetCode, 简单, 数据库] | salary | int | | managerId | int | +-------------+---------+ -Id是该表的主键。 +id 是该表的主键（具有唯一值的列）。 该表的每一行都表示雇员的ID、姓名、工资和经理的ID。
-
编写一个SQL查询来查找收入比经理高的员工。
+编写解决方案，找出收入比经理高的员工。
以 任意顺序 返回结果表。
-查询结果格式如下所示。
+结果格式如下所示。
diff --git "a/AllProblems/182.\346\237\245\346\211\276\351\207\215\345\244\215\347\232\204\347\224\265\345\255\220\351\202\256\347\256\261.md" "b/AllProblems/182.\346\237\245\346\211\276\351\207\215\345\244\215\347\232\204\347\224\265\345\255\220\351\202\256\347\256\261.md" index 427911d58ce..a2760e3091c 100644 --- "a/AllProblems/182.\346\237\245\346\211\276\351\207\215\345\244\215\347\232\204\347\224\265\345\255\220\351\202\256\347\256\261.md" +++ "b/AllProblems/182.\346\237\245\346\211\276\351\207\215\345\244\215\347\232\204\347\224\265\345\255\220\351\202\256\347\256\261.md" @@ -19,17 +19,17 @@ tags: [题解, LeetCode, 简单, 数据库] | id | int | | email | varchar | +-------------+---------+ -id 是该表的主键列。 +id 是该表的主键（具有唯一值的列）。 此表的每一行都包含一封电子邮件。电子邮件不包含大写字母。
-
编写一个 SQL 查询来报告所有重复的电子邮件。 请注意，可以保证电子邮件字段不为 NULL。
+编写解决方案来报告所有重复的电子邮件。 请注意，可以保证电子邮件字段不为 NULL。
以 任意顺序 返回结果表。
-查询结果格式如下例。
+结果格式如下例。
diff --git "a/AllProblems/183.\344\273\216\344\270\215\350\256\242\350\264\255\347\232\204\345\256\242\346\210\267.md" "b/AllProblems/183.\344\273\216\344\270\215\350\256\242\350\264\255\347\232\204\345\256\242\346\210\267.md" index 60f8557cb76..83893e23420 100644 --- "a/AllProblems/183.\344\273\216\344\270\215\350\256\242\350\264\255\347\232\204\345\256\242\346\210\267.md" +++ "b/AllProblems/183.\344\273\216\344\270\215\350\256\242\350\264\255\347\232\204\345\256\242\346\210\267.md" @@ -8,39 +8,68 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/customers-who-never-order/](https://leetcode.cn/problems/customers-who-never-order/) -
某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。
Customers 表：
+----+-------+ -| Id | Name | +\ No newline at end of file diff --git "a/AllProblems/184.\351\203\250\351\227\250\345\267\245\350\265\204\346\234\200\351\253\230\347\232\204\345\221\230\345\267\245.md" "b/AllProblems/184.\351\203\250\351\227\250\345\267\245\350\265\204\346\234\200\351\253\230\347\232\204\345\221\230\345\267\245.md" index 810b38b906b..37f67cdf30a 100644 --- "a/AllProblems/184.\351\203\250\351\227\250\345\267\245\350\265\204\346\234\200\351\253\230\347\232\204\345\221\230\345\267\245.md" +++ "b/AllProblems/184.\351\203\250\351\227\250\345\267\245\350\265\204\346\234\200\351\253\230\347\232\204\345\221\230\345\267\245.md" @@ -19,9 +19,9 @@ tags: [题解, LeetCode, 中等, 数据库] | salary | int | | departmentId | int | +--------------+---------+ -id是此表的主键列。 -departmentId是Department表中ID的外键。 -此表的每一行都表示员工的ID、姓名和工资。它还包含他们所在部门的ID。 +在 SQL 中，id是此表的主键。 +departmentId 是 Department 表中 id 的外键（在 Pandas 中称为 join key）。 +此表的每一行都表示员工的 id、姓名和工资。它还包含他们所在部门的 id。++-------------+---------+ +| Column Name | Type | ++-------------+---------+ +| id | int | +| name | varchar | ++-------------+---------+ +在 SQL 中，id 是该表的主键。 +该表的每一行都表示客户的 ID 和名称。+ ++ +
Orders表：++-------------+------+ +| Column Name | Type | ++-------------+------+ +| id | int | +| customerId | int | ++-------------+------+ +在 SQL 中，id 是该表的主键。 +customerId 是 Customers 表中 ID 的外键( Pandas 中的连接键)。 +该表的每一行都表示订单的 ID 和订购该订单的客户的 ID。+ ++ +
找出所有从不点任何东西的顾客。
+ +以 任意顺序 返回结果表。
+ +结果格式如下所示。
+ ++ +
示例 1：
+ ++输入： +Customers table: ++----+-------+ +| id | name | +----+-------+ | 1 | Joe | | 2 | Henry | | 3 | Sam | | 4 | Max | +----+-------+ -- -- -
Orders表：+----+------------+ -| Id | CustomerId | +Orders table: ++----+------------+ +| id | customerId | +----+------------+ | 1 | 3 | | 2 | 1 | +----+------------+ -- -例如给定上述表格，你的查询应返回：
- -+-----------+ +输出： ++-----------+ | Customers | +-----------+ | Henry | | Max | -+-----------+ -++-----------+
@@ -35,13 +35,13 @@ departmentId是Department表中ID的外键。 | id | int | | name | varchar | +-------------+---------+ -id是此表的主键列。 -此表的每一行都表示一个部门的ID及其名称。 +在 SQL 中，id 是此表的主键列。 +此表的每一行都表示一个部门的 id 及其名称。
-
编写SQL查询以查找每个部门中薪资最高的员工。
+
查找出每个部门中薪资最高的员工。
按 任意顺序 返回结果表。
查询结果格式如下例所示。
公司的主管们感兴趣的是公司每个部门中谁赚的钱最多。一个部门的 高收入者 是指一个员工的工资在该部门的 不同 工资中 排名前三 。
-编写一个SQL查询，找出每个部门中 收入高的员工 。
+编写解决方案，找出每个部门中 收入高的员工 。
以 任意顺序 返回结果表。
-查询结果格式如下所示。
+返回结果格式如下所示。
diff --git "a/AllProblems/1851.\345\214\205\345\220\253\346\257\217\344\270\252\346\237\245\350\257\242\347\232\204\346\234\200\345\260\217\345\214\272\351\227\264.md" "b/AllProblems/1851.\345\214\205\345\220\253\346\257\217\344\270\252\346\237\245\350\257\242\347\232\204\346\234\200\345\260\217\345\214\272\351\227\264.md" index dadbdd50193..fa7df4dc35b 100644 --- "a/AllProblems/1851.\345\214\205\345\220\253\346\257\217\344\270\252\346\237\245\350\257\242\347\232\204\346\234\200\345\260\217\345\214\272\351\227\264.md" +++ "b/AllProblems/1851.\345\214\205\345\220\253\346\257\217\344\270\252\346\237\245\350\257\242\347\232\204\346\234\200\345\260\217\345\214\272\351\227\264.md" @@ -10,11 +10,11 @@ tags: [题解, LeetCode, 困难, 数组, 二分查找, 排序, 扫描线, 堆（
给你一个二维整数数组 intervals ，其中 intervals[i] = [lefti, righti] 表示第 i 个区间开始于 lefti 、结束于 righti（包含两侧取值，闭区间）。区间的 长度 定义为区间中包含的整数数目，更正式地表达是 righti - lefti + 1 。
再给你一个整数数组 queries 。第 j 个查询的答案是满足 lefti <= queries[j] <= righti 的 长度最小区间 i 的长度 。如果不存在这样的区间，那么答案是 -1 。
再给你一个整数数组 queries 。第 j 个查询的答案是满足 lefti <= queries[j] <= righti 的 长度最小区间 i 的长度 。如果不存在这样的区间，那么答案是 -1 。
以数组形式返回对应查询的所有答案。
-+
示例 1：
@@ -40,16 +40,16 @@ tags: [题解, LeetCode, 困难, 数组, 二分查找, 排序, 扫描线, 堆（ - Query = 22：区间 [20,25] 是包含 22 的最小区间，答案为 25 - 20 + 1 = 6 。 -+
提示：
1 <= intervals.length <= 1051 <= queries.length <= 105queries[i].length == 21 <= lefti <= righti <= 1071 <= queries[j] <= 1071 <= intervals.length <= 1051 <= queries.length <= 105intervals[i].length == 21 <= lefti <= righti <= 1071 <= queries[j] <= 107-
写出一个SQL 查询语句，计算每个雇员的奖金。如果一个雇员的id是奇数并且他的名字不是以'M'开头，那么他的奖金是他工资的100%，否则奖金为0。
+编写解决方案，计算每个雇员的奖金。如果一个雇员的 id 是 奇数 并且他的名字不是以 'M' 开头，那么他的奖金是他工资的 100% ，否则奖金为 0 。
Return the result table ordered by employee_id.
返回的结果按照 employee_id 排序。
返回的结果集请按照employee_id排序。
查询结果格式如下面的例子所示。
+返回结果格式如下面的例子所示。
-
示例 1:
+示例 1:
输入： diff --git "a/AllProblems/188.\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 IV.md" "b/AllProblems/188.\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 IV.md" index 5a899053694..25e06413bd5 100644 --- "a/AllProblems/188.\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 IV.md" +++ "b/AllProblems/188.\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 IV.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 困难, 数组, 动态规划] 力扣题目链接：[https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/) -给定一个整数数组
+prices，它的第i个元素prices[i]是一支给定的股票在第i天的价格，和一个整型k。给你一个整数数组
prices和一个整数k，其中prices[i]是某支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成
@@ -36,8 +36,8 @@ tags: [题解, LeetCode, 困难, 数组, 动态规划]k笔交易。也就是说，你最多可以买k次，卖k次。提示：
0 <= k <= 1000 <= prices.length <= 10001 <= k <= 1001 <= prices.length <= 10000 <= prices[i] <= 1000-
编写一个 SQL 查询，该查询可以获取在 2020 年登录过的所有用户的本年度 最后一次 登录时间。结果集 不 包含 2020 年没有登录过的用户。
编写解决方案以获取在 2020 年登录过的所有用户的本年度 最后一次 登录时间。结果集 不 包含 2020 年没有登录过的用户。
返回的结果集可以按 任意顺序 排列。
-查询结果格式如下例。
+返回结果格式如下例。
diff --git "a/AllProblems/1907.\346\214\211\345\210\206\347\261\273\347\273\237\350\256\241\350\226\252\346\260\264.md" "b/AllProblems/1907.\346\214\211\345\210\206\347\261\273\347\273\237\350\256\241\350\226\252\346\260\264.md" index 10391004d6e..60ea8af59d8 100644 --- "a/AllProblems/1907.\346\214\211\345\210\206\347\261\273\347\273\237\350\256\241\350\226\252\346\260\264.md" +++ "b/AllProblems/1907.\346\214\211\345\210\206\347\261\273\347\273\237\350\256\241\350\226\252\346\260\264.md" @@ -17,13 +17,13 @@ tags: [题解, LeetCode, 中等, 数据库] | account_id | int | | income | int | +-------------+------+ -account_id 是这个表的主键。 +在 SQL 中，account_id 是这个表的主键。 每一行都包含一个银行帐户的月收入的信息。
-
写出一个 SQL 查询，来报告每个工资类别的银行账户数量。 工资类别如下：
+查询每个工资类别的银行账户数量。 工资类别如下：
"Low Salary"：所有工资 严格低于 20000 美元。-
编写一个 SQL 删除语句来 删除 所有重复的电子邮件，只保留一个id最小的唯一电子邮件。
+编写解决方案 删除 所有重复的电子邮件，只保留一个具有最小 id 的唯一电子邮件。
以 任意顺序 返回结果表。 （注意： 仅需要写删除语句，将自动对剩余结果进行查询）
+（对于 SQL 用户，请注意你应该编写一个 DELETE 语句而不是 SELECT 语句。）
查询结果格式如下所示。
+（对于 Pandas 用户，请注意你应该直接修改 Person 表。）
+
运行脚本后，显示的答案是 Person 表。驱动程序将首先编译并运行您的代码片段，然后再显示 Person 表。Person 表的最终顺序 无关紧要 。
返回结果格式如下示例所示。
-
示例 1:
+示例 1:
输入: diff --git "a/AllProblems/1965.\344\270\242\345\244\261\344\277\241\346\201\257\347\232\204\351\233\207\345\221\230.md" "b/AllProblems/1965.\344\270\242\345\244\261\344\277\241\346\201\257\347\232\204\351\233\207\345\221\230.md" index 7bf188abdb6..bbaece121a0 100644 --- "a/AllProblems/1965.\344\270\242\345\244\261\344\277\241\346\201\257\347\232\204\351\233\207\345\221\230.md" +++ "b/AllProblems/1965.\344\270\242\345\244\261\344\277\241\346\201\257\347\232\204\351\233\207\345\221\230.md" @@ -17,7 +17,7 @@ tags: [题解, LeetCode, 简单, 数据库] | employee_id | int | | name | varchar | +-------------+---------+ -employee_id 是这个表的主键。 +employee_id 是该表中具有唯一值的列。 每一行表示雇员的id 和他的姓名。@@ -30,13 +30,13 @@ employee_id 是这个表的主键。 | employee_id | int | | salary | int | +-------------+---------+ -employee_id is 这个表的主键。 +employee_id is 是该表中具有唯一值的列。 每一行表示雇员的id 和他的薪水。
-
写出一个查询语句，找到所有 丢失信息 的雇员id。当满足下面一个条件时，就被认为是雇员的信息丢失：
+编写解决方案，找到所有 丢失信息 的雇员 id。当满足下面一个条件时，就被认为是雇员的信息丢失：
-
编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 id 。
编写解决方案，找出与之前（昨天的）日期相比温度更高的所有日期的 id 。
返回结果 不要求顺序 。
+返回结果 无顺序要求 。
-查询结果格式如下例。
+结果格式如下例子所示。
-
示例 1：
+示例 1：
输入：
diff --git "a/AllProblems/1978.\344\270\212\347\272\247\347\273\217\347\220\206\345\267\262\347\246\273\350\201\214\347\232\204\345\205\254\345\217\270\345\221\230\345\267\245.md" "b/AllProblems/1978.\344\270\212\347\272\247\347\273\217\347\220\206\345\267\262\347\246\273\350\201\214\347\232\204\345\205\254\345\217\270\345\221\230\345\267\245.md"
index a099072a466..718d20d5e55 100644
--- "a/AllProblems/1978.\344\270\212\347\272\247\347\273\217\347\220\206\345\267\262\347\246\273\350\201\214\347\232\204\345\205\254\345\217\270\345\221\230\345\267\245.md"
+++ "b/AllProblems/1978.\344\270\212\347\272\247\347\273\217\347\220\206\345\267\262\347\246\273\350\201\214\347\232\204\345\205\254\345\217\270\345\221\230\345\267\245.md"
@@ -19,14 +19,14 @@ tags: [题解, LeetCode, 简单, 数据库]
| manager_id | int |
| salary | int |
+-------------+----------+
-employee_id 是这个表的主键。
+在 SQL 中，employee_id 是这个表的主键。
这个表包含了员工，他们的薪水和上级经理的id。
-有一些员工没有上级经理（其manager_id 是空值）。
+有一些员工没有上级经理（其 manager_id 是空值）。
-
写一个查询语句，查询出，这些员工的id，他们的薪水严格少于$30000 并且他们的上级经理已离职。当一个经理离开公司时，他们的信息需要从员工表中删除掉，但是表中的员工的manager_id 这一列还是设置的离职经理的id 。
查找这些员工的id，他们的薪水严格少于$30000 并且他们的上级经理已离职。当一个经理离开公司时，他们的信息需要从员工表中删除掉，但是表中的员工的manager_id 这一列还是设置的离职经理的id 。
返回的结果按照employee_id 从小到大排序。
Robot(int width, int height) 初始化一个 width x height 的网格图，机器人初始在 (0, 0) ，方向朝 "East" 。void move(int num) 给机器人下达前进 num 步的指令。void step(int num) 给机器人下达前进 num 步的指令。int[] getPos() 返回机器人当前所处的格子位置，用一个长度为 2 的数组 [x, y] 表示。String getDir() 返回当前机器人的朝向，为 "North" ，"East" ，"South" 或者 "West" 。示例 1：
-
输入：
-["Robot", "move", "move", "getPos", "getDir", "move", "move", "move", "getPos", "getDir"]
+
+输入：
+["Robot", "step", "step", "getPos", "getDir", "step", "step", "step", "getPos", "getDir"]
[[6, 3], [2], [2], [], [], [2], [1], [4], [], []]
输出：
[null, null, null, [4, 0], "East", null, null, null, [1, 2], "West"]
解释：
Robot robot = new Robot(6, 3); // 初始化网格图，机器人在 (0, 0) ，朝东。
-robot.move(2); // 机器人朝东移动 2 步，到达 (2, 0) ，并朝东。
-robot.move(2); // 机器人朝东移动 2 步，到达 (4, 0) ，并朝东。
+robot.step(2); // 机器人朝东移动 2 步，到达 (2, 0) ，并朝东。
+robot.step(2); // 机器人朝东移动 2 步，到达 (4, 0) ，并朝东。
robot.getPos(); // 返回 [4, 0]
robot.getDir(); // 返回 "East"
-robot.move(2); // 朝东移动 1 步到达 (5, 0) ，并朝东。
+robot.step(2); // 朝东移动 1 步到达 (5, 0) ，并朝东。
// 下一步继续往东移动将出界，所以逆时针转变方向朝北。
// 然后，往北移动 1 步到达 (5, 1) ，并朝北。
-robot.move(1); // 朝北移动 1 步到达 (5, 2) ，并朝 北 （不是朝西）。
-robot.move(4); // 下一步继续往北移动将出界，所以逆时针转变方向朝西。
+robot.step(1); // 朝北移动 1 步到达 (5, 2) ，并朝 北 （不是朝西）。
+robot.step(4); // 下一步继续往北移动将出界，所以逆时针转变方向朝西。
// 然后，移动 4 步到 (1, 2) ，并朝西。
robot.getPos(); // 返回 [1, 2]
robot.getDir(); // 返回 "West"
@@ -64,7 +65,7 @@ robot.getDir(); // 返回 "West"
2 <= width, height <= 1001 <= num <= 105move ，getPos 和 getDir 总共 调用次数不超过 104 次。step ，getPos 和 getDir 总共 调用次数不超过 104 次。你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。
[0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。[0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
+
示例 1：
@@ -34,15 +34,15 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 图, 输出：false 解释：总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。 -+
提示：
1 <= numCourses <= 1050 <= prerequisites.length <= 50001 <= numCourses <= 20000 <= prerequisites.length <= 5000prerequisites[i].length == 20 <= ai, bi < numCourses0 <= ai, bi < numCoursesprerequisites[i] 中的所有课程对 互不相同给定一个含有 n 个正整数的数组和一个正整数 target 。
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
+
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3] 输出：2 -解释：子数组[4,3]是该条件下的长度最小的子数组。 +解释：子数组[4,3]是该条件下的长度最小的子数组。
示例 2：
@@ -36,17 +36,17 @@ tags: [题解, LeetCode, 中等, 数组, 二分查找, 前缀和, 滑动窗口] 输出：0 -+
提示：
1 <= target <= 1091 <= nums.length <= 1051 <= nums[i] <= 1051 <= target <= 1091 <= nums.length <= 1051 <= nums[i] <= 105+
进阶：
diff --git "a/AllProblems/2100.\351\200\202\345\220\210\351\207\216\347\202\212\347\232\204\346\227\245\345\255\220.md" "b/AllProblems/2100.\351\200\202\345\220\210\351\207\216\347\202\212\347\232\204\346\227\245\345\255\220.md" new file mode 100644 index 00000000000..7bf094c4043 --- /dev/null +++ "b/AllProblems/2100.\351\200\202\345\220\210\351\207\216\347\202\212\347\232\204\346\227\245\345\255\220.md" @@ -0,0 +1,67 @@ +--- +title: 2100.适合野炊的日子 +date: 2023-10-10 14-35-11 +tags: [题解, LeetCode, 中等, 数组, 动态规划, 前缀和] +--- + +# 【LetMeFly】2100.适合野炊的日子 + +力扣题目链接：[https://leetcode.cn/problems/find-good-days-to-rob-the-bank/](https://leetcode.cn/problems/find-good-days-to-rob-the-bank/) + +你和朋友们准备去野炊。给你一个下标从 0 开始的整数数组 security ，其中 security[i] 是第 i 天的建议出行指数。日子从 0 开始编号。同时给你一个整数 time 。
如果第 i 天满足以下所有条件，我们称它为一个适合野炊的日子：
i 天前和后都分别至少有 time 天。i 天前连续 time 天建议出行指数都是非递增的。i 天后连续 time 天建议出行指数都是非递减的。更正式的，第 i 天是一个适合野炊的日子当且仅当：security[i - time] >= security[i - time + 1] >= ... >= security[i] <= ... <= security[i + time - 1] <= security[i + time].
请你返回一个数组，包含 所有 适合野炊的日子（下标从 0 开始）。返回的日子可以 任意 顺序排列。
+ ++ +
示例 1：
+ ++输入：security = [5,3,3,3,5,6,2], time = 2 +输出：[2,3] +解释： +第 2 天，我们有 security[0] >= security[1] >= security[2] <= security[3] <= security[4] 。 +第 3 天，我们有 security[1] >= security[2] >= security[3] <= security[4] <= security[5] 。 +没有其他日子符合这个条件，所以日子 2 和 3 是适合野炊的日子。 ++ +
示例 2：
+ ++输入：security = [1,1,1,1,1], time = 0 +输出：[0,1,2,3,4] +解释： +因为 time 等于 0 ，所以每一天都是适合野炊的日子，所以返回每一天。 ++ +
示例 3：
+ ++输入：security = [1,2,3,4,5,6], time = 2 +输出：[] +解释： +没有任何一天的前 2 天建议出行指数是非递增的。 +所以没有适合野炊的日子，返回空数组。 ++ +
+ +
提示：
+ +1 <= security.length <= 1050 <= security[i], time <= 105总计有 n 个环，环的颜色可以是红、绿、蓝中的一种。这些环分布穿在 10 根编号为 0 到 9 的杆上。
总计有 n 个环，环的颜色可以是红、绿、蓝中的一种。这些环分别穿在 10 根编号为 0 到 9 的杆上。
给你一个长度为 2n 的字符串 rings ，表示这 n 个环在杆上的分布。rings 中每两个字符形成一个 颜色位置对 ，用于描述每个环：
示例 1：
-
-输入：rings = "B0B6G0R6R0R6G9" ++输入：rings = "B0B6G0R6R0R6G9" 输出：1 解释： - 编号 0 的杆上有 3 个环，集齐全部颜色：红、绿、蓝。 @@ -35,8 +36,9 @@ tags: [题解, LeetCode, 简单, 哈希表, 字符串]示例 2：
--
输入：rings = "B0R0G0R9R0B0G0" ++输入：rings = "B0R0G0R9R0B0G0" 输出：1 解释： - 编号 0 的杆上有 6 个环，集齐全部颜色：红、绿、蓝。 @@ -46,7 +48,8 @@ tags: [题解, LeetCode, 简单, 哈希表, 字符串]示例 3：
-输入：rings = "G4" ++输入：rings = "G4" 输出：0 解释： 只给了一个环，因此，不存在集齐全部三种颜色环的杆。 diff --git "a/AllProblems/220.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" "b/AllProblems/220.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" index e2a380e9d8f..0895786167a 100644 --- "a/AllProblems/220.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" +++ "b/AllProblems/220.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" @@ -8,39 +8,49 @@ tags: [题解, LeetCode, 困难, 数组, 桶排序, 有序集合, 排序, 滑动 力扣题目链接：[https://leetcode.cn/problems/contains-duplicate-iii/](https://leetcode.cn/problems/contains-duplicate-iii/) -给你一个整数数组
+nums和两个整数k和t。请你判断是否存在 两个不同下标i和j，使得abs(nums[i] - nums[j]) <= t，同时又满足abs(i - j) <= k。给你一个整数数组
-nums和两个整数indexDiff和valueDiff。如果存在则返回
+true，不存在返回false。找出满足下述条件的下标对
-(i, j)：+
i != j,abs(i - j) <= indexDiffabs(nums[i] - nums[j]) <= valueDiff示例 1：
+如果存在，返回 true ；否则，返回 false 。
-输入：nums = [1,2,3,1], k = 3, t = 0 -输出：true+
-
示例 2：
+示例 1：
-输入：nums = [1,0,1,1], k = 1, t = 2 -输出：true+输入：nums = [1,2,3,1], indexDiff = 3, valueDiff = 0 +输出：true +解释：可以找出 (i, j) = (0, 3) 。 +满足下述 3 个条件： +i != j --> 0 != 3 +abs(i - j) <= indexDiff --> abs(0 - 3) <= 3 +abs(nums[i] - nums[j]) <= valueDiff --> abs(1 - 1) <= 0 + -
示例 3：
+示例 2：
-输入：nums = [1,5,9,1,5,9], k = 2, t = 3 -输出：false+输入：nums = [1,5,9,1,5,9], indexDiff = 2, valueDiff = 3 +输出：false +解释：尝试所有可能的下标对 (i, j) ，均无法满足这 3 个条件，因此返回 false 。 + -
+
提示：
0 <= nums.length <= 2 * 104-231 <= nums[i] <= 231 - 10 <= k <= 1040 <= t <= 231 - 12 <= nums.length <= 105-109 <= nums[i] <= 1091 <= indexDiff <= nums.length0 <= valueDiff <= 109示例 1：
-输入：nums = [5,19,8,1] ++输入：nums = [5,19,8,1] 输出：3 解释：初始 nums 的和为 5 + 19 + 8 + 1 = 33 。 以下是将数组和减少至少一半的一种方法： @@ -31,7 +32,8 @@ nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组示例 2：
-输入：nums = [3,8,20] ++输入：nums = [3,8,20] 输出：3 解释：初始 nums 的和为 3 + 8 + 20 = 31 。 以下是将数组和减少至少一半的一种方法： @@ -39,7 +41,7 @@ nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组 选择数字 10 并减小为 5 。 选择数字 3 并减小为 1.5 。 最终数组为 [1.5, 8, 5] ，和为 1.5 + 8 + 5 = 14.5 。 -nums 的和减小了 31 - 14.5 = 16.5 ，减小的部分超过了初始数组和的一半， 16.5 >= 31/2 = 16.5 。 +nums 的和减小了 31 - 14.5 = 16.5 ，减小的部分超过了初始数组和的一半， 16.5 >= 31/2 = 15.5 。 我们需要 3 个操作实现题目要求，所以返回 3 。 可以证明，无法通过少于 3 个操作使数组和减少至少一半。diff --git "a/AllProblems/2212.\345\260\204\347\256\255\346\257\224\350\265\233\344\270\255\347\232\204\346\234\200\345\244\247\345\276\227\345\210\206.md" "b/AllProblems/2212.\345\260\204\347\256\255\346\257\224\350\265\233\344\270\255\347\232\204\346\234\200\345\244\247\345\276\227\345\210\206.md" index b23a1f217d7..02bd4cf822e 100644 --- "a/AllProblems/2212.\345\260\204\347\256\255\346\257\224\350\265\233\344\270\255\347\232\204\346\234\200\345\244\247\345\276\227\345\210\206.md" +++ "b/AllProblems/2212.\345\260\204\347\256\255\346\257\224\350\265\233\344\270\255\347\232\204\346\234\200\345\244\247\345\276\227\345\210\206.md" @@ -1,7 +1,7 @@ --- title: 2212.射箭比赛中的最大得分 date: 2022-06-02 20-14-32 -tags: [题解, LeetCode, 中等, 位运算, 递归, 数组, 枚举] +tags: [题解, LeetCode, 中等, 位运算, 数组, 回溯, 枚举] --- # 【LetMeFly】2212.射箭比赛中的最大得分 diff --git "a/AllProblems/2251.\350\212\261\346\234\237\345\206\205\350\212\261\347\232\204\346\225\260\347\233\256.md" "b/AllProblems/2251.\350\212\261\346\234\237\345\206\205\350\212\261\347\232\204\346\225\260\347\233\256.md" index 65ba58e57fd..7a678e430b3 100644 --- "a/AllProblems/2251.\350\212\261\346\234\237\345\206\205\350\212\261\347\232\204\346\225\260\347\233\256.md" +++ "b/AllProblems/2251.\350\212\261\346\234\237\345\206\205\350\212\261\347\232\204\346\225\260\347\233\256.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 困难, 数组, 哈希表, 二分查找, 有序集合, 力扣题目链接：[https://leetcode.cn/problems/number-of-flowers-in-full-bloom/](https://leetcode.cn/problems/number-of-flowers-in-full-bloom/) -给你一个下标从 0 开始的二维整数数组
+flowers，其中flowers[i] = [starti, endi]表示第i朵花的 花期 从starti到endi（都 包含）。同时给你一个下标从 0 开始大小为n的整数数组persons，persons[i]是第i个人来看花的时间。给你一个下标从 0 开始的二维整数数组
flowers，其中flowers[i] = [starti, endi]表示第i朵花的 花期 从starti到endi（都 包含）。同时给你一个下标从 0 开始大小为n的整数数组people，people[i]是第i个人来看花的时间。请你返回一个大小为
@@ -16,9 +16,10 @@ tags: [题解, LeetCode, 困难, 数组, 哈希表, 二分查找, 有序集合,n的整数数组answer，其中answer[i]是第i个人到达时在花期内花的 数目 。示例 1：
-+
-
输入：flowers = [[1,6],[3,7],[9,12],[4,13]], persons = [2,3,7,11] ++输入：flowers = [[1,6],[3,7],[9,12],[4,13]], people = [2,3,7,11] 输出：[1,2,2,2] 解释：上图展示了每朵花的花期时间，和每个人的到达时间。 对每个人，我们返回他们到达时在花期内花的数目。 @@ -26,9 +27,10 @@ tags: [题解, LeetCode, 困难, 数组, 哈希表, 二分查找, 有序集合,示例 2：
-+
-
输入：flowers = [[1,10],[3,3]], persons = [3,3,2] ++输入：flowers = [[1,10],[3,3]], people = [3,3,2] 输出：[2,2,1] 解释：上图展示了每朵花的花期时间，和每个人的到达时间。 对每个人，我们返回他们到达时在花期内花的数目。 @@ -42,8 +44,8 @@ tags: [题解, LeetCode, 困难, 数组, 哈希表, 二分查找, 有序集合,
1 <= flowers.length <= 5 * 104flowers[i].length == 21 <= starti <= endi <= 1091 <= persons.length <= 5 * 1041 <= persons[i] <= 1091 <= people.length <= 5 * 1041 <= people[i] <= 109给你一个二维整数数组 tiles ，其中 tiles[i] = [li, ri] ，表示所有在 li <= j <= ri 之间的每个瓷砖位置 j 都被涂成了白色。
同时给你一个整数 carpetLen ，表示可以放在 任何位置 的一块毯子。
同时给你一个整数 carpetLen ，表示可以放在 任何位置 的一块毯子的长度。
请你返回使用这块毯子，最多 可以盖住多少块瓷砖。
diff --git "a/AllProblems/2337.\347\247\273\345\212\250\347\211\207\346\256\265\345\276\227\345\210\260\345\255\227\347\254\246\344\270\262.md" "b/AllProblems/2337.\347\247\273\345\212\250\347\211\207\346\256\265\345\276\227\345\210\260\345\255\227\347\254\246\344\270\262.md" index 2fcd18da0a3..63f079f6b0b 100644 --- "a/AllProblems/2337.\347\247\273\345\212\250\347\211\207\346\256\265\345\276\227\345\210\260\345\255\227\347\254\246\344\270\262.md" +++ "b/AllProblems/2337.\347\247\273\345\212\250\347\211\207\346\256\265\345\276\227\345\210\260\345\255\227\347\254\246\344\270\262.md" @@ -21,18 +21,20 @@ tags: [题解, LeetCode, 中等, 双指针, 字符串]示例 1：
-输入：start = "_L__R__R_", target = "L______RR" ++输入：start = "_L__R__R_", target = "L______RR" 输出：true 解释：可以从字符串 start 获得 target ，需要进行下面的移动： - 将第一个片段向左移动一步，字符串现在变为 "L___R__R_" 。 - 将最后一个片段向右移动一步，字符串现在变为 "L___R___R" 。 -- 将第二个片段向右移动散步，字符串现在变为 "L______RR" 。 +- 将第二个片段向右移动三步，字符串现在变为 "L______RR" 。 可以从字符串 start 得到 target ，所以返回 true 。示例 2：
-输入：start = "R_L_", target = "__LR" ++输入：start = "R_L_", target = "__LR" 输出：false 解释：字符串 start 中的 'R' 片段可以向右移动一步得到 "_RL_" 。 但是，在这一步之后，不存在可以移动的片段，所以无法从字符串 start 得到 target 。 @@ -40,7 +42,8 @@ tags: [题解, LeetCode, 中等, 双指针, 字符串]示例 3：
-输入：start = "_R", target = "R_" ++输入：start = "_R", target = "R_" 输出：false 解释：字符串 start 中的片段只能向右移动，所以无法从字符串 start 得到 target 。diff --git "a/AllProblems/2356.\346\257\217\344\275\215\346\225\231\345\270\210\346\211\200\346\225\231\346\216\210\347\232\204\347\247\221\347\233\256\347\247\215\347\261\273\347\232\204\346\225\260\351\207\217.md" "b/AllProblems/2356.\346\257\217\344\275\215\346\225\231\345\270\210\346\211\200\346\225\231\346\216\210\347\232\204\347\247\221\347\233\256\347\247\215\347\261\273\347\232\204\346\225\260\351\207\217.md" index 7023296c360..14b213b1876 100644 --- "a/AllProblems/2356.\346\257\217\344\275\215\346\225\231\345\270\210\346\211\200\346\225\231\346\216\210\347\232\204\347\247\221\347\233\256\347\247\215\347\261\273\347\232\204\346\225\260\351\207\217.md" +++ "b/AllProblems/2356.\346\257\217\344\275\215\346\225\231\345\270\210\346\211\200\346\225\231\346\216\210\347\232\204\347\247\221\347\233\256\347\247\215\347\261\273\347\232\204\346\225\260\351\207\217.md" @@ -18,13 +18,13 @@ tags: [题解, LeetCode, 简单, 数据库] | subject_id | int | | dept_id | int | +-------------+------+ -(subject_id, dept_id) 是该表的主键。 +在 SQL 中，(subject_id, dept_id) 是该表的主键。 该表中的每一行都表示带有 teacher_id 的教师在系 dept_id 中教授科目 subject_id。-
写一个 SQL 来查询每位老师在大学里教授的科目种类的数量。
+查询每位老师在大学里教授的科目种类的数量。
以 任意顺序 返回结果表。
diff --git "a/AllProblems/2366.\345\260\206\346\225\260\347\273\204\346\216\222\345\272\217\347\232\204\346\234\200\345\260\221\346\233\277\346\215\242\346\254\241\346\225\260.md" "b/AllProblems/2366.\345\260\206\346\225\260\347\273\204\346\216\222\345\272\217\347\232\204\346\234\200\345\260\221\346\233\277\346\215\242\346\254\241\346\225\260.md" index 687bdb61b2f..d01e20829df 100644 --- "a/AllProblems/2366.\345\260\206\346\225\260\347\273\204\346\216\222\345\272\217\347\232\204\346\234\200\345\260\221\346\233\277\346\215\242\346\254\241\346\225\260.md" +++ "b/AllProblems/2366.\345\260\206\346\225\260\347\273\204\346\216\222\345\272\217\347\232\204\346\234\200\345\260\221\346\233\277\346\215\242\346\254\241\346\225\260.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 数学] 力扣题目链接：[https://leetcode.cn/problems/minimum-replacements-to-sort-the-array/](https://leetcode.cn/problems/minimum-replacements-to-sort-the-array/) -给你一个下表从 0 开始的整数数组
+nums。每次操作中，你可以将数组中任何一个元素替换为 任意两个 和为该元素的数字。给你一个下标从 0 开始的整数数组
nums。每次操作中，你可以将数组中任何一个元素替换为 任意两个 和为该元素的数字。
nums = [5,6,7] 。一次操作中，我们可以将 nums[1] 替换成 2 和 4 ，将 nums 转变成 [5,2,4,7] 。题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
请不要使用除法，且在 O(n) 时间复杂度内完成此题。
请 不要使用除法，且在 O(n) 时间复杂度内完成此题。
@@ -42,7 +42,7 @@ tags: [题解, LeetCode, 中等, 数组, 前缀和]
-
进阶：你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）
进阶：你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组 不被视为 额外空间。）
示例 1：
-输入：nums = [1,3,5,2], cost = [2,3,1,14] ++输入：nums = [1,3,5,2], cost = [2,3,1,14] 输出：8 解释：我们可以执行以下操作使所有元素变为 2 ： - 增加第 0 个元素 1 次，开销为 2 。 @@ -36,7 +37,8 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 二分查找, 前缀和, 排序示例 2：
-输入：nums = [2,2,2,2,2], cost = [4,2,8,1,3] ++输入：nums = [2,2,2,2,2], cost = [4,2,8,1,3] 输出：0 解释：数组中所有元素已经全部相等，不需要执行额外的操作。@@ -49,6 +51,7 @@ tags: [题解, LeetCode, 困难, 贪心, 数组, 二分查找, 前缀和, 排序
n == nums.length == cost.length1 <= n <= 1051 <= nums[i], cost[i] <= 106给你一个链表的头节点 head 。
对于列表中的每个节点 node ，如果其右侧存在一个具有 严格更大 值的节点，则移除 node 。
移除每个右侧有一个更大数值的节点。
返回修改后链表的头节点 head 。
示例 3：
@@ -56,7 +56,7 @@ tags: [题解, LeetCode, 简单, 字符串] 输入：sentence = "Leetcode is cool" 输出：false 解释：句子中的单词是 ["Leetcode", "is", "cool"] 。 -- Leetcode 的最后一个字符和 is 的第一个字符 不 相等。 +- Leetcode 的最后一个字符和 is 的第一个字符 不 相等。 这个句子 不 是回环句。diff --git "a/AllProblems/2500.\345\210\240\351\231\244\346\257\217\350\241\214\344\270\255\347\232\204\346\234\200\345\244\247\345\200\274.md" "b/AllProblems/2500.\345\210\240\351\231\244\346\257\217\350\241\214\344\270\255\347\232\204\346\234\200\345\244\247\345\200\274.md" index f004c610e79..a5d9508d628 100644 --- "a/AllProblems/2500.\345\210\240\351\231\244\346\257\217\350\241\214\344\270\255\347\232\204\346\234\200\345\244\247\345\200\274.md" +++ "b/AllProblems/2500.\345\210\240\351\231\244\346\257\217\350\241\214\344\270\255\347\232\204\346\234\200\345\244\247\345\200\274.md" @@ -1,7 +1,7 @@ --- title: 2500.删除每行中的最大值 date: 2023-01-03 18-53-59 -tags: [题解, LeetCode, 简单, 数组, 矩阵, 排序] +tags: [题解, LeetCode, 简单, 数组, 矩阵, 排序, 模拟, 堆（优先队列）] --- # 【LetMeFly】2500.删除每行中的最大值 diff --git "a/AllProblems/2503.\347\237\251\351\230\265\346\237\245\350\257\242\345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\345\210\206\346\225\260.md" "b/AllProblems/2503.\347\237\251\351\230\265\346\237\245\350\257\242\345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\345\210\206\346\225\260.md" index ad74062d686..2edeef4c5c3 100644 --- "a/AllProblems/2503.\347\237\251\351\230\265\346\237\245\350\257\242\345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\345\210\206\346\225\260.md" +++ "b/AllProblems/2503.\347\237\251\351\230\265\346\237\245\350\257\242\345\217\257\350\216\267\345\276\227\347\232\204\346\234\200\345\244\247\345\210\206\346\225\260.md" @@ -1,7 +1,7 @@ --- title: 2503.矩阵查询可获得的最大分数 date: 2023-01-03 18-54-01 -tags: [题解, LeetCode, 困难, 广度优先搜索, 并查集, 数组, 排序, 堆（优先队列）] +tags: [题解, LeetCode, 困难, 广度优先搜索, 并查集, 数组, 双指针, 矩阵, 排序, 堆（优先队列）] --- # 【LetMeFly】2503.矩阵查询可获得的最大分数 @@ -10,7 +10,7 @@ tags: [题解, LeetCode, 困难, 广度优先搜索, 并查集, 数组, 排序,
给你一个大小为 m x n 的整数矩阵 grid 和一个大小为 k 的数组 queries 。
找出一个大小为 k 的数组 answer ，且满足对于每个整数 queres[i] ，你从矩阵 左上角 单元格开始，重复以下过程：
找出一个大小为 k 的数组 answer ，且满足对于每个整数 queries[i] ，你从矩阵 左上角 单元格开始，重复以下过程：
queries[i] 严格 大于你当前所处位置单元格，如果该单元格是第一次访问，则获得 1 分，并且你可以移动到所有 4 个方向（上、下、左、右）上任一 相邻 单元格。
示例 1：
-
-输入：grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2] ++输入：grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2] 输出：[5,8,1] 解释：上图展示了每个查询中访问并获得分数的单元格。示例 2：
--
输入：grid = [[5,2,1],[1,1,2]], queries = [3] ++输入：grid = [[5,2,1],[1,1,2]], queries = [3] 输出：[0] 解释：无法获得分数，因为左上角单元格的值大于等于 3 。diff --git "a/AllProblems/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/AllProblems/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" index 72ad28c6276..f62e6b55db2 100644 --- "a/AllProblems/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/AllProblems/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" @@ -49,9 +49,8 @@ tags: [题解, LeetCode, 中等, 数组, 二分查找, 排序]提示：
1 <= price.length <= 1052 <= k <= price.length <= 1051 <= price[i] <= 1092 <= k <= price.lengthnums1 中下标对应元素求和，乘以 nums2 中下标对应元素的 最小值 。(nums1[i0] + nums1[i1] +...+ nums1[ik - 1]) * min(nums2[i0] , nums2[i1], ... ,nums2[ik - 1]) 。(nums1[i0] + nums1[i1] +...+ nums1[ik - 1]) * min(nums2[i0] , nums2[i1], ... ,nums2[ik - 1]) 。请你返回 最大 可能的分数。
@@ -25,7 +25,8 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 排序, 堆（优先队列）]示例 1：
-输入：nums1 = [1,3,3,2], nums2 = [2,1,3,4], k = 3 ++输入：nums1 = [1,3,3,2], nums2 = [2,1,3,4], k = 3 输出：12 解释： 四个可能的子序列分数为： @@ -38,7 +39,8 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 排序, 堆（优先队列）]示例 2：
-输入：nums1 = [4,2,3,1,1], nums2 = [7,5,10,9,6], k = 1 ++输入：nums1 = [4,2,3,1,1], nums2 = [7,5,10,9,6], k = 1 输出：30 解释： 选择下标 2 最优：nums1[2] * nums2[2] = 3 * 10 = 30 是最大可能分数。 diff --git "a/AllProblems/2569.\346\233\264\346\226\260\346\225\260\347\273\204\345\220\216\345\244\204\347\220\206\346\261\202\345\222\214\346\237\245\350\257\242.md" "b/AllProblems/2569.\346\233\264\346\226\260\346\225\260\347\273\204\345\220\216\345\244\204\347\220\206\346\261\202\345\222\214\346\237\245\350\257\242.md" index 70ebaa0e9bc..d59819390b9 100644 --- "a/AllProblems/2569.\346\233\264\346\226\260\346\225\260\347\273\204\345\220\216\345\244\204\347\220\206\346\261\202\345\222\214\346\237\245\350\257\242.md" +++ "b/AllProblems/2569.\346\233\264\346\226\260\346\225\260\347\273\204\345\220\216\345\244\204\347\220\206\346\261\202\345\222\214\346\237\245\350\257\242.md" @@ -11,12 +11,12 @@ tags: [题解, LeetCode, 困难, 线段树, 数组]给你两个下标从 0 开始的数组
nums1和nums2，和一个二维数组queries表示一些操作。总共有 3 种类型的操作：-
-- 操作类型 1 为
+queries[i] = [1, l, r]。你需要将nums1从下标l到下标r的所有0反转成1或将1反转成0。l和r下标都从 0 开始。- 操作类型 1 为
queries[i] = [1, l, r]。你需要将nums1从下标l到下标r的所有0反转成1并且所有1反转成0。l和r下标都从 0 开始。- 操作类型 2 为
queries[i] = [2, p, 0]。对于0 <= i < n中的所有下标，令nums2[i] = nums2[i] + nums1[i] * p。- 操作类型 3 为
queries[i] = [3, 0, 0]。求nums2中所有元素的和。请你返回一个数组，包含所有第三种操作类型的答案。
+请你返回一个 数组，包含 所有第三种操作类型 的答案。
diff --git "a/AllProblems/2573.\346\211\276\345\207\272\345\257\271\345\272\224 LCP \347\237\251\351\230\265\347\232\204\345\255\227\347\254\246\344\270\262.md" "b/AllProblems/2573.\346\211\276\345\207\272\345\257\271\345\272\224 LCP \347\237\251\351\230\265\347\232\204\345\255\227\347\254\246\344\270\262.md" index 6eb520352be..07f2db51426 100644 --- "a/AllProblems/2573.\346\211\276\345\207\272\345\257\271\345\272\224 LCP \347\237\251\351\230\265\347\232\204\345\255\227\347\254\246\344\270\262.md" +++ "b/AllProblems/2573.\346\211\276\345\207\272\345\257\271\345\272\224 LCP \347\237\251\351\230\265\347\232\204\345\255\227\347\254\246\344\270\262.md" @@ -1,7 +1,7 @@ --- title: 2573.找出对应 LCP 矩阵的字符串 date: 2023-06-02 21-30-06 -tags: [题解, LeetCode, 困难, 贪心, 并查集, 字符串, 动态规划] +tags: [题解, LeetCode, 困难, 贪心, 并查集, 数组, 字符串, 动态规划, 矩阵] --- # 【LetMeFly】2573.找出对应 LCP 矩阵的字符串 diff --git "a/AllProblems/2578.\346\234\200\345\260\217\345\222\214\345\210\206\345\211\262.md" "b/AllProblems/2578.\346\234\200\345\260\217\345\222\214\345\210\206\345\211\262.md" index 109d44074bc..72b36eb3351 100644 --- "a/AllProblems/2578.\346\234\200\345\260\217\345\222\214\345\210\206\345\211\262.md" +++ "b/AllProblems/2578.\346\234\200\345\260\217\345\222\214\345\210\206\345\211\262.md" @@ -36,7 +36,7 @@ tags: [题解, LeetCode, 简单, 贪心, 数学, 排序]
输入：num = 4325 输出：59 -解释：我们可以将 4325 分割成num1= 24 和 num2=35 ，和为 59 ，59 是最小和。 +解释：我们可以将 4325 分割成num1= 24 和num2= 35 ，和为 59 ，59 是最小和。示例 2：
diff --git "a/AllProblems/2596.\346\243\200\346\237\245\351\252\221\345\243\253\345\267\241\350\247\206\346\226\271\346\241\210.md" "b/AllProblems/2596.\346\243\200\346\237\245\351\252\221\345\243\253\345\267\241\350\247\206\346\226\271\346\241\210.md" index 686bcb31fe1..e5bb6717e83 100644 --- "a/AllProblems/2596.\346\243\200\346\237\245\351\252\221\345\243\253\345\267\241\350\247\206\346\226\271\346\241\210.md" +++ "b/AllProblems/2596.\346\243\200\346\237\245\351\252\221\345\243\253\345\267\241\350\247\206\346\226\271\346\241\210.md" @@ -8,27 +8,29 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 数组, 力扣题目链接：[https://leetcode.cn/problems/check-knight-tour-configuration/](https://leetcode.cn/problems/check-knight-tour-configuration/) -骑士在一张
+n x n的棋盘上巡视。在有效的巡视方案中，骑士会从棋盘的 左上角 出发，并且访问棋盘上的每个格子 恰好一次 。骑士在一张
n x n的棋盘上巡视。在 有效 的巡视方案中，骑士会从棋盘的 左上角 出发，并且访问棋盘上的每个格子 恰好一次 。给你一个
n x n的整数矩阵grid，由范围[0, n * n - 1]内的不同整数组成，其中grid[row][col]表示单元格(row, col)是骑士访问的第grid[row][col]个单元格。骑士的行动是从下标 0 开始的。如果
-grid表示了骑士的有效巡视方案，返回true；否则返回false。注意，骑士行动时可以垂直移动两个格子且水平移动一个格子，或水平移动两个格子且垂直移动一个格子。下图展示了骑士从某个格子出发可能的八种行动路线。
+
-注意，骑士行动时可以垂直移动两个格子且水平移动一个格子，或水平移动两个格子且垂直移动一个格子。下图展示了骑士从某个格子出发可能的八种行动路线。
+
示例 1：
--
输入：grid = [[0,11,16,5,20],[17,4,19,10,15],[12,1,8,21,6],[3,18,23,14,9],[24,13,2,7,22]] ++
+输入：grid = [[0,11,16,5,20],[17,4,19,10,15],[12,1,8,21,6],[3,18,23,14,9],[24,13,2,7,22]] 输出：true 解释：grid 如上图所示，可以证明这是一个有效的巡视方案。示例 2：
--
输入：grid = [[0,3,6],[5,8,1],[2,7,4]] ++
+输入：grid = [[0,3,6],[5,8,1],[2,7,4]] 输出：false 解释：grid 如上图所示，考虑到骑士第 7 次行动后的位置，第 8 次行动是无效的。diff --git "a/AllProblems/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/AllProblems/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" index 49229fef9fc..a4317d06d39 100644 --- "a/AllProblems/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/AllProblems/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" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 简单, 数组, 双指针] 力扣题目链接：[https://leetcode.cn/problems/remove-duplicates-from-sorted-array/](https://leetcode.cn/problems/remove-duplicates-from-sorted-array/) -给你一个 升序排列 的数组
+nums，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回nums中唯一元素的个数。给你一个 非严格递增排列 的数组
nums，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回nums中唯一元素的个数。考虑
@@ -59,7 +59,7 @@ for (int i = 0; i < k; i++) {nums的唯一元素的数量为k，你需要做以下事情确保你的题解可以被通过：
1 <= nums.length <= 3 * 104-104 <= nums[i] <= 104nums 已按 升序 排列nums 已按 非严格递增 排列numOnes 件标记为 1 的物品。numZeroes 件标记为 0 的物品。numZeros 件标记为 0 的物品。numNegOnes 件标记为 -1 的物品。示例 1：
-输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2 ++输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 2 输出：2 解释：袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 2 件标记为 1 的物品，得到的数字之和为 2 。 可以证明 2 是所有可行方案中的最大值。示例 2：
-输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4 ++输入：numOnes = 3, numZeros = 2, numNegOnes = 0, k = 4 输出：3 解释：袋子中的物品分别标记为 {1, 1, 1, 0, 0} 。取 3 件标记为 1 的物品，1 件标记为 0 的物品，得到的数字之和为 3 。 可以证明 3 是所有可行方案中的最大值。 diff --git "a/AllProblems/2618.\346\243\200\346\237\245\346\230\257\345\220\246\346\230\257\347\261\273\347\232\204\345\257\271\350\261\241\345\256\236\344\276\213.md" "b/AllProblems/2618.\346\243\200\346\237\245\346\230\257\345\220\246\346\230\257\347\261\273\347\232\204\345\257\271\350\261\241\345\256\236\344\276\213.md" index 1ff24a05473..75c43f57f64 100644 --- "a/AllProblems/2618.\346\243\200\346\237\245\346\230\257\345\220\246\346\230\257\347\261\273\347\232\204\345\257\271\350\261\241\345\256\236\344\276\213.md" +++ "b/AllProblems/2618.\346\243\200\346\237\245\346\230\257\345\220\246\346\230\257\347\261\273\347\232\204\345\257\271\350\261\241\345\256\236\344\276\213.md" @@ -8,9 +8,9 @@ tags: [题解, LeetCode, 中等, ] 力扣题目链接：[https://leetcode.cn/problems/check-if-object-instance-of-class/](https://leetcode.cn/problems/check-if-object-instance-of-class/) -diff --git "a/AllProblems/2619.\346\225\260\347\273\204\345\216\237\345\236\213\345\257\271\350\261\241\347\232\204\346\234\200\345\220\216\344\270\200\344\270\252\345\205\203\347\264\240.md" "b/AllProblems/2619.\346\225\260\347\273\204\345\216\237\345\236\213\345\257\271\350\261\241\347\232\204\346\234\200\345\220\216\344\270\200\344\270\252\345\205\203\347\264\240.md" index 3655679a6a8..196cc78ddc7 100644 --- "a/AllProblems/2619.\346\225\260\347\273\204\345\216\237\345\236\213\345\257\271\350\261\241\347\232\204\346\234\200\345\220\216\344\270\200\344\270\252\345\205\203\347\264\240.md" +++ "b/AllProblems/2619.\346\225\260\347\273\204\345\216\237\345\236\213\345\257\271\350\261\241\347\232\204\346\234\200\345\220\216\344\270\200\344\270\252\345\205\203\347\264\240.md" @@ -10,12 +10,14 @@ tags: [题解, LeetCode, 简单, ]请你编写一个函数，检查给定的对象是否是给定类或超类的实例。
+请你编写一个函数，检查给定的值是否是给定类或超类的实例。
-可以传递给函数的数据类型没有限制。
+可以传递给函数的数据类型没有限制。例如，值或类可能是
undefined。@@ -30,7 +30,7 @@ tags: [题解, LeetCode, 中等, ] 解释： class Animal {}; class Dog extends Animal {}; -checkIfInstance(new Dog(), Animal); // true +checkIfInstanceOf(new Dog(), Animal); // true Dog 是 Animal 的子类。因此，Dog 对象同时是 Dog 和 Animal 的实例。
请你编写一段代码实现一个数组方法，使任何数组都可以调用
+array.last()方法，这个方法将返回数组最后一个元素。如果数组中没有元素，则返回-1。你可以假设数组是
+JSON.parse的输出结果。
示例 1 ：
-输入：nums = [1,2,3] +输入：nums = [null, {}, 3] 输出：3 解释：调用 nums.last() 后返回最后一个元素： 3。@@ -33,8 +35,8 @@ tags: [题解, LeetCode, 简单, ]提示：
arr 是一个有效的 JSON 数组0 <= arr.length <= 10000 <= arr[i] <= 1000取消率 的计算方式如下：(被司机或乘客取消的非禁止用户生成的订单数量) / (非禁止用户生成的订单总数)。
-写一段 SQL 语句查出 "2013-10-01" 至 "2013-10-03" 期间非禁止用户（乘客和司机都必须未被禁止）的取消率。非禁止用户即 banned 为 No 的用户，禁止用户即 banned 为 Yes 的用户。
编写解决方案找出 "2013-10-01" 至 "2013-10-03" 期间非禁止用户（乘客和司机都必须未被禁止）的取消率。非禁止用户即 banned 为 No 的用户，禁止用户即 banned 为 Yes 的用户。其中取消率 Cancellation Rate 需要四舍五入保留 两位小数 。
返回结果表中的数据可以按任意顺序组织。其中取消率 Cancellation Rate 需要四舍五入保留 两位小数 。
返回结果表中的数据 无顺序要求 。
-查询结果格式如下例所示。
+结果格式如下例所示。
-
示例：
+示例 1：
输入： @@ -79,7 +79,6 @@ Trips 表： | 9 | 3 | 10 | 12 | completed | 2013-10-03 | | 10 | 4 | 13 | 12 | cancelled_by_driver | 2013-10-03 | +----+-----------+-----------+---------+---------------------+------------+ - Users 表： +----------+--------+--------+ | users_id | banned | role | diff --git "a/AllProblems/2620.\350\256\241\346\225\260\345\231\250.md" "b/AllProblems/2620.\350\256\241\346\225\260\345\231\250.md" index 38b8bd33bea..b0d5d08f5d0 100644 --- "a/AllProblems/2620.\350\256\241\346\225\260\345\231\250.md" +++ "b/AllProblems/2620.\350\256\241\346\225\260\345\231\250.md" @@ -8,19 +8,19 @@ tags: [题解, LeetCode, 简单, ] 力扣题目链接：[https://leetcode.cn/problems/counter/](https://leetcode.cn/problems/counter/) -请你编写并返回一个 计数器 函数，它接收一个整型参数 n 。这个 计数器 函数最初返回 n，每次调用它时返回前一个值加 1 的值 (
+n,n + 1,n + 2，等等)。给定一个整型参数
n，请你编写并返回一个counter函数。这个counter函数最初返回n，每次调用它时会返回前一个值加 1 的值 (n,n + 1,n + 2，等等)。
示例 1：
-输入： +输入： n = 10 ["call","call","call"] -输出：[10,11,12] -解释： -counter() = 10 // 第一次调用 counter()，返回 n。 +输出：[10,11,12] +解释： +counter() = 10 // 第一次调用 counter()，返回 n。 counter() = 11 // 返回上次调用的值加 1。 counter() = 12 // 返回上次调用的值加 1。@@ -28,11 +28,11 @@ counter() = 12 // 返回上次调用的值加 1。示例 2：
-输入： +输入： n = -2 ["call","call","call","call","call"] -输出：[-2,-1,0,1,2] -解释：counter() 最初返回 -2。然后在每个后续调用后增加 1。 +输出：[-2,-1,0,1,2] +解释：counter() 最初返回 -2。然后在每个后续调用后增加 1。@@ -41,7 +41,8 @@ n = -2
-1000 <= n <= 1000最多对 counter() 进行 1000 次调用0 <= calls.length <= 1000calls[i] === "call"请你编写一个异步函数，它接收一个正整数参数 millis ，并休眠这么多毫秒。要求此函数可以解析任何值。
请你编写一个异步函数，它接收一个正整数参数 millis ，并休眠 millis 毫秒。要求此函数可以解析任何值。
diff --git "a/AllProblems/2622.\346\234\211\346\227\266\351\227\264\351\231\220\345\210\266\347\232\204\347\274\223\345\255\230.md" "b/AllProblems/2622.\346\234\211\346\227\266\351\227\264\351\231\220\345\210\266\347\232\204\347\274\223\345\255\230.md" index a7ee5609d1d..8f4c1c2bff6 100644 --- "a/AllProblems/2622.\346\234\211\346\227\266\351\227\264\351\231\220\345\210\266\347\232\204\347\274\223\345\255\230.md" +++ "b/AllProblems/2622.\346\234\211\346\227\266\351\227\264\351\231\220\345\210\266\347\232\204\347\274\223\345\255\230.md" @@ -24,9 +24,9 @@ tags: [题解, LeetCode, 中等, ]
输入： -["TimeLimitedCache", "set", "get", "count", "get"] -[[], [1, 42, 100], [1], [], [1]] -[0, 0, 50, 50, 150] +actions = ["TimeLimitedCache", "set", "get", "count", "get"] +values = [[], [1, 42, 100], [1], [], [1]] +timeDeays = [0, 0, 50, 50, 150] 输出： [null, false, 42, 1, -1] 解释： 在 t=0 时，缓存被构造。 @@ -41,9 +41,9 @@ tags: [题解, LeetCode, 中等, ]输入： -["TimeLimitedCache", "set", "set", "get", "get", "get", "count"] -[[], [1, 42, 50], [1, 50, 100], [1], [1], [1], []] -[0, 0, 40, 50, 120, 200, 250] +actions = ["TimeLimitedCache", "set", "set", "get", "get", "get", "count"] +values = [[], [1, 42, 50], [1, 50, 100], [1], [1], [1], []] +timeDelays = [0, 0, 40, 50, 120, 200, 250] 输出： [null, false, true, 50, 50, -1] 解释： 在 t=0 时，缓存被构造。 @@ -61,10 +61,14 @@ tags: [题解, LeetCode, 中等, ]提示：
0 <= key <= 1090 <= value <= 1090 <= key, value <= 1090 <= duration <= 1000方法调用总数不会超过1001 <= actions.length <= 100actions.length === values.lengthactions.length === timeDelays.length0 <= timeDelays[i] <= 1450actions[i] 是 "TimeLimitedCache"、"set"、"get" 和 "count" 中的一个。输入： -"sum" -["call","call","getCallCount","call","getCallCount"] -[[2,2],[2,2],[],[1,2],[]] -输出： -[4,4,1,3,2] - +fnName = "sum" +actions = ["call","call","getCallCount","call","getCallCount"] +values = [[2,2],[2,2],[],[1,2],[]] +输出：[4,4,1,3,2] 解释： const sum = (a, b) => a + b; const memoizedSum = memoize(sum); -memoizedSum (2, 2);// 返回 4。sum() 被调用，因为之前没有使用参数 (2, 2) 调用过。 -memoizedSum (2, 2);// 返回 4。没有调用 sum()，因为前面有相同的输入。 -//总调用数： 1 -memoizedSum(1、2);// 返回 3。sum() 被调用，因为之前没有使用参数 (1, 2) 调用过。 -//总调用数： 2 +memoizedSum (2, 2);// "call" - 返回 4。sum() 被调用，因为之前没有使用参数 (2, 2) 调用过。 +memoizedSum (2, 2);// "call" - 返回 4。没有调用 sum()，因为前面有相同的输入。 +// "getCallCount" - 总调用数： 1 +memoizedSum(1、2);// "call" - 返回 3。sum() 被调用，因为之前没有使用参数 (1, 2) 调用过。 +// "getCallCount" - 总调用数： 2
示例 2：
输入： -"factorial" -["call","call","call","getCallCount","call","getCallCount"] -[[2],[3],[2],[],[3],[]] -输出： -[2,6,2,2,6,2] - +fnName = "factorial" +actions = ["call","call","call","getCallCount","call","getCallCount"] +values = [[2],[3],[2],[],[3],[]] +输出：[2,6,2,2,6,2] 解释： const factorial = (n) => (n <= 1) ? 1 : (n * factorial(n - 1)); const memoFactorial = memoize(factorial); -memoFactorial(2); // 返回 2。 -memoFactorial(3); // 返回 6。 -memoFactorial(2); // 返回 2。 没有调用 factorial()，因为前面有相同的输入。 -// 总调用数：2 -memoFactorial(3); // 返回 6。 没有调用 factorial()，因为前面有相同的输入。 -// 总调用数：2 +memoFactorial(2); // "call" - 返回 2。 +memoFactorial(3); // "call" - 返回 6。 +memoFactorial(2); // "call" - 返回 2。 没有调用 factorial()，因为前面有相同的输入。 +// "getCallCount" - 总调用数：2 +memoFactorial(3); // "call" - 返回 6。 没有调用 factorial()，因为前面有相同的输入。 +// "getCallCount" - 总调用数：2
示例 3：
输入： -"fib" -["call","getCallCount"] -[[5],[]] -输出： -[8,1] - +fnName = "fib" +actions = ["call","getCallCount"] +values = [[5],[]] +输出：[8,1] 解释： -fib(5) = 8 -// 总调用数：1 +fib(5) = 8 // "call" +// "getCallCount" - 总调用数：1
-
Constraints:
+提示：
0 <= a, b <= 1051 <= n <= 10at most 105 function callsat most 105 attempts to access callCountinput function is sum, fib, or factorialactions.length === values.lengthactions[i] 为 "call" 和 "getCallCount" 中的一个fnName 为 "sum", "factorial" 和 "fib" 中的一个请你编写一个函数，它的参数为一个整数数组 nums 、一个计算函数 fn 和初始值 init 。返回一个数组 归约后 的值。
请你编写一个函数，它的参数为一个整数数组 nums 、一个计算函数 fn 和初始值init 。返回一个数组 归约后 的值。
你可以定义一个数组 归约后 的值，然后应用以下操作： val = fn(init, nums[0]) ， val = fn(val, nums[1]) ， val = fn(val, nums[2]) ，... 直到数组中的每个元素都被处理完毕。返回 val 的最终值。
-1000 <= x <= 10000 <= functions.length <= 1000所有函数都接受并返回一个整型请你编写一个函数，该函数接受一个整数数组参数 arr 和一个过滤函数 fn，并返回一个过滤后元素数量较少或元素数量相等的新数组。
给定一个整数数组 arr 和一个过滤函数 fn，并返回一个过滤后的数组 filteredArr 。
返回的数组应该只包含通过过滤函数 fn(arr[i]， i) 计算后为真值的元素。
fn 函数接受一个或两个参数：
请你在不使用内置函数 Array.filter 的前提下解决该问题。
arr[i] - arr 中的数字i - arr[i] 的索引filteredArr 应该只包含使表达式 fn(arr[i], i) 的值为 真值 的 arr 中的元素。真值 是指 Boolean(value) 返回参数为 true 的值。
请在不使用内置的 Array.filter 方法的情况下解决该问题。
diff --git "a/AllProblems/2635.\350\275\254\346\215\242\346\225\260\347\273\204\344\270\255\347\232\204\346\257\217\344\270\252\345\205\203\347\264\240.md" "b/AllProblems/2635.\350\275\254\346\215\242\346\225\260\347\273\204\344\270\255\347\232\204\346\257\217\344\270\252\345\205\203\347\264\240.md" index 60f5b2d0a67..9e193a551f2 100644 --- "a/AllProblems/2635.\350\275\254\346\215\242\346\225\260\347\273\204\344\270\255\347\232\204\346\257\217\344\270\252\345\205\203\347\264\240.md" +++ "b/AllProblems/2635.\350\275\254\346\215\242\346\225\260\347\273\204\344\270\255\347\232\204\346\257\217\344\270\252\345\205\203\347\264\240.md" @@ -49,7 +49,7 @@ const newArray = map(arr, plusone); // [2,3,4]
0 <= arr.length <= 1000-109 <= arr[i] <= 109fn 返回一个数fn 返回一个数请你编写一个函数，它接收一个异步函数 fn 和一个以毫秒为单位的时间 t。它应根据限时函数返回一个有 限时 效果的函数。
请你编写一个函数，它接受一个异步函数 fn 和一个以毫秒为单位的时间 t。它应根据限时函数返回一个有 限时 效果的函数。函数 fn 接受提供给 限时 函数的参数。
限时函数是与原函数相同的函数，除非它需要 t 毫秒以上的时间来完成。如果出现了这种情况，请你返回 "Time Limit Exceeded" 拒绝这次函数的调用。注意，它应该返回一个字符串拒绝，而不是一个 Error 。
限时 函数应遵循以下规则：
+ +fn 在 t 毫秒的时间限制内完成，限时 函数应返回结果。fn 的执行超过时间限制，限时 函数应拒绝并返回字符串 "Time Limit Exceeded" 。
示例 1：
-输入：
+输入：
fn = async (n) => {
await new Promise(res => setTimeout(res, 100));
return n * n;
}
inputs = [5]
t = 50
-输出：{"rejected":"Time Limit Exceeded","time":50}
-解释：
+输出：{"rejected":"Time Limit Exceeded","time":50}
+解释：
+const limited = timeLimit(fn, t)
+const start = performance.now()
+let result;
+try {
+ const res = await limited(...inputs)
+ result = {"resolved": res, "time": Math.floor(performance.now() - start)};
+} catch (err) {
+ result = {"rejected": err, "time": Math.floor(performance.now() - start)};
+}
+console.log(result) // 输出结果
+
提供的函数设置在 100ms 后执行完成，但是设置的超时时间为 50ms，所以在 t=50ms 时拒绝因为达到了超时时间。
示例 2：
-输入：
+输入：
fn = async (n) => {
await new Promise(res => setTimeout(res, 100));
return n * n;
}
inputs = [5]
t = 150
-输出：{"resolved":25,"time":100}
-解释：
+输出：{"resolved":25,"time":100}
+解释：
在 t=100ms 时执行 5*5=25 ，没有达到超时时间。
示例 3：
-输入：
+输入：
fn = async (a, b) => {
await new Promise(res => setTimeout(res, 120));
return a + b;
}
inputs = [5,10]
t = 150
-输出：{"resolved":15,"time":120}
-解释：
+输出：{"resolved":15,"time":120}
+解释：
在 t=120ms 时执行 5+10=15，没有达到超时时间。
示例 4：
-输入：
+输入：
fn = async () => {
throw "Error";
}
inputs = []
t = 1000
-输出：{"rejected":"Error","time":0}
-解释：
+输出：{"rejected":"Error","time":0}
+解释：
此函数始终丢出 Error
@@ -79,7 +95,7 @@ t = 1000
0 <= inputs.length <= 100 <= t <= 1000fn 返回一个 Promise 对象fn 返回一个 Promise 对象当生成器完成时，您的函数返回的 promise 应该解析为生成器返回的值。但是，如果生成器抛出错误，则返回的 promise 应该拒绝并抛出该错误。
-下面是您的代码应如何使用的示例：
+下面的示例展示了你的代码会如何被使用：
function* tasks() {
@@ -29,19 +29,19 @@ setTimeout(cancel, 50);
promise.catch(console.log); // logs "Cancelled" at t=50ms
-如果相反， cancel() 没有被调用或者在 t=100ms 之后才被调用，那么 Promise 应被解析为 5 。
相反，如果 cancel() 没有被调用或者在 t=100ms 之后才被调用，那么 promise 应被解析为 5 。
示例 1：
-输入：
+输入：
generatorFunction = function*() {
return 42;
}
cancelledAt = 100
-输出：{"resolved": 42}
+输出：{"resolved": 42}
解释：
const generator = generatorFunction();
const [cancel, promise] = cancellable(generator);
@@ -60,7 +60,7 @@ generatorFunction = function*() {
throw `Error: ${msg}`;
}
cancelledAt = null
-输出：{"rejected": "Error: Hello"}
+输出：{"rejected": "Error: Hello"}
解释：
一个 Promise 被生成。该函数通过等待 promise 解析并将解析后的值传回生成器来处理它。然后抛出一个错误，这会导致 promise 被同样抛出的错误拒绝。
@@ -68,13 +68,13 @@ cancelledAt = null
示例 3：
-输入：
+输入：
generatorFunction = function*() {
yield new Promise(res => setTimeout(res, 200));
return "Success";
}
cancelledAt = 100
-输出：{"rejected": "Cancelled"}
+输出：{"rejected": "Cancelled"}
解释：
当函数等待被生成的 promise 解析时，cancel() 被调用。这会导致一个错误消息被发送回生成器。由于这个错误没有被捕获，返回的 promise 会因为这个错误而被拒绝。
@@ -92,7 +92,7 @@ generatorFunction = function*() {
return result;
}
cancelledAt = null
-输出：{"resolved": 2}
+输出：{"resolved": 2}
解释：
生成器生成了 4 个 promise 。其中两个 promise 的值被添加到结果中。200ms 后，生成器以值 2 完成，该值被返回的 promise 解析。
@@ -100,7 +100,7 @@ cancelledAt = null
示例 5：
-输入：
+输入：
generatorFunction = function*() {
let result = 0;
try {
@@ -114,7 +114,7 @@ generatorFunction = function*() {
return result;
}
cancelledAt = 150
-输出：{"resolved": 1}
+输出：{"resolved": 1}
解释：
前两个生成的 promise 解析并导致结果递增。然而，在 t=150ms 时，生成器被取消了。发送给生成器的错误被捕获，结果被返回并最终由返回的 promise 解析。
@@ -122,7 +122,7 @@ cancelledAt = 150
示例 6：
-输入：
+输入：
generatorFunction = function*() {
try {
yield new Promise((resolve, reject) => reject("Promise Rejected"));
@@ -133,7 +133,7 @@ generatorFunction = function*() {
};
}
cancelledAt = null
-输出：{"resolved": 4}
+输出：{"resolved": 4}
解释：
第一个生成的 promise 立即被拒绝。该错误被捕获。因为生成器没有被取消，执行继续像往常一样。最终解析为 2 + 2 = 4。
@@ -143,7 +143,7 @@ cancelledAt = null
cancelledAt == null or 0 <= cancelledAt <= 1000generatorFunction 返回一个生成器对象generatorFunction 返回一个生成器对象请你写一个函数 createCounter. 这个函数接收一个初始的整数值 init 并返回一个包含三个函数的对象。
请你写一个函数 createCounter。这个函数接收一个初始的整数值 init。并返回一个包含三个函数的对象。
这三个函数是：
@@ -23,8 +23,8 @@ tags: [题解, LeetCode, 简单, ]示例 1：
-输入：init = 5, calls = ["increment","reset","decrement"] -输出：[6,5,4] +输入：init = 5, calls = ["increment","reset","decrement"] +输出：[6,5,4] 解释： const counter = createCounter(5); counter.increment(); // 6 @@ -35,8 +35,8 @@ counter.decrement(); // 4示例 2：
-输入：init = 0, calls = ["increment","increment","decrement","reset","reset"] -输出：[1,2,1,0,0] +输入：init = 0, calls = ["increment","increment","decrement","reset","reset"] +输出：[1,2,1,0,0] 解释： const counter = createCounter(0); counter.increment(); // 1 @@ -52,7 +52,8 @@ counter.reset(); // 0
-1000 <= init <= 1000总调用次数不会超过 10000 <= calls.length <= 1000calls[i] 是 “increment”、“decrement” 和 “reset” 中的一个给定一个函数 fn ，它返回一个新的函数，返回的函数与原始函数完全相同，只不过它确保 fn 最多被调用一次。
fn 相同的结果。undefined 。+ +
示例 1：
+ +
+输入：fn = (a,b,c) => (a + b + c), calls = [[1,2,3],[2,3,6]]
+输出：[{"calls":1,"value":6}]
+解释：
+const onceFn = once(fn);
+onceFn(1, 2, 3); // 6
+onceFn(2, 3, 6); // undefined, fn 没有被调用
+
+
+示例 2：
+ +
+输入：fn = (a,b,c) => (a * b * c), calls = [[5,7,4],[2,3,6],[4,6,8]]
+输出：[{"calls":1,"value":140}]
+解释：
+const onceFn = once(fn);
+onceFn(5, 7, 4); // 140
+onceFn(2, 3, 6); // undefined, fn 没有被调用
+onceFn(4, 6, 8); // undefined, fn 没有被调用
+
+
++ +
提示：
+ +calls 是一个有效的 JSON 数组1 <= calls.length <= 101 <= calls[i].length <= 1002 <= JSON.stringify(calls).length <= 1000提示：
arr is a valid JSON arrayarr 是一个有效的 JSON 数组2 <= JSON.stringify(arr).length <= 1051 <= size <= arr.length + 1n 个朋友在玩游戏。这些朋友坐成一个圈，按 顺时针方向 从 1 到 n 编号。从第 i 个朋友的位置开始顺时针移动 1 步会到达第 (i + 1) 个朋友的位置（1 <= i < n），而从第 n 个朋友的位置开始顺时针移动 1 步会回到第 1 个朋友的位置。
n 个朋友在玩游戏。这些朋友坐成一个圈，按 顺时针方向 从 1 到 n 编号。准确的说，从第 i 个朋友的位置开始顺时针移动 1 步会到达第 (i + 1) 个朋友的位置（1 <= i < n），而从第 n 个朋友的位置开始顺时针移动 1 步会回到第 1 个朋友的位置。
游戏规则如下：
@@ -36,7 +36,7 @@ tags: [题解, LeetCode, 简单, 数组, 哈希表, 模拟] 输入：n = 5, k = 2 输出：[4,5] 解释：以下为游戏进行情况： -1）第 1 个朋友接球，第1 个朋友将球传给距离他顺时针方向 2 步的玩家 —— 第 3 个朋友。
+1）第 1 个朋友接球，第 1 个朋友将球传给距离他顺时针方向 2 步的玩家 —— 第 3 个朋友。
2）第 3 个朋友将球传给距离他顺时针方向 4 步的玩家 —— 第 2 个朋友。
3）第 2 个朋友将球传给距离他顺时针方向 6 步的玩家 —— 第 3 个朋友。
4）第 3 个朋友接到两次球，游戏结束。
@@ -48,7 +48,7 @@ tags: [题解, LeetCode, 简单, 数组, 哈希表, 模拟]
输入：n = 4, k = 4
输出：[2,3,4]
解释：以下为游戏进行情况：
-1）第 1 个朋友接球，第 1 个朋友将球传给距离他顺时针方向 4 步的玩家 —— 第 1 个朋友。
+1）第 1 个朋友接球，第 1 个朋友将球传给距离他顺时针方向 4 步的玩家 —— 第 1 个朋友。
2）第 1 个朋友接到两次球，游戏结束。
diff --git "a/AllProblems/2694.\344\272\213\344\273\266\345\217\221\345\260\204\345\231\250.md" "b/AllProblems/2694.\344\272\213\344\273\266\345\217\221\345\260\204\345\231\250.md" index fcc6eae0cfd..7160a95d9cd 100644 --- "a/AllProblems/2694.\344\272\213\344\273\266\345\217\221\345\260\204\345\231\250.md" +++ "b/AllProblems/2694.\344\272\213\344\273\266\345\217\221\345\260\204\345\231\250.md" @@ -22,7 +22,9 @@ tags: [题解, LeetCode, 中等, ]
示例 1：
-输入：actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"], values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent"]]
+输入：
+actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"],
+values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent"]]
输出：[[],["emitted",[]],["subscribed"],["subscribed"],["emitted",[5,6]]]
解释：
const emitter = new EventEmitter();
@@ -35,7 +37,9 @@ emitter.emit("firstEvent"); // [5, 6], 返回 cb1 和 cb2 的输出
示例 2：
-输入：actions = ["EventEmitter", "subscribe", "emit", "emit"], values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
+输入：
+actions = ["EventEmitter", "subscribe", "emit", "emit"],
+values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
输出：[[],["subscribed"],["emitted",["1,2,3"]],["emitted",["3,4,6"]]]
解释：注意 emit 方法应该能够接受一个可选的参数数组。
@@ -48,7 +52,9 @@ emitter.emit("firstEvent", [3, 4, 6]); // ["3,4,6"]
示例 3：
-输入：actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"], values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
+输入：
+actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"],
+values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
输出：[[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[]]]
解释：
const emitter = new EventEmitter();
@@ -58,6 +64,20 @@ sub.unsubscribe(); // undefined
emitter.emit("firstEvent", [4, 5, 6]); // [], 没有订阅者
+示例 4：
+
+
+输入：
+actions = ["EventEmitter", "subscribe", "subscribe", "unsubscribe", "emit"],
+values = [[], ["firstEvent", "x => x + 1"], ["firstEvent", "x => x + 2"], [0], ["firstEvent", [5]]]
+输出：[[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[7]]]
+解释：
+const emitter = new EventEmitter();
+const sub1 = emitter.subscribe("firstEvent", x => x + 1);
+const sub2 = emitter.subscribe("firstEvent", x => x + 2);
+sub1.unsubscribe(); // undefined
+emitter.emit("firstEvent", [5]); // [7]
+
提示：
diff --git "a/AllProblems/2698.\346\261\202\344\270\200\344\270\252\346\225\264\346\225\260\347\232\204\346\203\251\347\275\232\346\225\260.md" "b/AllProblems/2698.\346\261\202\344\270\200\344\270\252\346\225\264\346\225\260\347\232\204\346\203\251\347\275\232\346\225\260.md"
index 8af5b69d7e4..ea67c53afcc 100644
--- "a/AllProblems/2698.\346\261\202\344\270\200\344\270\252\346\225\264\346\225\260\347\232\204\346\203\251\347\275\232\346\225\260.md"
+++ "b/AllProblems/2698.\346\261\202\344\270\200\344\270\252\346\225\264\346\225\260\347\232\204\346\203\251\347\275\232\346\225\260.md"
@@ -1,7 +1,7 @@
---
title: 2698.求一个整数的惩罚数
date: 2023-06-02 21-30-59
-tags: [题解, LeetCode, 中等, 递归, 数学]
+tags: [题解, LeetCode, 中等, 数学, 回溯]
---
# 【LetMeFly】2698.求一个整数的惩罚数
diff --git "a/AllProblems/2703.\350\277\224\345\233\236\344\274\240\351\200\222\347\232\204\345\217\202\346\225\260\347\232\204\351\225\277\345\272\246.md" "b/AllProblems/2703.\350\277\224\345\233\236\344\274\240\351\200\222\347\232\204\345\217\202\346\225\260\347\232\204\351\225\277\345\272\246.md"
index 6cc45416d1e..5c5d391bfc2 100644
--- "a/AllProblems/2703.\350\277\224\345\233\236\344\274\240\351\200\222\347\232\204\345\217\202\346\225\260\347\232\204\351\225\277\345\272\246.md"
+++ "b/AllProblems/2703.\350\277\224\345\233\236\344\274\240\351\200\222\347\232\204\345\217\202\346\225\260\347\232\204\351\225\277\345\272\246.md"
@@ -14,7 +14,7 @@ tags: [题解, LeetCode, 简单, ]
示例 1：
-输入：argsArr = [5]
+输入：args = [5]
输出：1
解释：
argumentsLength(5); // 1
@@ -25,7 +25,7 @@ argumentsLength(5); // 1
示例 2：
-输入：argsArr = [{}, null, "3"]
+输入：args = [{}, null, "3"]
输出：3
解释：
argumentsLength({}, null, "3"); // 3
@@ -38,8 +38,8 @@ argumentsLength({}, null, "3"); // 3
提示：
argsArr 是一个有效的 JSON 数组0 <= argsArr.length <= 100args 是一个有效的 JSON 数组0 <= args.length <= 100提示：
obj 是一个有效的 JSON 对象obj 是一个有效的 JSON 对象2 <= JSON.stringify(obj).length <= 106现给定一个函数 fn ，一个参数数组 args 和一个以毫秒为单位的超时时间 t ，返回一个取消函数 cancelFn 。
在经过 t 毫秒的延迟后，应该调用 fn 函数，并将 args 作为参数传递。除非 在 t 毫秒的延迟过程中，在 cancelT 毫秒时调用了 cancelFn。并且在这种情况下，fn 函数不应该被调用。
示例 1:
+ +
+输入：fn = (x) => x * 5, args = [2], t = 20, cancelT = 50
+输出：[{"time": 20, "returned": 10}]
+解释：
+const cancel = cancellable((x) => x * 5, [2], 20); // fn(2) 在 t=20ms 时被调用
+setTimeout(cancel, 50);
+
+取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在20毫秒时执行之后。
+
+示例 2：
+ ++输入：fn = (x) => x**2, args = [2], t = 100, cancelT = 50 +输出：[] +解释： +const cancel = cancellable((x) => x**2, [2], 100); // fn(2) 没被调用 +setTimeout(cancel, 50); + +取消操作被安排在延迟了 cancelT（50毫秒）后进行，这发生在 fn(2) 在100毫秒时执行之前，导致 fn(2) 从未被调用。 ++ +
示例 3：
+ +
+输入：fn = (x1, x2) => x1 * x2, args = [2,4], t = 30, cancelTime = 100
+输出：[{"time": 30, "returned": 8}]
+解释：
+const cancel = cancellable((x1, x2) => x1 * x2, [2,4], 30); // fn(2,4) 在 t=30ms 时被调用
+setTimeout(cancel, 100);
+
+取消操作被安排在延迟了 cancelT（100毫秒）后进行，这发生在 fn(2,4) 在30毫秒时执行之后。
+
+
++ +
提示：
+ +fn 是一个函数args 是一个有效的 JSON 数组1 <= args.length <= 1020 <= t <= 100010 <= cancelT <= 1000给你一个下标从 0 开始的字符串 s ，重复执行下述操作 任意 次：
i ，并使 c 为字符串下标 i 处的字符。并在 i 左侧（如果有）和 右侧（如果有）各 删除 一个距离 i 最近 的字符 c 。请你通过执行上述操作任意次，使 s 的长度 最小化 。
返回一个表示 最小化 字符串的长度的整数。
+ ++ +
示例 1：
+ ++输入：s = "aaabc" +输出：3 +解释：在这个示例中，s 等于 "aaabc" 。我们可以选择位于下标 1 处的字符 'a' 开始。接着删除下标 1 左侧最近的那个 'a'（位于下标 0）以及下标 1 右侧最近的那个 'a'（位于下标 2）。执行操作后，字符串变为 "abc" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。+ +
示例 2：
+ ++输入：s = "cbbd" +输出：3 +解释：我们可以选择位于下标 1 处的字符 'b' 开始。下标 1 左侧不存在字符 'b' ，但右侧存在一个字符 'b'（位于下标 2），所以会删除位于下标 2 的字符 'b' 。执行操作后，字符串变为 "cbd" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。+ +
示例 3：
+ ++输入：s = "dddaaa" +输出：2 +解释：我们可以选择位于下标 1 处的字符 'd' 开始。接着删除下标 1 左侧最近的那个 'd'（位于下标 0）以及下标 1 右侧最近的那个 'd'（位于下标 2）。执行操作后，字符串变为 "daaa" 。继续对新字符串执行操作，可以选择位于下标 2 的字符 'a' 。接着删除下标 2 左侧最近的那个 'a'（位于下标 1）以及下标 2 右侧最近的那个 'a'（位于下标 3）。执行操作后，字符串变为 "da" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 2 。 ++ +
+ +
提示：
+ +1 <= s.length <= 100s 仅由小写英文字母组成给你一个下标从 0 开始、长度为 n 的整数排列 nums 。
如果排列的第一个数字等于 1 且最后一个数字等于 n ，则称其为 半有序排列 。你可以执行多次下述操作，直到将 nums 变成一个 半有序排列 ：
nums 中相邻的两个元素，然后交换它们。返回使 nums 变成 半有序排列 所需的最小操作次数。
排列 是一个长度为 n 的整数序列，其中包含从 1 到 n 的每个数字恰好一次。
+ +
示例 1：
+ ++输入：nums = [2,1,4,3] +输出：2 +解释：可以依次执行下述操作得到半有序排列： +1 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。 +2 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。 +可以证明，要让 nums 成为半有序排列，不存在执行操作少于 2 次的方案。+ +
示例 2：
+ ++输入：nums = [2,4,1,3] +输出：3 +解释： +可以依次执行下述操作得到半有序排列： +1 - 交换下标 1 和下标 2 对应元素。排列变为 [2,1,4,3] 。 +2 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。 +3 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。 +可以证明，要让 nums 成为半有序排列，不存在执行操作少于 3 次的方案。 ++ +
示例 3：
+ ++输入：nums = [1,3,4,2,5] +输出：0 +解释：这个排列已经是一个半有序排列，无需执行任何操作。 ++ +
+ +
提示：
+ +2 <= nums.length == n <= 501 <= nums[i] <= 50nums 是一个 排列给你一个整数 n 和一个下标从 0 开始的 二维数组 queries ，其中 queries[i] = [typei, indexi, vali] 。
一开始，给你一个下标从 0 开始的 n x n 矩阵，所有元素均为 0 。每一个查询，你需要执行以下操作之一：
typei == 0 ，将第 indexi 行的元素全部修改为 vali ，覆盖任何之前的值。typei == 1 ，将第 indexi 列的元素全部修改为 vali ，覆盖任何之前的值。请你执行完所有查询以后，返回矩阵中所有整数的和。
+ ++ +
示例 1：
+ +
输入：n = 3, queries = [[0,0,1],[1,2,2],[0,2,3],[1,0,4]] +输出：23 +解释：上图展示了每个查询以后矩阵的值。所有操作执行完以后，矩阵元素之和为 23 。 ++ +
示例 2：
+ +
输入：n = 3, queries = [[0,0,4],[0,1,2],[1,0,1],[0,2,3],[1,2,1]] +输出：17 +解释：上图展示了每一个查询操作之后的矩阵。所有操作执行完以后，矩阵元素之和为 17 。 ++ +
+ +
提示：
+ +1 <= n <= 1041 <= queries.length <= 5 * 104queries[i].length == 30 <= typei <= 10 <= indexi < n0 <= vali <= 105给你两个数字字符串 num1 和 num2 ，以及两个整数 max_sum 和 min_sum 。如果一个整数 x 满足以下条件，我们称它是一个好整数：
num1 <= x <= num2min_sum <= digit_sum(x) <= max_sum.请你返回好整数的数目。答案可能很大，请返回答案对 109 + 7 取余后的结果。
注意，digit_sum(x) 表示 x 各位数字之和。
+ +
示例 1：
+ ++输入：num1 = "1", num2 = "12", min_num = 1, max_num = 8 +输出：11 +解释：总共有 11 个整数的数位和在 1 到 8 之间，分别是 1,2,3,4,5,6,7,8,10,11 和 12 。所以我们返回 11 。 ++ +
示例 2：
+ ++输入：num1 = "1", num2 = "5", min_num = 1, max_num = 5 +输出：5 +解释：数位和在 1 到 5 之间的 5 个整数分别为 1,2,3,4 和 5 。所以我们返回 5 。 ++ +
+ +
提示：
+ +1 <= num1 <= num2 <= 10221 <= min_sum <= max_sum <= 400给定一个异步函数数组 functions，返回一个新的 promise 对象 promise。数组中的每个函数都不接受参数并返回一个 promise。所有的 promise 都应该并行执行。
promise resolve 条件：
functions 返回的 promise 都成功的并行解析时。promise 的解析值应该是一个按照它们在 functions 中的顺序排列的 promise 的解析值数组。promise 应该在数组中的所有异步函数并行执行完成时解析。promise reject 条件：
functions 返回的 promise 被拒绝时。promise 也会被拒绝，并返回第一个拒绝的原因。请在不使用内置的 Promise.all 函数的情况下解决。
+ +
示例 1：
+ +
+输入：functions = [
+ () => new Promise(resolve => setTimeout(() => resolve(5), 200))
+]
+输出：{"t": 200, "resolved": [5]}
+解释：
+promiseAll(functions).then(console.log); // [5]
+
+单个函数在 200 毫秒后以值 5 成功解析。
+
+
+示例 2：
+ +
+输入：functions = [
+ () => new Promise(resolve => setTimeout(() => resolve(1), 200)),
+ () => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100))
+]
+输出：{"t": 100, "rejected": "Error"}
+解释：由于其中一个 promise 被拒绝，返回的 promise 也在同一时间被拒绝并返回相同的错误。
+
+
+示例 3：
+ +
+输入：functions = [
+ () => new Promise(resolve => setTimeout(() => resolve(4), 50)),
+ () => new Promise(resolve => setTimeout(() => resolve(10), 150)),
+ () => new Promise(resolve => setTimeout(() => resolve(16), 100))
+]
+输出：{"t": 150, "resolved": [4, 10, 16]}
+解释：所有的 promise 都成功执行。当最后一个 promise 被解析时，返回的 promise 也被解析了。
+
+
++ +
提示：
+ +functions 是一个返回 promise 的函数数组1 <= functions.length <= 10现给定两个数组 arr1 和 arr2 ，返回一个新的数组 joinedArray 。两个输入数组中的每个对象都包含一个 id 字段。joinedArray 是一个通过 id 将 arr1 和 arr2 连接而成的数组。joinedArray 的长度应为唯一值 id 的长度。返回的数组应按 id 升序 排序。
如果一个 id 存在于一个数组中但不存在于另一个数组中，则该对象应包含在结果数组中且不进行修改。
如果两个对象共享一个 id ，则它们的属性应进行合并：
arr2 中的值应覆盖 arr1 中的值。+ +
示例 1：
+ +
+输入：
+arr1 = [
+ {"id": 1, "x": 1},
+ {"id": 2, "x": 9}
+],
+arr2 = [
+ {"id": 3, "x": 5}
+]
+输出：
+[
+ {"id": 1, "x": 1},
+ {"id": 2, "x": 9},
+ {"id": 3, "x": 5}
+]
+解释：没有共同的 id，因此将 arr1 与 arr2 简单地连接起来。
+
+
+示例 2：
+ +
+输入：
+arr1 = [
+ {"id": 1, "x": 2, "y": 3},
+ {"id": 2, "x": 3, "y": 6}
+],
+arr2 = [
+ {"id": 2, "x": 10, "y": 20},
+ {"id": 3, "x": 0, "y": 0}
+]
+输出：
+[
+ {"id": 1, "x": 2, "y": 3},
+ {"id": 2, "x": 10, "y": 20},
+ {"id": 3, "x": 0, "y": 0}
+]
+解释：id 为 1 和 id 为 3 的对象在结果数组中保持不变。id 为 2 的两个对象合并在一起。arr2 中的键覆盖 arr1 中的值。
+
+
+示例 3：
+ +
+输入：
+arr1 = [
+ {"id": 1, "b": {"b": 94},"v": [4, 3], "y": 48}
+]
+arr2 = [
+ {"id": 1, "b": {"c": 84}, "v": [1, 3]}
+]
+输出： [
+ {"id": 1, "b": {"c": 84}, "v": [1, 3], "y": 48}
+]
+解释：具有 id 为 1 的对象合并在一起。对于键 "b" 和 "v" ，使用 arr2 中的值。由于键 "y" 只存在于 arr1 中，因此取 arr1 的值。
+
++ +
提示：
+ +arr1 和 arr2 都是有效的 JSON 数组在 arr1 和 arr2 中都有唯一的键值 id2 <= JSON.stringify(arr1).length <= 1062 <= JSON.stringify(arr2).length <= 106promise1 和 promise2，返回一个新的 promise。promise1 和 promise2 都会被解析为一个数字。返回的 Promise 应该解析为这两个数字的和。
++ +
示例 1：
+ ++输入： +promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20)), +promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60)) +输出：7 +解释：两个输入的 Promise 分别解析为值 2 和 5。返回的 Promise 应该解析为 2 + 5 = 7。返回的 Promise 解析的时间不作为判断条件。 ++ +
示例 2：
+ ++输入： +promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50)), +promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30)) +输出：-2 +解释：两个输入的 Promise 分别解析为值 10 和 -12。返回的 Promise 应该解析为 10 + -12 = -2。 ++ +
+ +
提示：
+ +promise1 和 promise2 都是被解析为一个数字的 promise 对象给定一个数组 arr 和一个函数 fn，返回一个排序后的数组 sortedArr。你可以假设 fn 只返回数字，并且这些数字决定了 sortedArr 的排序顺序。sortedArr 必须按照 fn 的输出值 升序 排序。
你可以假设对于给定的数组，fn 不会返回重复的数字。
+ +
示例 1：
+ ++输入：arr = [5, 4, 1, 2, 3], fn = (x) => x +输出：[1, 2, 3, 4, 5] +解释：fn 只是返回传入的数字，因此数组按升序排序。 ++ +
示例 2：
+ +
+输入：arr = [{"x": 1}, {"x": 0}, {"x": -1}], fn = (d) => d.x
+输出：[{"x": -1}, {"x": 0}, {"x": 1}]
+解释：fn 返回 "x" 键的值，因此数组根据该值排序。
+
+
+示例 3：
+ ++输入：arr = [[3, 4], [5, 2], [10, 1]], fn = (x) => x[1] +输出：[[10, 1], [5, 2], [3, 4]] +解释：数组按照索引为 1 处的数字升序排序。 ++ +
+ +
提示：
+ +arr 是一个有效的 JSON 数组fn 是一个函数，返回一个数字1 <= arr.length <= 5 * 105现给定一个函数 fn，一个参数数组 args 和一个时间间隔 t，返回一个取消函数 cancelFn。
函数 fn 应该立即使用 args 调用，并且在每个 t 毫秒内再次调用，直到调用 cancelFn。
+ +
示例 1：
+ +
+输入：fn = (x) => x * 2, args = [4], t = 35, cancelT = 190
+输出：
+[
+ {"time": 0, "returned": 8},
+ {"time": 35, "returned": 8},
+ {"time": 70, "returned": 8},
+ {"time": 105, "returned": 8},
+ {"time": 140, "returned": 8},
+ {"time": 175, "returned": 8}
+]
+解释：
+const result = []
+const fn = (x) => x * 2
+const args = [4], t = 35, cancelT = 190
+
+const start = performance.now()
+
+const log = (...argsArr) => {
+ const diff = Math.floor(performance.now() - start)
+ result.push({"time": diff, "returned": fn(...argsArr)})
+}
+
+const cancel = cancellable(log, [4], 35);
+setTimeout(cancel, 190);
+
+setTimeout(() => {
+ console.log(result) // Output
+ }, cancelT + t + 15)
+
+每隔 35ms，调用 fn(4)。直到 t=190ms，然后取消。
+第一次调用 fn 是在 0ms。fn(4) 返回 8。
+第二次调用 fn 是在 35ms。fn(4) 返回 8。
+第三次调用 fn 是在 70ms。fn(4) 返回 8。
+第四次调用 fn 是在 105ms。fn(4) 返回 8。
+第五次调用 fn 是在 140ms。fn(4) 返回 8。
+第六次调用 fn 是在 175ms。fn(4) 返回 8。
+在 t=190ms 时取消
+
+
+示例 2：
+ +
+输入：fn = (x1, x2) => (x1 * x2), args = [2, 5], t = 30, cancelT = 165
+输出：
+[
+ {"time": 0, "returned": 10},
+ {"time": 30, "returned": 10},
+ {"time": 60, "returned": 10},
+ {"time": 90, "returned": 10},
+ {"time": 120, "returned": 10},
+ {"time": 150, "returned": 10}
+]
+解释：
+const cancel = cancellable((x1, x2) => (x1 * x2), [2, 5], 30);
+setTimeout(cancel, 165);
+
+每隔 30ms，调用 fn(2, 5)。直到 t=165ms，然后取消。
+第一次调用 fn 是在 0ms
+第二次调用 fn 是在 30ms
+第三次调用 fn 是在 60ms
+第四次调用 fn 是在 90ms
+第五次调用 fn 是在 120ms
+第六次调用 fn 是在 150ms
+在 165ms 取消
+
+
+示例 3：
+ +
+输入：fn = (x1, x2, x3) => (x1 + x2 + x3), args = [5, 1, 3], t = 50, cancelT = 180
+输出：
+[
+ {"time": 0, "returned": 9},
+ {"time": 50, "returned": 9},
+ {"time": 100, "returned": 9},
+ {"time": 150, "returned": 9}
+]
+解释：
+const cancel = cancellable((x1, x2, x3) => (x1 + x2 + x3), [5, 1, 3], 50);
+setTimeout(cancel, cancelT);
+
+每隔 50ms，调用 fn(5, 1, 3)。直到 t=180ms，然后取消。
+第一次调用 fn 是在 0ms
+第二次调用 fn 是在 50ms
+第三次调用 fn 是在 100ms
+第四次调用 fn 是在 150ms
+在 180ms 取消
+
+
++ +
提示：
+ +fn 是一个函数args 是一个有效的 JSON 数组1 <= args.length <= 1030 <= t <= 10010 <= cancelT <= 500设计一个类 Calculator 。该类应提供加法、减法、乘法、除法和乘方等数学运算功能。同时，它还应支持连续操作的方法链式调用。Calculator 类的构造函数应接受一个数字作为 result 的初始值。
你的 Calculator 类应包含以下方法：
add - 将给定的数字 value 与 result 相加，并返回更新后的 Calculator 对象。subtract - 从 result 中减去给定的数字 value ，并返回更新后的 Calculator 对象。multiply - 将 result 乘以给定的数字 value ，并返回更新后的 Calculator 对象。divide - 将 result 除以给定的数字 value ，并返回更新后的 Calculator 对象。如果传入的值为 0 ，则抛出错误 "Division by zero is not allowed" 。power - 计算 result 的幂，指数为给定的数字 value ，并返回更新后的 Calculator 对象。（result = result ^ value ）getResult - 返回 result 的值。结果与实际结果相差在 10-5 范围内的解被认为是正确的。
+ +
示例 1：
+ ++输入：actions = ["Calculator", "add", "subtract", "getResult"], +values = [10, 5, 7] +输出：8 +解释： +new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8 ++ +
示例 2：
+ ++输入：actions = ["Calculator", "multiply", "power", "getResult"], +values = [2, 5, 2] +输出：100 +解释： +new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100 ++ +
示例 3：
+ ++输入：actions = ["Calculator", "divide", "getResult"], +values = [20, 0] +输出："Division by zero is not allowed" +解释： +new Calculator(20).divide(0).getResult() // 20 / 0 + +由于不能除以零，因此应抛出错误。 ++ +
+ +
提示：
+ +actions 是一个有效的 JSON 字符串数组values 是一个有效的 JSON 字符串数组2 <= actions.length <= 2 * 1041 <= values.length <= 2 * 104 - 1actions[i] 是 "Calculator", "add", "subtract", "multiply", "divide", "power", 和 "getResult" 其中的元素给定一个对象或数组，判断它是否为空。
+ +你可以假设对象或数组是通过 JSON.parse 解析得到的。
+ +
示例 1：
+ +
+输入：obj = {"x": 5, "y": 42}
+输出：false
+解释：这个对象有两个键值对，所以它不为空。
+
+
+示例 2：
+ +
+输入：obj = {}
+输出：true
+解释：这个对象没有任何键值对，所以它为空。
+
+
+示例 3：
+ ++输入：obj = [null, false, 0] +输出：false +解释：这个数组有 3 个元素，所以它不为空。 ++ +
+ +
提示：
+ +obj 是一个有效的 JSON 对象或数组2 <= JSON.stringify(obj).length <= 105+你可以在 O(1) 时间复杂度内解决这个问题吗？ + + \ No newline at end of file diff --git "a/AllProblems/2729.\345\210\244\346\226\255\344\270\200\344\270\252\346\225\260\346\230\257\345\220\246\350\277\267\344\272\272.md" "b/AllProblems/2729.\345\210\244\346\226\255\344\270\200\344\270\252\346\225\260\346\230\257\345\220\246\350\277\267\344\272\272.md" new file mode 100644 index 00000000000..2a615606a47 --- /dev/null +++ "b/AllProblems/2729.\345\210\244\346\226\255\344\270\200\344\270\252\346\225\260\346\230\257\345\220\246\350\277\267\344\272\272.md" @@ -0,0 +1,48 @@ +--- +title: 2729.判断一个数是否迷人 +date: 2023-10-10 14-40-08 +tags: [题解, LeetCode, 简单, 哈希表, 数学] +--- + +# 【LetMeFly】2729.判断一个数是否迷人 + +力扣题目链接：[https://leetcode.cn/problems/check-if-the-number-is-fascinating/](https://leetcode.cn/problems/check-if-the-number-is-fascinating/) + +
给你一个三位数整数 n 。
如果经过以下修改得到的数字 恰好 包含数字 1 到 9 各一次且不包含任何 0 ，那么我们称数字 n 是 迷人的 ：
n 与数字 2 * n 和 3 * n 连接 。如果 n 是迷人的，返回 true，否则返回 false 。
连接 两个数字表示把它们首尾相接连在一起。比方说 121 和 371 连接得到 121371 。
+ +
示例 1：
+ +输入：n = 192 +输出：true +解释：我们将数字 n = 192 ，2 * n = 384 和 3 * n = 576 连接，得到 192384576 。这个数字包含 1 到 9 恰好各一次。 ++ +
示例 2：
+ +输入：n = 100 +输出：false +解释：我们将数字 n = 100 ，2 * n = 200 和 3 * n = 300 连接，得到 100200300 。这个数字不符合上述条件。 ++ +
+ +
提示：
+ +100 <= n <= 999给你一个下标从 0 开始的字符串 s ，这个字符串只包含 0 到 9 的数字字符。
如果一个字符串 t 中至多有一对相邻字符是相等的，那么称这个字符串 t 是 半重复的 。例如，0010 、002020 、0123 、2002 和 54944 是半重复字符串，而 00101022 和 1101234883 不是。
请你返回 s 中最长 半重复 子字符串的长度。
一个 子字符串 是一个字符串中一段连续 非空 的字符。
+ ++ +
示例 1：
+ ++输入：s = "52233" +输出：4 +解释：最长半重复子字符串是 "5223" ，子字符串从 i = 0 开始，在 j = 3 处结束。 ++ +
示例 2：
+ ++输入：s = "5494" +输出：4 +解释：s 就是一个半重复字符串，所以答案为 4 。 ++ +
示例 3：
+ ++输入：s = "1111111" +输出：2 +解释：最长半重复子字符串是 "11" ，子字符串从 i = 0 开始，在 j = 1 处结束。 ++ +
+ +
提示：
+ +1 <= s.length <= 50'0' <= s[i] <= '9'有一些机器人分布在一条无限长的数轴上，他们初始坐标用一个下标从 0 开始的整数数组 nums 表示。当你给机器人下达命令时，它们以每秒钟一单位的速度开始移动。
给你一个字符串 s ，每个字符按顺序分别表示每个机器人移动的方向。'L' 表示机器人往左或者数轴的负方向移动，'R' 表示机器人往右或者数轴的正方向移动。
当两个机器人相撞时，它们开始沿着原本相反的方向移动。
+ +请你返回指令重复执行 d 秒后，所有机器人之间两两距离之和。由于答案可能很大，请你将答案对 109 + 7 取余后返回。
注意：
+ +i 和 j 的两个机器人，(i,j) 和 (j,i) 视为相同的坐标对。也就是说，机器人视为无差别的。当两个机器人在同一时刻占据相同的位置时，就会相撞。
+ +例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 2 并往左移动，下一秒，它们都将占据位置 1，并改变方向。再下一秒钟后，第一个机器人位于位置 0 并往左移动，而另一个机器人位于位置 2 并往右移动。
+例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 1 并往左移动，下一秒，第一个机器人位于位置 0 并往左行驶，而另一个机器人位于位置 1 并往右移动。
++ +
示例 1：
+ ++输入：nums = [-2,0,2], s = "RLL", d = 3 +输出：8 +解释： +1 秒后，机器人的位置为 [-1,-1,1] 。现在下标为 0 的机器人开始往左移动，下标为 1 的机器人开始往右移动。 +2 秒后，机器人的位置为 [-2,0,0] 。现在下标为 1 的机器人开始往左移动，下标为 2 的机器人开始往右移动。 +3 秒后，机器人的位置为 [-3,-1,1] 。 +下标为 0 和 1 的机器人之间距离为 abs(-3 - (-1)) = 2 。 +下标为 0 和 2 的机器人之间的距离为 abs(-3 - 1) = 4 。 +下标为 1 和 2 的机器人之间的距离为 abs(-1 - 1) = 2 。 +所有机器人对之间的总距离为 2 + 4 + 2 = 8 。 ++ +
示例 2：
+ ++输入：nums = [1,0], s = "RL", d = 2 +输出：5 +解释： +1 秒后，机器人的位置为 [2,-1] 。 +2 秒后，机器人的位置为 [3,-2] 。 +两个机器人的距离为 abs(-2 - 3) = 5 。 ++ +
+ +
提示：
+ +2 <= nums.length <= 105-2 * 109 <= nums[i] <= 2 * 1090 <= d <= 109nums.length == s.length s 只包含 'L' 和 'R' 。nums[i] 互不相同。给你一个下标从 0 开始大小为 m x n 的二进制矩阵 grid 。
从原矩阵中选出若干行构成一个行的 非空 子集，如果子集中任何一列的和至多为子集大小的一半，那么我们称这个子集是 好子集。
+ +更正式的，如果选出来的行子集大小（即行的数量）为 k，那么每一列的和至多为 floor(k / 2) 。
请你返回一个整数数组，它包含好子集的行下标，请你将子集中的元素 升序 返回。
+ +如果有多个好子集，你可以返回任意一个。如果没有好子集，请你返回一个空数组。
+ +一个矩阵 grid 的行 子集 ，是删除 grid 中某些（也可能不删除）行后，剩余行构成的元素集合。
+ +
示例 1：
+ ++输入：grid = [[0,1,1,0],[0,0,0,1],[1,1,1,1]] +输出：[0,1] +解释：我们可以选择第 0 和第 1 行构成一个好子集。 +选出来的子集大小为 2 。 +- 第 0 列的和为 0 + 0 = 0 ，小于等于子集大小的一半。 +- 第 1 列的和为 1 + 0 = 1 ，小于等于子集大小的一半。 +- 第 2 列的和为 1 + 0 = 1 ，小于等于子集大小的一半。 +- 第 3 列的和为 0 + 1 = 1 ，小于等于子集大小的一半。 ++ +
示例 2：
+ ++输入：grid = [[0]] +输出：[0] +解释：我们可以选择第 0 行构成一个好子集。 +选出来的子集大小为 1 。 +- 第 0 列的和为 0 ，小于等于子集大小的一半。 ++ +
示例 3：
+ ++输入：grid = [[1,1,1],[1,1,1]] +输出：[] +解释：没有办法得到一个好子集。 ++ +
+ +
提示：
+ +m == grid.lengthn == grid[i].length1 <= m <= 1041 <= n <= 5grid[i][j] 要么是 0 ，要么是 1 。给你一个整数数组 nums ，数组由 不同正整数 组成，请你找出并返回数组中 任一 既不是 最小值 也不是 最大值 的数字，如果不存在这样的数字，返回 -1 。
返回所选整数。
+ ++ +
示例 1：
+ +输入：nums = [3,2,1,4] +输出：2 +解释：在这个示例中，最小值是 1 ，最大值是 4 。因此，2 或 3 都是有效答案。 ++ +
示例 2：
+ +输入：nums = [1,2] +输出：-1 +解释：由于不存在既不是最大值也不是最小值的数字，我们无法选出满足题目给定条件的数字。因此，不存在答案，返回 -1 。 ++ +
示例 3：
+ +输入：nums = [2,1,3] +输出：2 +解释：2 既不是最小值，也不是最大值，这个示例只有这一个有效答案。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1001 <= nums[i] <= 100nums 中的所有数字互不相同给你一个仅由小写英文字母组成的字符串 s 。在一步操作中，你可以完成以下行为：
s 的任一非空子字符串，可能是整个字符串，接着将字符串中的每一个字符替换为英文字母表中的前一个字符。例如，'b' 用 'a' 替换，'a' 用 'z' 替换。返回执行上述操作 恰好一次 后可以获得的 字典序最小 的字符串。
+ +子字符串 是字符串中的一个连续字符序列。
+现有长度相同的两个字符串x 和 字符串 y ，在满足 x[i] != y[i] 的第一个位置 i 上，如果 x[i] 在字母表中先于 y[i] 出现，则认为字符串 x 比字符串 y 字典序更小 。
+
++ +
示例 1：
+ ++输入：s = "cbabc" +输出："baabc" +解释：我们选择从下标 0 开始、到下标 1 结束的子字符串执行操作。 +可以证明最终得到的字符串是字典序最小的。 ++ +
示例 2：
+ ++输入：s = "acbbc" +输出："abaab" +解释：我们选择从下标 1 开始、到下标 4 结束的子字符串执行操作。 +可以证明最终得到的字符串是字典序最小的。 ++ +
示例 3：
+ ++输入：s = "leetcode" +输出："kddsbncd" +解释：我们选择整个字符串执行操作。 +可以证明最终得到的字符串是字典序最小的。 ++ +
+ +
提示：
+ +1 <= s.length <= 3 * 105s 仅由小写英文字母组成给你一个长度为 n 、下标从 0 开始的整数数组 nums ，表示收集不同巧克力的成本。每个巧克力都对应一个不同的类型，最初，位于下标 i 的巧克力就对应第 i 个类型。
在一步操作中，你可以用成本 x 执行下述行为：
ith 修改为类型 ((i + 1) mod n)th。假设你可以执行任意次操作，请返回收集所有类型巧克力所需的最小成本。
+ ++ +
示例 1：
+ ++输入：nums = [20,1,15], x = 5 +输出：13 +解释：最开始，巧克力的类型分别是 [0,1,2] 。我们可以用成本 1 购买第 1 个类型的巧克力。 +接着，我们用成本 5 执行一次操作，巧克力的类型变更为 [1,2,0] 。我们可以用成本 1 购买第 2 个类型的巧克力。 +然后，我们用成本 5 执行一次操作，巧克力的类型变更为 [2,0,1] 。我们可以用成本 1 购买第 0 个类型的巧克力。 +因此，收集所有类型的巧克力需要的总成本是 (1 + 5 + 1 + 5 + 1) = 13 。可以证明这是一种最优方案。 ++ +
示例 2：
+ ++输入：nums = [1,2,3], x = 4 +输出：6 +解释：我们将会按最初的成本收集全部三个类型的巧克力，而不需执行任何操作。因此，收集所有类型的巧克力需要的总成本是 1 + 2 + 3 = 6 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 10001 <= nums[i] <= 1091 <= x <= 109给你两个长度为 n 、下标从 0 开始的整数数组 nums1 和 nums2 ，另给你一个下标从 1 开始的二维数组 queries ，其中 queries[i] = [xi, yi] 。
对于第 i 个查询，在所有满足 nums1[j] >= xi 且 nums2[j] >= yi 的下标 j (0 <= j < n) 中，找出 nums1[j] + nums2[j] 的 最大值 ，如果不存在满足条件的 j 则返回 -1 。
返回数组 answer ，其中 answer[i] 是第 i 个查询的答案。
+ +
示例 1：
+ +输入：nums1 = [4,3,1,2], nums2 = [2,4,9,5], queries = [[4,1],[1,3],[2,5]] +输出：[6,10,7] +解释： +对于第 1 个查询：+ +xi = 4且yi = 1，可以选择下标j = 0，此时nums1[j] >= 4且nums2[j] >= 1。nums1[j] + nums2[j]等于 6 ，可以证明 6 是可以获得的最大值。 +对于第 2 个查询：xi = 1且yi = 3，可以选择下标j = 2，此时nums1[j] >= 1且nums2[j] >= 3。nums1[j] + nums2[j]等于 10 ，可以证明 10 是可以获得的最大值。 +对于第 3 个查询：xi = 2且yi = 5，可以选择下标j = 3，此时nums1[j] >= 2且nums2[j] >= 5。nums1[j] + nums2[j]等于 7 ，可以证明 7 是可以获得的最大值。 +因此，我们返回[6,10,7]。 +
示例 2：
+ +输入：nums1 = [3,2,5], nums2 = [2,3,4], queries = [[4,4],[3,2],[1,1]]
+输出：[9,9,9]
+解释：对于这个示例，我们可以选择下标 j = 2 ，该下标可以满足每个查询的限制。
+
+
+示例 3：
+ +输入：nums1 = [2,1], nums2 = [2,3], queries = [[3,3]] +输出：[-1] +解释：示例中的查询+ +xi= 3 且yi= 3 。对于每个下标 j ，都只满足 nums1[j] <xi或者 nums2[j] <yi。因此，不存在答案。 +
+ +
提示：
+ +nums1.length == nums2.length n == nums1.length 1 <= n <= 1051 <= nums1[i], nums2[i] <= 109 1 <= queries.length <= 105queries[i].length == 2xi == queries[i][1]yi == queries[i][2]1 <= xi, yi <= 109卡车有两个油箱。给你两个整数，mainTank 表示主油箱中的燃料（以升为单位），additionalTank 表示副油箱中的燃料（以升为单位）。
该卡车每耗费 1 升燃料都可以行驶 10 km。每当主油箱使用了 5 升燃料时，如果副油箱至少有 1 升燃料，则会将 1 升燃料从副油箱转移到主油箱。
返回卡车可以行驶的最大距离。
+ +注意：从副油箱向主油箱注入燃料不是连续行为。这一事件会在每消耗 5 升燃料时突然且立即发生。
+ +
示例 1：
+ +输入：mainTank = 5, additionalTank = 10 +输出：60 +解释： +在用掉 5 升燃料后，主油箱中燃料还剩下 (5 - 5 + 1) = 1 升，行驶距离为 50km 。 +在用掉剩下的 1 升燃料后，没有新的燃料注入到主油箱中，主油箱变为空。 +总行驶距离为 60km 。 ++ +
示例 2：
+ +输入：mainTank = 1, additionalTank = 2 +输出：10 +解释： +在用掉 1 升燃料后，主油箱变为空。 +总行驶距离为 10km 。 ++ +
+ +
提示：
+ +1 <= mainTank, additionalTank <= 100给你一个 正 整数数组 nums 。
将 nums 分成两个数组：nums1 和 nums2 ，并满足下述条件：
nums 中的每个元素都属于数组 nums1 或数组 nums2 。分区值的计算方法是 |max(nums1) - min(nums2)| 。
其中，max(nums1) 表示数组 nums1 中的最大元素，min(nums2) 表示数组 nums2 中的最小元素。
返回表示分区值的整数。
+ ++ +
示例 1：
+ +输入：nums = [1,3,2,4] +输出：1 +解释：可以将数组 nums 分成 nums1 = [1,2] 和 nums2 = [3,4] 。 +- 数组 nums1 的最大值等于 2 。 +- 数组 nums2 的最小值等于 3 。 +分区值等于 |2 - 3| = 1 。 +可以证明 1 是所有分区方案的最小值。 ++ +
示例 2：
+ +输入：nums = [100,1,10] +输出：9 +解释：可以将数组 nums 分成 nums1 = [10] 和 nums2 = [100,1] 。 +- 数组 nums1 的最大值等于 10 。 +- 数组 nums2 的最小值等于 1 。 +分区值等于 |10 - 1| = 9 。 +可以证明 9 是所有分区方案的最小值。 ++ +
+ +
提示：
+ +2 <= nums.length <= 1051 <= nums[i] <= 109给你一个下标从 0 开始的整数数组 nums ，它包含 n 个 互不相同 的正整数。如果 nums 的一个排列满足以下条件，我们称它是一个特别的排列：
0 <= i < n - 1 的下标 i ，要么 nums[i] % nums[i+1] == 0 ，要么 nums[i+1] % nums[i] == 0 。请你返回特别排列的总数目，由于答案可能很大，请将它对 109 + 7 取余 后返回。
+ +
示例 1：
+ +输入：nums = [2,3,6] +输出：2 +解释：[3,6,2] 和 [2,6,3] 是 nums 两个特别的排列。 ++ +
示例 2：
+ +输入：nums = [1,4,3] +输出：2 +解释：[3,1,4] 和 [4,1,3] 是 nums 两个特别的排列。 ++ +
+ +
提示：
+ +2 <= nums.length <= 141 <= nums[i] <= 109给你两个长度为 n 下标从 0 开始的整数数组 cost 和 time ，分别表示给 n 堵不同的墙刷油漆需要的开销和时间。你有两名油漆匠：
i 堵墙需要花费 time[i] 单位的时间，开销为 cost[i] 单位的钱。1 单位，开销为 0 。但是必须在付费油漆匠 工作 时，免费油漆匠才会工作。请你返回刷完 n 堵墙最少开销为多少。
+ +
示例 1：
+ +输入：cost = [1,2,3,2], time = [1,2,3,2] +输出：3 +解释：下标为 0 和 1 的墙由付费油漆匠来刷，需要 3 单位时间。同时，免费油漆匠刷下标为 2 和 3 的墙，需要 2 单位时间，开销为 0 。总开销为 1 + 2 = 3 。 ++ +
示例 2：
+ +输入：cost = [2,3,4,2], time = [1,1,1,1] +输出：4 +解释：下标为 0 和 3 的墙由付费油漆匠来刷，需要 2 单位时间。同时，免费油漆匠刷下标为 1 和 2 的墙，需要 2 单位时间，开销为 0 。总开销为 2 + 2 = 4 。 ++ +
+ +
提示：
+ +1 <= cost.length <= 500cost.length == time.length1 <= cost[i] <= 1061 <= time[i] <= 500给你一个下标从 0 开始的数组 words ，数组中包含 互不相同 的字符串。
如果字符串 words[i] 与字符串 words[j] 满足以下条件，我们称它们可以匹配：
words[i] 等于 words[j] 的反转字符串。0 <= i < j < words.length请你返回数组 words 中的 最大 匹配数目。
注意，每个字符串最多匹配一次。
+ ++ +
示例 1：
+ ++输入：words = ["cd","ac","dc","ca","zz"] +输出：2 +解释：在此示例中，我们可以通过以下方式匹配 2 对字符串： +- 我们将第 0 个字符串与第 2 个字符串匹配，因为 word[0] 的反转字符串是 "dc" 并且等于 words[2]。 +- 我们将第 1 个字符串与第 3 个字符串匹配，因为 word[1] 的反转字符串是 "ca" 并且等于 words[3]。 +可以证明最多匹配数目是 2 。 ++ +
示例 2：
+ ++输入：words = ["ab","ba","cc"] +输出：1 +解释：在此示例中，我们可以通过以下方式匹配 1 对字符串： +- 我们将第 0 个字符串与第 1 个字符串匹配，因为 words[1] 的反转字符串 "ab" 与 words[0] 相等。 +可以证明最多匹配数目是 1 。 ++ +
示例 3：
+ ++输入：words = ["aa","ab"] +输出：0 +解释：这个例子中，无法匹配任何字符串。 ++ +
+ +
提示：
+ +1 <= words.length <= 50words[i].length == 2words 包含的字符串互不相同。words[i] 只包含小写英文字母。给你三个整数 x ，y 和 z 。
这三个整数表示你有 x 个 "AA" 字符串，y 个 "BB" 字符串，和 z 个 "AB" 字符串。你需要选择这些字符串中的部分字符串（可以全部选择也可以一个都不选择），将它们按顺序连接得到一个新的字符串。新字符串不能包含子字符串 "AAA" 或者 "BBB" 。
请你返回新字符串的最大可能长度。
+ +子字符串 是一个字符串中一段连续 非空 的字符序列。
+ ++ +
示例 1：
+ ++输入：x = 2, y = 5, z = 1 +输出：12 +解释： 我们可以按顺序连接 "BB" ，"AA" ，"BB" ，"AA" ，"BB" 和 "AB" ，得到新字符串 "BBAABBAABBAB" 。 +字符串长度为 12 ，无法得到一个更长的符合题目要求的字符串。 ++ +
示例 2：
+ ++输入：x = 3, y = 2, z = 2 +输出：14 +解释：我们可以按顺序连接 "AB" ，"AB" ，"AA" ，"BB" ，"AA" ，"BB" 和 "AA" ，得到新字符串 "ABABAABBAABBAA" 。 +字符串长度为 14 ，无法得到一个更长的符合题目要求的字符串。 ++ +
+ +
提示：
+ +1 <= x, y, z <= 50给你一个下标从 0 开始的数组 words ，它包含 n 个字符串。
定义 连接 操作 join(x, y) 表示将字符串 x 和 y 连在一起，得到 xy 。如果 x 的最后一个字符与 y 的第一个字符相等，连接后两个字符中的一个会被 删除 。
比方说 join("ab", "ba") = "aba" ， join("ab", "cde") = "abcde" 。
你需要执行 n - 1 次 连接 操作。令 str0 = words[0] ，从 i = 1 直到 i = n - 1 ，对于第 i 个操作，你可以执行以下操作之一：
stri = join(stri - 1, words[i])stri = join(words[i], stri - 1)你的任务是使 strn - 1 的长度 最小 。
请你返回一个整数，表示 strn - 1 的最小长度。
+ +
示例 1：
+ ++输入：words = ["aa","ab","bc"] +输出：4 +解释：这个例子中，我们按以下顺序执行连接操作，得到+ +str2的最小长度： +str0 = "aa"+str1 = join(str0, "ab") = "aab" +str2 = join(str1, "bc") = "aabc"+str2的最小长度为 4 。
示例 2：
+ +
+输入：words = ["ab","b"]
+输出：2
+解释：这个例子中，str0 = "ab"，可以得到两个不同的 str1：
+join(str0, "b") = "ab" 或者 join("b", str0) = "bab" 。
+第一个字符串 "ab" 的长度最短，所以答案为 2 。
+
+
+示例 3：
+ ++输入：words = ["aaa","c","aba"] +输出：6 +解释：这个例子中，我们按以下顺序执行连接操作，得到+ +str2 的最小长度：+str0 = "aaa" +str1 = join(str0, "c") = "aaac"+str2 = join("aba", str1) = "abaaac"+str2的最小长度为 6 。 +
+ +
提示：
+ +1 <= words.length <= 10001 <= words[i].length <= 50words[i] 中只包含小写英文字母。给你一个整数 n ，表示服务器的总数目，再给你一个下标从 0 开始的 二维 整数数组 logs ，其中 logs[i] = [server_id, time] 表示 id 为 server_id 的服务器在 time 时收到了一个请求。
同时给你一个整数 x 和一个下标从 0 开始的整数数组 queries 。
请你返回一个长度等于 queries.length 的数组 arr ，其中 arr[i] 表示在时间区间 [queries[i] - x, queries[i]] 内没有收到请求的服务器数目。
注意时间区间是个闭区间。
+ ++ +
示例 1：
+ ++输入：n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11] +输出：[1,2] +解释： +对于 queries[0]：id 为 1 和 2 的服务器在区间 [5, 10] 内收到了请求，所以只有服务器 3 没有收到请求。 +对于 queries[1]：id 为 2 的服务器在区间 [6,11] 内收到了请求，所以 id 为 1 和 3 的服务器在这个时间段内没有收到请求。 ++ +
示例 2：
+ ++输入：n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4] +输出：[0,1] +解释： +对于 queries[0]：区间 [1, 3] 内所有服务器都收到了请求。 +对于 queries[1]：只有 id 为 3 的服务器在区间 [2,4] 内没有收到请求。 ++ +
+ +
提示：
+ +1 <= n <= 1051 <= logs.length <= 1051 <= queries.length <= 105logs[i].length == 21 <= logs[i][0] <= n1 <= logs[i][1] <= 1061 <= x <= 105x < queries[i] <= 106给你一个下标从 0 开始的整数数组 nums 。如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对 。
返回 nums 中 美丽下标对 的总数目。
对于两个整数 x 和 y ，如果不存在大于 1 的整数可以整除它们，则认为 x 和 y 互质 。换而言之，如果 gcd(x, y) == 1 ，则认为 x 和 y 互质，其中 gcd(x, y) 是 x 和 k 最大公因数 。
+ +
示例 1：
+ ++输入：nums = [2,5,1,4] +输出：5 +解释：nums 中共有 5 组美丽下标对： +i = 0 和 j = 1 ：nums[0] 的第一个数字是 2 ，nums[1] 的最后一个数字是 5 。2 和 5 互质，因此 gcd(2,5) == 1 。 +i = 0 和 j = 2 ：nums[0] 的第一个数字是 2 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(2,1) == 1 。 +i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1 。2 和 5 互质，因此 gcd(5,1) == 1 。 +i = 1 和 j = 3 ：nums[1] 的第一个数字是 5 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(5,4) == 1 。 +i = 2 和 j = 3 ：nums[2] 的第一个数字是 1 ，nums[3] 的最后一个数字是 4 。2 和 5 互质，因此 gcd(1,4) == 1 。 +因此，返回 5 。 ++ +
示例 2：
+ ++输入：nums = [11,21,12] +输出：2 +解释：共有 2 组美丽下标对： +i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1 。gcd(1,1) == 1 。 +i = 0 和 j = 2 ：nums[0] 的第一个数字是 1 ，nums[2] 的最后一个数字是 2 。gcd(1,2) == 1 。 +因此，返回 2 。+ +
+ +
提示：
+ +2 <= nums.length <= 1001 <= nums[i] <= 9999nums[i] % 10 != 0给你两个整数：num1 和 num2 。
在一步操作中，你需要从范围 [0, 60] 中选出一个整数 i ，并从 num1 减去 2i + num2 。
请你计算，要想使 num1 等于 0 需要执行的最少操作数，并以整数形式返回。
如果无法使 num1 等于 0 ，返回 -1 。
+ +
示例 1：
+ ++输入：num1 = 3, num2 = -2 +输出：3 +解释：可以执行下述步骤使 3 等于 0 ： +- 选择 i = 2 ，并从 3 减去 22 + (-2) ，num1 = 3 - (4 + (-2)) = 1 。 +- 选择 i = 2 ，并从 1 减去 22 + (-2) ，num1 = 1 - (4 + (-2)) = -1 。 +- 选择 i = 0 ，并从 -1 减去 20 + (-2) ，num1 = (-1) - (1 + (-2)) = 0 。 +可以证明 3 是需要执行的最少操作数。 ++ +
示例 2：
+ ++输入：num1 = 5, num2 = 7 +输出：-1 +解释：可以证明，执行操作无法使 5 等于 0 。 ++ +
+ +
提示：
+ +1 <= num1 <= 109-109 <= num2 <= 109给你一个二元数组 nums 。
如果数组中的某个子数组 恰好 只存在 一 个值为 1 的元素，则认为该子数组是一个 好子数组 。
请你统计将数组 nums 划分成若干 好子数组 的方法数，并以整数形式返回。由于数字可能很大，返回其对 109 + 7 取余 之后的结果。
子数组是数组中的一个连续 非空 元素序列。
+ ++ +
示例 1：
+ +输入：nums = [0,1,0,0,1] +输出：3 +解释：存在 3 种可以将 nums 划分成若干好子数组的方式： +- [0,1] [0,0,1] +- [0,1,0] [0,1] +- [0,1,0,0] [1] ++ +
示例 2：
+ +输入：nums = [0,1,0] +输出：1 +解释：存在 1 种可以将 nums 划分成若干好子数组的方式： +- [0,1,0] ++ +
+ +
提示：
+ +1 <= nums.length <= 1050 <= nums[i] <= 1现有 n 个机器人，编号从 1 开始，每个机器人包含在路线上的位置、健康度和移动方向。
给你下标从 0 开始的两个整数数组 positions、healths 和一个字符串 directions（directions[i] 为 'L' 表示 向左 或 'R' 表示 向右）。 positions 中的所有整数 互不相同 。
所有机器人以 相同速度 同时 沿给定方向在路线上移动。如果两个机器人移动到相同位置，则会发生 碰撞 。
+ +如果两个机器人发生碰撞，则将 健康度较低 的机器人从路线中 移除 ，并且另一个机器人的健康度 减少 1 。幸存下来的机器人将会继续沿着与之前 相同 的方向前进。如果两个机器人的健康度相同，则将二者都从路线中移除。
+ +请你确定全部碰撞后幸存下的所有机器人的 健康度 ，并按照原来机器人编号的顺序排列。即机器人 1 （如果幸存）的最终健康度，机器人 2 （如果幸存）的最终健康度等。 如果不存在幸存的机器人，则返回空数组。
+ +在不再发生任何碰撞后，请你以数组形式，返回所有剩余机器人的健康度（按机器人输入中的编号顺序）。
+ +注意：位置 positions 可能是乱序的。
+ +
示例 1：
+ +
+输入：positions = [5,4,3,2,1], healths = [2,17,9,15,10], directions = "RRRRR" +输出：[2,17,9,15,10] +解释：在本例中不存在碰撞，因为所有机器人向同一方向移动。所以，从第一个机器人开始依序返回健康度，[2, 17, 9, 15, 10] 。 ++ +
示例 2：
+ +
+输入：positions = [3,5,2,6], healths = [10,10,15,12], directions = "RLRL" +输出：[14] +解释：本例中发生 2 次碰撞。首先，机器人 1 和机器人 2 将会碰撞，因为二者健康度相同，二者都将被从路线中移除。接下来，机器人 3 和机器人 4 将会发生碰撞，由于机器人 4 的健康度更小，则它会被移除，而机器人 3 的健康度变为 15 - 1 = 14 。仅剩机器人 3 ，所以返回 [14] 。 ++ +
示例 3：
+ +
+输入：positions = [1,2,5,6], healths = [10,10,11,11], directions = "RLRL" +输出：[] +解释：机器人 1 和机器人 2 将会碰撞，因为二者健康度相同，二者都将被从路线中移除。机器人 3 和机器人 4 将会碰撞，因为二者健康度相同，二者都将被从路线中移除。所以返回空数组 [] 。+ +
+ +
提示：
+ +1 <= positions.length == healths.length == directions.length == n <= 1051 <= positions[i], healths[i] <= 109directions[i] == 'L' 或 directions[i] == 'R'positions 中的所有值互不相同给你一个下标从 0 开始的整数数组 nums 和一个整数 threshold 。
请你从 nums 的子数组中找出以下标 l 开头、下标 r 结尾 (0 <= l <= r < nums.length) 且满足以下条件的 最长子数组 ：
nums[l] % 2 == 0[l, r - 1] 内的所有下标 i ，nums[i] % 2 != nums[i + 1] % 2[l, r] 内的所有下标 i ，nums[i] <= threshold以整数形式返回满足题目要求的最长子数组的长度。
+ +注意：子数组 是数组中的一个连续非空元素序列。
+ ++ +
示例 1：
+ +输入：nums = [3,2,5,4], threshold = 5 +输出：3 +解释：在这个示例中，我们选择从 l = 1 开始、到 r = 3 结束的子数组 => [2,5,4] ，满足上述条件。 +因此，答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。+ +
示例 2：
+ +输入：nums = [1,2], threshold = 2 +输出：1 +解释： +在这个示例中，我们选择从 l = 1 开始、到 r = 1 结束的子数组 => [2] 。 +该子数组满足上述全部条件。可以证明 1 是满足题目要求的最大长度。 ++ +
示例 3：
+ +输入：nums = [2,3,4,5], threshold = 4 +输出：3 +解释： +在这个示例中，我们选择从 l = 0 开始、到 r = 2 结束的子数组 => [2,3,4] 。 +该子数组满足上述全部条件。 +因此，答案就是这个子数组的长度 3 。可以证明 3 是满足题目要求的最大长度。+ +
+ +
提示：
+ +1 <= nums.length <= 100 1 <= nums[i] <= 100 1 <= threshold <= 100给你一个整数 n 。如果两个整数 x 和 y 满足下述条件，则认为二者形成一个质数对：
1 <= x <= y <= nx + y == nx 和 y 都是质数请你以二维有序列表的形式返回符合题目要求的所有 [xi, yi] ，列表需要按 xi 的 非递减顺序 排序。如果不存在符合要求的质数对，则返回一个空数组。
注意：质数是大于 1 的自然数，并且只有两个因子，即它本身和 1 。
+ +
示例 1：
+ +输入：n = 10 +输出：[[3,7],[5,5]] +解释：在这个例子中，存在满足条件的两个质数对。 +这两个质数对分别是 [3,7] 和 [5,5]，按照题面描述中的方式排序后返回。 ++ +
示例 2：
+ +输入：n = 2 +输出：[] +解释：可以证明不存在和为 2 的质数对，所以返回一个空数组。 ++ +
+ +
提示：
+ +1 <= n <= 106给你一个下标从 0 开始的整数数组 nums 。nums 的一个子数组如果满足以下条件，那么它是 不间断 的：
i，i + 1 ，...，j 表示子数组中的下标。对于所有满足 i <= i1, i2 <= j 的下标对，都有 0 <= |nums[i1] - nums[i2]| <= 2 。请你返回 不间断 子数组的总数目。
+ +子数组是一个数组中一段连续 非空 的元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [5,4,2,4] +输出：8 +解释： +大小为 1 的不间断子数组：[5], [4], [2], [4] 。 +大小为 2 的不间断子数组：[5,4], [4,2], [2,4] 。 +大小为 3 的不间断子数组：[4,2,4] 。 +没有大小为 4 的不间断子数组。 +不间断子数组的总数目为 4 + 3 + 1 = 8 。 +除了这些以外，没有别的不间断子数组。 ++ +
示例 2：
+ ++输入：nums = [1,2,3] +输出：6 +解释： +大小为 1 的不间断子数组：[1], [2], [3] 。 +大小为 2 的不间断子数组：[1,2], [2,3] 。 +大小为 3 的不间断子数组：[1,2,3] 。 +不间断子数组的总数目为 3 + 2 + 1 = 6 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 109一个长度为 n 下标从 0 开始的整数数组 arr 的 不平衡数字 定义为，在 sarr = sorted(arr) 数组中，满足以下条件的下标数目：
0 <= i < n - 1 ，和sarr[i+1] - sarr[i] > 1这里，sorted(arr) 表示将数组 arr 排序后得到的数组。
给你一个下标从 0 开始的整数数组 nums ，请你返回它所有 子数组 的 不平衡数字 之和。
子数组指的是一个数组中连续一段 非空 的元素序列。
+ ++ +
示例 1：
+ +输入：nums = [2,3,1,4] +输出：3 +解释：总共有 3 个子数组有非 0 不平衡数字： +- 子数组 [3, 1] ，不平衡数字为 1 。 +- 子数组 [3, 1, 4] ，不平衡数字为 1 。 +- 子数组 [1, 4] ，不平衡数字为 1 。 +其他所有子数组的不平衡数字都是 0 ，所以所有子数组的不平衡数字之和为 3 。 ++ +
示例 2：
+ +输入：nums = [1,3,3,3,5] +输出：8 +解释：总共有 7 个子数组有非 0 不平衡数字： +- 子数组 [1, 3] ，不平衡数字为 1 。 +- 子数组 [1, 3, 3] ，不平衡数字为 1 。 +- 子数组 [1, 3, 3, 3] ，不平衡数字为 1 。 +- 子数组 [1, 3, 3, 3, 5] ，不平衡数字为 2 。 +- 子数组 [3, 3, 3, 5] ，不平衡数字为 1 。 +- 子数组 [3, 3, 5] ，不平衡数字为 1 。 +- 子数组 [3, 5] ，不平衡数字为 1 。 +其他所有子数组的不平衡数字都是 0 ，所以所有子数组的不平衡数字之和为 8 。+ +
+ +
提示：
+ +1 <= nums.length <= 10001 <= nums[i] <= nums.length给你一个下标从 0 开始的整数数组 nums 。如果 nums 中长度为 m 的子数组 s 满足以下条件，我们称它是一个 交替子序列 ：
m 大于 1 。s1 = s0 + 1 。s 与数组 [s0, s1, s0, s1,...,s(m-1) % 2] 一样。也就是说，s1 - s0 = 1 ，s2 - s1 = -1 ，s3 - s2 = 1 ，s4 - s3 = -1 ，以此类推，直到 s[m - 1] - s[m - 2] = (-1)m 。请你返回 nums 中所有 交替 子数组中，最长的长度，如果不存在交替子数组，请你返回 -1 。
子数组是一个数组中一段连续 非空 的元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [2,3,4,3,4] +输出：4 +解释：交替子数组有 [3,4] ，[3,4,3] 和 [3,4,3,4] 。最长的子数组为 [3,4,3,4] ，长度为4 。 ++ +
示例 2：
+ ++输入：nums = [4,5,6] +输出：2 +解释：[4,5] 和 [5,6] 是仅有的两个交替子数组。它们长度都为 2 。 ++ +
+ +
提示：
+ +2 <= nums.length <= 1001 <= nums[i] <= 104给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。
在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。
完成这些操作后，请你按升序返回所有 有 石块的位置。
+ +注意：
+ ++ +
示例 1：
+ ++输入：nums = [1,6,7,8], moveFrom = [1,7,2], moveTo = [2,9,5] +输出：[5,6,8,9] +解释：一开始，石块在位置 1,6,7,8 。 +第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。 +第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。 +第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。 +最后，至少有一个石块的位置为 [5,6,8,9] 。+ +
示例 2：
+ ++输入：nums = [1,1,3,3], moveFrom = [1,3], moveTo = [2,2] +输出：[2] +解释：一开始，石块在位置 [1,1,3,3] 。 +第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3] 。 +第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2] 。 +由于 2 是唯一有石块的位置，我们返回 [2] 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= moveFrom.length <= 105moveFrom.length == moveTo.length1 <= nums[i], moveFrom[i], moveTo[i] <= 109i 步操作时，moveFrom[i] 处至少有一个石块。给你一个二进制字符串 s ，你需要将字符串分割成一个或者多个 子字符串 ，使每个子字符串都是 美丽 的。
如果一个字符串满足以下条件，我们称它是 美丽 的：
+ +5 的幂的 二进制 表示。请你返回分割后的子字符串的 最少 数目。如果无法将字符串 s 分割成美丽子字符串，请你返回 -1 。
子字符串是一个字符串中一段连续的字符序列。
+ ++ +
示例 1：
+ +输入：s = "1011" +输出：2 +解释：我们可以将输入字符串分成 ["101", "1"] 。 +- 字符串 "101" 不包含前导 0 ，且它是整数 51 = 5 的二进制表示。 +- 字符串 "1" 不包含前导 0 ，且它是整数 50 = 1 的二进制表示。 +最少可以将 s 分成 2 个美丽子字符串。 ++ +
示例 2：
+ +输入：s = "111" +输出：3 +解释：我们可以将输入字符串分成 ["1", "1", "1"] 。 +- 字符串 "1" 不包含前导 0 ，且它是整数 50 = 1 的二进制表示。 +最少可以将 s 分成 3 个美丽子字符串。 ++ +
示例 3：
+ +输入：s = "0" +输出：-1 +解释：无法将给定字符串分成任何美丽子字符串。 ++ +
+ +
提示：
+ +1 <= s.length <= 15s[i] 要么是 '0' 要么是 '1' 。给你两个整数 m 和 n ，表示一个下标从 0 开始的 m x n 的网格图。
给你一个下标从 0 开始的二维整数矩阵 coordinates ，其中 coordinates[i] = [x, y] 表示坐标为 [x, y] 的格子是 黑色的 ，所有没出现在 coordinates 中的格子都是 白色的。
一个块定义为网格图中 2 x 2 的一个子矩阵。更正式的，对于左上角格子为 [x, y] 的块，其中 0 <= x < m - 1 且 0 <= y < n - 1 ，包含坐标为 [x, y] ，[x + 1, y] ，[x, y + 1] 和 [x + 1, y + 1] 的格子。
请你返回一个下标从 0 开始长度为 5 的整数数组 arr ，arr[i] 表示恰好包含 i 个 黑色 格子的块的数目。
+ +
示例 1：
+ ++输入：m = 3, n = 3, coordinates = [[0,0]] +输出：[3,1,0,0,0] +解释：网格图如下： ++ ++只有 1 个块有一个黑色格子，这个块是左上角为 [0,0] 的块。 +其他 3 个左上角分别为 [0,1] ，[1,0] 和 [1,1] 的块都有 0 个黑格子。 +所以我们返回 [3,1,0,0,0] 。 +
示例 2：
+ ++输入：m = 3, n = 3, coordinates = [[0,0],[1,1],[0,2]] +输出：[0,2,2,0,0] +解释：网格图如下： ++ ++有 2 个块有 2 个黑色格子（左上角格子分别为 [0,0] 和 [0,1]）。 +左上角为 [1,0] 和 [1,1] 的两个块，都有 1 个黑格子。 +所以我们返回 [0,2,2,0,0] 。 +
+ +
提示：
+ +2 <= m <= 1052 <= n <= 1050 <= coordinates.length <= 104coordinates[i].length == 20 <= coordinates[i][0] < m0 <= coordinates[i][1] < ncoordinates 中的坐标对两两互不相同。给你两个整数 num 和 t 。
如果整数 x 可以在执行下述操作不超过 t 次的情况下变为与 num 相等，则称其为 可达成数字 ：
x 的值增加或减少 1 ，同时可以选择将 num 的值增加或减少 1 。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。
+ ++ +
示例 1：
+ +输入：num = 4, t = 1 +输出：6 +解释：最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ： +- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 +可以证明不存在大于 6 的可达成数字。 ++ +
示例 2：
+ +输入：num = 3, t = 2 +输出：7 +解释：最大的可达成数字是 x = 7 ，执行下述操作可以使其等于 num ： +- x 减少 1 ，同时 num 增加 1 。此时，x = 6 且 num = 4 。 +- x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 +可以证明不存在大于 7 的可达成数字。 ++ +
+ +
提示：
+ +1 <= num, t <= 50给你一个下标从 0 开始、由 n 个整数组成的数组 nums 和一个整数 target 。
你的初始位置在下标 0 。在一步操作中，你可以从下标 i 跳跃到任意满足下述条件的下标 j ：
0 <= i < j < n-target <= nums[j] - nums[i] <= target返回到达下标 n - 1 处所需的 最大跳跃次数 。
如果无法到达下标 n - 1 ，返回 -1 。
+ +
示例 1：
+ +输入：nums = [1,3,6,4,1,2], target = 2 +输出：3 +解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作： +- 从下标 0 跳跃到下标 1 。 +- 从下标 1 跳跃到下标 3 。 +- 从下标 3 跳跃到下标 5 。 +可以证明，从 0 到 n - 1 的所有方案中，不存在比 3 步更长的跳跃序列。因此，答案是 3 。+ +
示例 2：
+ +输入：nums = [1,3,6,4,1,2], target = 3 +输出：5 +解释：要想以最大跳跃次数从下标 0 到下标 n - 1 ，可以按下述跳跃序列执行操作： +- 从下标 0 跳跃到下标 1 。 +- 从下标 1 跳跃到下标 2 。 +- 从下标 2 跳跃到下标 3 。 +- 从下标 3 跳跃到下标 4 。 +- 从下标 4 跳跃到下标 5 。 +可以证明，从 0 到 n - 1 的所有方案中，不存在比 5 步更长的跳跃序列。因此，答案是 5 。+ +
示例 3：
+ +输入：nums = [1,3,6,4,1,2], target = 0 +输出：-1 +解释：可以证明不存在从 0 到 n - 1 的跳跃序列。因此，答案是 -1 。 ++ +
+ +
提示：
+ +2 <= nums.length == n <= 1000-109 <= nums[i] <= 1090 <= target <= 2 * 109给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，长度均为 n 。
让我们定义另一个下标从 0 开始、长度为 n 的整数数组，nums3 。对于范围 [0, n - 1] 的每个下标 i ，你可以将 nums1[i] 或 nums2[i] 的值赋给 nums3[i] 。
你的任务是使用最优策略为 nums3 赋值，以最大化 nums3 中 最长非递减子数组 的长度。
以整数形式表示并返回 nums3 中 最长非递减 子数组的长度。
注意：子数组 是数组中的一个连续非空元素序列。
+ ++ +
示例 1：
+ +输入：nums1 = [2,3,1], nums2 = [1,2,1] +输出：2 +解释：构造 nums3 的方法之一是： +nums3 = [nums1[0], nums2[1], nums2[2]] => [2,2,1] +从下标 0 开始到下标 1 结束，形成了一个长度为 2 的非递减子数组 [2,2] 。 +可以证明 2 是可达到的最大长度。+ +
示例 2：
+ +输入：nums1 = [1,3,2,1], nums2 = [2,2,3,4] +输出：4 +解释：构造 nums3 的方法之一是： +nums3 = [nums1[0], nums2[1], nums2[2], nums2[3]] => [1,2,3,4] +整个数组形成了一个长度为 4 的非递减子数组，并且是可达到的最大长度。 ++ +
示例 3：
+ +输入：nums1 = [1,1], nums2 = [2,2] +输出：2 +解释：构造 nums3 的方法之一是： +nums3 = [nums1[0], nums1[1]] => [1,1] +整个数组形成了一个长度为 2 的非递减子数组，并且是可达到的最大长度。 ++ +
+ +
提示：
+ +1 <= nums1.length == nums2.length == n <= 1051 <= nums1[i], nums2[i] <= 109给你一个下标从 0 开始的整数数组 nums 和一个正整数 k 。
你可以对数组执行下述操作 任意次 ：
+ +k 的 任一 子数组，并将子数组中每个元素都 减去 1 。如果你可以使数组中的所有元素都等于 0 ，返回 true ；否则，返回 false 。
子数组 是数组中的一个非空连续元素序列。
+ ++ +
示例 1：
+ +输入：nums = [2,2,3,1,1,0], k = 3 +输出：true +解释：可以执行下述操作： +- 选出子数组 [2,2,3] ，执行操作后，数组变为 nums = [1,1,2,1,1,0] 。 +- 选出子数组 [2,1,1] ，执行操作后，数组变为 nums = [1,1,1,0,0,0] 。 +- 选出子数组 [1,1,1] ，执行操作后，数组变为 nums = [0,0,0,0,0,0] 。 ++ +
示例 2：
+ +输入：nums = [1,3,1,1], k = 2 +输出：false +解释：无法使数组中的所有元素等于 0 。 ++ +
+ +
提示：
+ +1 <= k <= nums.length <= 1050 <= nums[i] <= 106给你一个下标从 1 开始、长度为 n 的整数数组 nums 。
对 nums 中的元素 nums[i] 而言，如果 n 能够被 i 整除，即 n % i == 0 ，则认为 num[i] 是一个 特殊元素 。
返回 nums 中所有 特殊元素 的 平方和 。
+ +
示例 1：
+ +输入：nums = [1,2,3,4] +输出：21 +解释：nums 中共有 3 个特殊元素：nums[1] ，因为 4 被 1 整除；nums[2] ，因为 4 被 2 整除；以及 nums[4] ，因为 4 被 4 整除。 +因此，nums 中所有元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[4] * nums[4] = 1 * 1 + 2 * 2 + 4 * 4 = 21 。 ++ +
示例 2：
+ +输入：nums = [2,7,1,19,18,3] +输出：63 +解释：nums 中共有 4 个特殊元素：nums[1] ，因为 6 被 1 整除；nums[2] ，因为 6 被 2 整除；nums[3] ，因为 6 被 3 整除；以及 nums[6] ，因为 6 被 6 整除。 +因此，nums 中所有元素的平方和等于 nums[1] * nums[1] + nums[2] * nums[2] + nums[3] * nums[3] + nums[6] * nums[6] = 2 * 2 + 7 * 7 + 1 * 1 + 3 * 3 = 63 。+ +
+ +
提示：
+ +1 <= nums.length == n <= 501 <= nums[i] <= 50给你一个下标从 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 <= 1050 <= nums[i], k <= 105如果元素 x 在长度为 m 的整数数组 arr 中满足 freq(x) * 2 > m ，那么我们称 x 是 支配元素 。其中 freq(x) 是 x 在数组 arr 中出现的次数。注意，根据这个定义，数组 arr 最多 只会有 一个 支配元素。
给你一个下标从 0 开始长度为 n 的整数数组 nums ，数据保证它含有一个支配元素。
你需要在下标 i 处将 nums 分割成两个数组 nums[0, ..., i] 和 nums[i + 1, ..., n - 1] ，如果一个分割满足以下条件，我们称它是 合法 的：
0 <= i < n - 1nums[0, ..., i] 和 nums[i + 1, ..., n - 1] 的支配元素相同。这里， nums[i, ..., j] 表示 nums 的一个子数组，它开始于下标 i ，结束于下标 j ，两个端点都包含在子数组内。特别地，如果 j < i ，那么 nums[i, ..., j] 表示一个空数组。
请你返回一个 合法分割 的 最小 下标。如果合法分割不存在，返回 -1 。
+ +
示例 1：
+ +输入：nums = [1,2,2,2] +输出：2 +解释：我们将数组在下标 2 处分割，得到 [1,2,2] 和 [2] 。 +数组 [1,2,2] 中，元素 2 是支配元素，因为它在数组中出现了 2 次，且 2 * 2 > 3 。 +数组 [2] 中，元素 2 是支配元素，因为它在数组中出现了 1 次，且 1 * 2 > 1 。 +两个数组 [1,2,2] 和 [2] 都有与 nums 一样的支配元素，所以这是一个合法分割。 +下标 2 是合法分割中的最小下标。+ +
示例 2：
+ +输入：nums = [2,1,3,1,1,1,7,1,2,1] +输出：4 +解释：我们将数组在下标 4 处分割，得到 [2,1,3,1,1] 和 [1,7,1,2,1] 。 +数组 [2,1,3,1,1] 中，元素 1 是支配元素，因为它在数组中出现了 3 次，且 3 * 2 > 5 。 +数组 [1,7,1,2,1] 中，元素 1 是支配元素，因为它在数组中出现了 3 次，且 3 * 2 > 5 。 +两个数组 [2,1,3,1,1] 和 [1,7,1,2,1] 都有与 nums 一样的支配元素，所以这是一个合法分割。 +下标 4 是所有合法分割中的最小下标。+ +
示例 3：
+ +输入：nums = [3,3,3,3,7,2,2] +输出：-1 +解释：没有合法分割。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 109nums 有且只有一个支配元素。给你一个字符串 word 和一个字符串数组 forbidden 。
如果一个字符串不包含 forbidden 中的任何字符串，我们称这个字符串是 合法 的。
请你返回字符串 word 的一个 最长合法子字符串 的长度。
子字符串 指的是一个字符串中一段连续的字符，它可以为空。
+ ++ +
示例 1：
+ ++输入：word = "cbaaaabc", forbidden = ["aaa","cb"] +输出：4 +解释：总共有 11 个合法子字符串："c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc" 和 "aabc"。最长合法子字符串的长度为 4 。 +其他子字符串都要么包含 "aaa" ，要么包含 "cb" 。+ +
示例 2：
+ ++输入：word = "leetcode", forbidden = ["de","le","e"] +输出：4 +解释：总共有 11 个合法子字符串："l" ，"t" ，"c" ，"o" ，"d" ，"tc" ，"co" ，"od" ，"tco" ，"cod" 和 "tcod" 。最长合法子字符串的长度为 4 。 +所有其他子字符串都至少包含 "de" ，"le" 和 "e" 之一。 ++ +
+ +
提示：
+ +1 <= word.length <= 105word 只包含小写英文字母。1 <= forbidden.length <= 1051 <= forbidden[i].length <= 10forbidden[i] 只包含小写英文字母。给你一个整数数组 nums ，如果它是数组 base[n] 的一个排列，我们称它是个 好 数组。
base[n] = [1, 2, ..., n - 1, n, n] （换句话说，它是一个长度为 n + 1 且包含 1 到 n - 1 恰好各一次，包含 n 两次的一个数组）。比方说，base[1] = [1, 1] ，base[3] = [1, 2, 3, 3] 。
如果数组是一个好数组，请你返回 true ，否则返回 false 。
注意：数组的排列是这些数字按任意顺序排布后重新得到的数组。
+ ++ +
示例 1：
+ +输入：nums = [2, 1, 3] +输出：false +解释：因为数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 。但是 base[3] 有 4 个元素，但数组 nums 只有 3 个元素，所以无法得到 base[3] = [1, 2, 3, 3] 的排列，所以答案为 false 。 ++ +
示例 2：
+ +输入：nums = [1, 3, 3, 2] +输出：true +解释：因为数组的最大元素是 3 ，唯一可以构成这个数组的 base[n] 对应的 n = 3 ，可以看出数组是 base[3] = [1, 2, 3, 3] 的一个排列（交换 nums 中第二个和第四个元素）。所以答案为 true 。+ +
示例 3：
+ +输入：nums = [1, 1] +输出：true +解释：因为数组的最大元素是 1 ，唯一可以构成这个数组的 base[n] 对应的 n = 1，可以看出数组是 base[1] = [1, 1] 的一个排列。所以答案为 true 。+ +
示例 4：
+ +输入：nums = [3, 4, 4, 1, 2, 1] +输出：false +解释：因为数组的最大元素是 4 ，唯一可以构成这个数组的 base[n] 对应的 n = 4 。但是 base[n] 有 5 个元素而 nums 有 6 个元素。所以答案为 false 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1001 <= num[i] <= 200给你一个下标从 0 开始的字符串 s ，将 s 中的元素重新 排列 得到新的字符串 t ，它满足：
0 <= i < s.length 的下标 i 处的 s[i] 是个辅音字母，那么 t[i] = s[i] 。0 <= i < j < s.length 的下标 i 和 j ，如果 s[i] 和 s[j] 都是元音字母，那么 t[i] 的 ASCII 值不能大于 t[j] 的 ASCII 值。请你返回结果字母串。
+ +元音字母为 'a' ，'e' ，'i' ，'o' 和 'u' ，它们可能是小写字母也可能是大写字母，辅音字母是除了这 5 个字母以外的所有字母。
+ +
示例 1：
+ ++输入：s = "lEetcOde" +输出："lEOtcede" +解释：'E' ，'O' 和 'e' 是 s 中的元音字母，'l' ，'t' ，'c' 和 'd' 是所有的辅音。将元音字母按照 ASCII 值排序，辅音字母留在原地。 ++ +
示例 2：
+ ++输入：s = "lYmpH" +输出："lYmpH" +解释：s 中没有元音字母（s 中都为辅音字母），所以我们返回 "lYmpH" 。 ++ +
+ +
提示：
+ +1 <= s.length <= 105s 只包含英语字母表中的 大写 和 小写 字母。给你一个下标从 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 <= 1051 <= nums[i], x <= 106给你两个 正 整数 n 和 x 。
请你返回将 n 表示成一些 互不相同 正整数的 x 次幂之和的方案数。换句话说，你需要返回互不相同整数 [n1, n2, ..., nk] 的集合数目，满足 n = n1x + n2x + ... + nkx 。
由于答案可能非常大，请你将它对 109 + 7 取余后返回。
比方说，n = 160 且 x = 3 ，一个表示 n 的方法是 n = 23 + 33 + 53 。
+ +
示例 1：
+ +输入：n = 10, x = 2 +输出：1 +解释：我们可以将 n 表示为：n = 32 + 12 = 10 。 +这是唯一将 10 表达成不同整数 2 次方之和的方案。 ++ +
示例 2：
+ +输入：n = 4, x = 1 +输出：2 +解释：我们可以将 n 按以下方案表示： +- n = 41 = 4 。 +- n = 31 + 11 = 4 。 ++ +
+ +
提示：
+ +1 <= n <= 3001 <= x <= 5给你一个字符串数组 words 和一个字符 separator ，请你按 separator 拆分 words 中的每个字符串。
返回一个由拆分后的新字符串组成的字符串数组，不包括空字符串 。
+ +注意
+ +separator 用于决定拆分发生的位置，但它不包含在结果字符串中。+ +
示例 1：
+ ++输入：words = ["one.two.three","four.five","six"], separator = "." +输出：["one","two","three","four","five","six"] +解释：在本示例中，我们进行下述拆分： + +"one.two.three" 拆分为 "one", "two", "three" +"four.five" 拆分为 "four", "five" +"six" 拆分为 "six" + +因此，结果数组为 ["one","two","three","four","five","six"] 。+ +
示例 2：
+ ++输入：words = ["$easy$","$problem$"], separator = "$" +输出：["easy","problem"] +解释：在本示例中，我们进行下述拆分： + +"$easy$" 拆分为 "easy"（不包括空字符串） +"$problem$" 拆分为 "problem"（不包括空字符串） + +因此，结果数组为 ["easy","problem"] 。 ++ +
示例 3：
+ ++输入：words = ["|||"], separator = "|" +输出：[] +解释：在本示例中，"|||" 的拆分结果将只包含一些空字符串，所以我们返回一个空数组 [] 。+ +
+ +
提示：
+ +1 <= words.length <= 1001 <= words[i].length <= 20words[i] 中的字符要么是小写英文字母，要么就是字符串 ".,|$#@" 中的字符（不包括引号）separator 是字符串 ".,|$#@" 中的某个字符（不包括引号）给你一个下标从 0 开始、由正整数组成的数组 nums 。
你可以在数组上执行下述操作 任意 次：
+ +0 <= i < nums.length - 1 和 nums[i] <= nums[i + 1] 的整数 i 。将元素 nums[i + 1] 替换为 nums[i] + nums[i + 1] ，并从数组中删除元素 nums[i] 。返回你可以从最终数组中获得的 最大 元素的值。
+ ++ +
示例 1：
+ +输入：nums = [2,3,7,9,3] +输出：21 +解释：我们可以在数组上执行下述操作： +- 选中 i = 0 ，得到数组 nums = [5,7,9,3] 。 +- 选中 i = 1 ，得到数组 nums = [5,16,3] 。 +- 选中 i = 0 ，得到数组 nums = [21,3] 。 +最终数组中的最大元素是 21 。可以证明我们无法获得更大的元素。 ++ +
示例 2：
+ +输入：nums = [5,3,3] +输出：11 +解释：我们可以在数组上执行下述操作： +- 选中 i = 1 ，得到数组 nums = [5,6] 。 +- 选中 i = 0 ，得到数组 nums = [11] 。 +最终数组中只有一个元素，即 11 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 106给你一个下标从 0 开始、长度为 n 的数组 usageLimits 。
你的任务是使用从 0 到 n - 1 的数字创建若干组，并确保每个数字 i 在 所有组 中使用的次数总共不超过 usageLimits[i] 次。此外，还必须满足以下条件：
在满足所有条件的情况下，以整数形式返回可以创建的最大组数。
+ ++ +
示例 1：
+ +
+输入：usageLimits = [1,2,5]
+输出：3
+解释：在这个示例中，我们可以使用 0 至多一次，使用 1 至多 2 次，使用 2 至多 5 次。
+一种既能满足所有条件，又能创建最多组的方式是：
+组 1 包含数字 [2] 。
+组 2 包含数字 [1,2] 。
+组 3 包含数字 [0,1,2] 。
+可以证明能够创建的最大组数是 3 。
+所以，输出是 3 。
+
+示例 2：
+ +++ +输入：usageLimits= [2,1,2] +输出：2 +解释：在这个示例中，我们可以使用 0 至多 2 次，使用 1 至多 1 次，使用 2 至多 2 次。 +一种既能满足所有条件，又能创建最多组的方式是： +组 1 包含数字 [0] 。 +组 2 包含数字 [1,2] 。 +可以证明能够创建的最大组数是 2 。 +所以，输出是 2 。 +
示例 3：
+ +++ +输入：usageLimits= [1,1] +输出：1 +解释：在这个示例中，我们可以使用 0 和 1 至多 1 次。 +一种既能满足所有条件，又能创建最多组的方式是： +组 1 包含数字 [0] 。 +可以证明能够创建的最大组数是 1 。 +所以，输出是 1 。 +
+ +
提示：
+ +1 <= usageLimits.length <= 1051 <= usageLimits[i] <= 109给你一棵 树（即，一个连通、无向且无环的图），根 节点为 0 ，由编号从 0 到 n - 1 的 n 个节点组成。这棵树用一个长度为 n 、下标从 0 开始的数组 parent 表示，其中 parent[i] 为节点 i 的父节点，由于节点 0 为根节点，所以 parent[0] == -1 。
另给你一个长度为 n 的字符串 s ，其中 s[i] 是分配给 i 和 parent[i] 之间的边的字符。s[0] 可以忽略。
找出满足 u < v ，且从 u 到 v 的路径上分配的字符可以 重新排列 形成 回文 的所有节点对 (u, v) ，并返回节点对的数目。
如果一个字符串正着读和反着读都相同，那么这个字符串就是一个 回文 。
+ ++ +
示例 1：
+ +
+输入：parent = [-1,0,0,1,1,2], s = "acaabc" +输出：8 +解释：符合题目要求的节点对分别是： +- (0,1)、(0,2)、(1,3)、(1,4) 和 (2,5) ，路径上只有一个字符，满足回文定义。 +- (2,3)，路径上字符形成的字符串是 "aca" ，满足回文定义。 +- (1,5)，路径上字符形成的字符串是 "cac" ，满足回文定义。 +- (3,5)，路径上字符形成的字符串是 "acac" ，可以重排形成回文 "acca" 。 ++ +
示例 2：
+ ++输入：parent = [-1,0,0,0,0], s = "aaaaa" +输出：10 +解释：任何满足 u < v 的节点对 (u,v) 都符合题目要求。 ++ +
+ +
提示：
+ +n == parent.length == s.length1 <= n <= 105i >= 1 ，0 <= parent[i] <= n - 1 均成立parent[0] == -1parent 表示一棵有效的树s 仅由小写英文字母组成公司里共有 n 名员工，按从 0 到 n - 1 编号。每个员工 i 已经在公司工作了 hours[i] 小时。
公司要求每位员工工作 至少 target 小时。
给你一个下标从 0 开始、长度为 n 的非负整数数组 hours 和一个非负整数 target 。
请你用整数表示并返回工作至少 target 小时的员工数。
+ +
示例 1：
+ +输入：hours = [0,1,2,3,4], target = 2 +输出：3 +解释：公司要求每位员工工作至少 2 小时。 +- 员工 0 工作 0 小时，不满足要求。 +- 员工 1 工作 1 小时，不满足要求。 +- 员工 2 工作 2 小时，满足要求。 +- 员工 3 工作 3 小时，满足要求。 +- 员工 4 工作 4 小时，满足要求。 +共有 3 位满足要求的员工。 ++ +
示例 2：
+ +输入：hours = [5,1,4,2,2], target = 6 +输出：0 +解释：公司要求每位员工工作至少 6 小时。 +共有 0 位满足要求的员工。 ++ +
+ +
提示：
+ +1 <= n == hours.length <= 500 <= hours[i], target <= 105给你一个由 正 整数组成的数组 nums 。
如果数组中的某个子数组满足下述条件，则称之为 完全子数组 ：
+ +返回数组中 完全子数组 的数目。
+ +子数组 是数组中的一个连续非空序列。
+ ++ +
示例 1：
+ +输入：nums = [1,3,1,2,2] +输出：4 +解释：完全子数组有：[1,3,1,2]、[1,3,1,2,2]、[3,1,2] 和 [3,1,2,2] 。 ++ +
示例 2：
+ +输入：nums = [5,5,5,5] +输出：10 +解释：数组仅由整数 5 组成，所以任意子数组都满足完全子数组的条件。子数组的总数为 10 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 10001 <= nums[i] <= 2000a ，b 和 c ， 你的任务是找到长度 最短 的字符串，且这三个字符串都是它的 子字符串 。
+如果有多个这样的字符串，请你返回 字典序最小 的一个。
+ +请你返回满足题目要求的字符串。
+ +注意：
+ +a 和 b ，如果在第一个不相同的字符处，a 的字母在字母表中比 b 的字母 靠前 ，那么字符串 a 比字符串 b 字典序小 。+ +
示例 1：
+ ++ +输入：a= "abc",b= "bca",c= "aaa" +输出："aaabca" +解释：字符串 "aaabca" 包含所有三个字符串：a = ans[2...4] ，b = ans[3..5] ，c = ans[0..2] 。结果字符串的长度至少为 6 ，且"aaabca" 是字典序最小的一个。
示例 2：
+ ++ +输入：a= "ab",b= "ba",c= "aba" +输出："aba" +解释：字符串 "aba" 包含所有三个字符串：a = ans[0..1] ，b = ans[1..2] ，c = ans[0..2] 。由于 c 的长度为 3 ，结果字符串的长度至少为 3 。"aba" 是字典序最小的一个。 +
+ +
提示：
+ +1 <= a.length, b.length, c.length <= 100a ，b ，c 只包含小写英文字母。给你两个正整数 low 和 high ，都用字符串表示，请你统计闭区间 [low, high] 内的 步进数字 数目。
如果一个整数相邻数位之间差的绝对值都 恰好 是 1 ，那么这个数字被称为 步进数字 。
请你返回一个整数，表示闭区间 [low, high] 之间步进数字的数目。
由于答案可能很大，请你将它对 109 + 7 取余 后返回。
注意：步进数字不能有前导 0 。
+ ++ +
示例 1：
+ +输入：low = "1", high = "11" +输出：10 +解释：区间 [1,11] 内的步进数字为 1 ，2 ，3 ，4 ，5 ，6 ，7 ，8 ，9 和 10 。总共有 10 个步进数字。所以输出为 10 。+ +
示例 2：
+ +输入：low = "90", high = "101" +输出：2 +解释：区间 [90,101] 内的步进数字为 98 和 101 。总共有 2 个步进数字。所以输出为 2 。+ +
+ +
提示：
+ +1 <= int(low) <= int(high) < 101001 <= low.length, high.length <= 100low 和 high 只包含数字。low 和 high 都不含前导 0 。一开始，你的银行账户里有 100 块钱。
给你一个整数purchaseAmount ，它表示你在一次购买中愿意支出的金额。
在一个商店里，你进行一次购买，实际支出的金额会向 最近 的 10 的 倍数 取整。换句话说，你实际会支付一个 非负 金额 roundedAmount ，满足 roundedAmount 是 10 的倍数且 abs(roundedAmount - purchaseAmount) 的值 最小 。
如果存在多于一个最接近的 10 的倍数，较大的倍数 是你的实际支出金额。
请你返回一个整数，表示你在愿意支出金额为 purchaseAmount 块钱的前提下，购买之后剩下的余额。
注意： 0 也是 10 的倍数。
+ +
示例 1：
+ +输入：purchaseAmount = 9 +输出：90 +解释：这个例子中，最接近 9 的 10 的倍数是 10 。所以你的账户余额为 100 - 10 = 90 。 ++ +
示例 2：
+ +输入：purchaseAmount = 15 +输出：80 +解释：这个例子中，有 2 个最接近 15 的 10 的倍数：10 和 20，较大的数 20 是你的实际开销。 +所以你的账户余额为 100 - 20 = 80 。 ++ +
+ +
提示：
+ +0 <= purchaseAmount <= 100给你一个链表的头 head ，每个结点包含一个整数值。
在相邻结点之间，请你插入一个新的结点，结点值为这两个相邻结点值的 最大公约数 。
+ +请你返回插入之后的链表。
+ +两个数的 最大公约数 是可以被两个数字整除的最大正整数。
+ ++ +
示例 1：
+ +
输入：head = [18,6,10,3] +输出：[18,6,6,2,10,1,3] +解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。 +- 18 和 6 的最大公约数为 6 ，插入第一和第二个结点之间。 +- 6 和 10 的最大公约数为 2 ，插入第二和第三个结点之间。 +- 10 和 3 的最大公约数为 1 ，插入第三和第四个结点之间。 +所有相邻结点之间都插入完毕，返回链表。 ++ +
示例 2：
+ +
输入：head = [7] +输出：[7] +解释：第一幅图是一开始的链表，第二幅图是插入新结点后的图（蓝色结点为新插入结点）。 +没有相邻结点，所以返回初始链表。 ++ +
+ +
提示：
+ +[1, 5000] 之间。1 <= Node.val <= 1000给你一个下标从 0 开始长度为 n 的数组 nums 。
每一秒，你可以对数组执行以下操作：
+ +[0, n - 1] 内的每一个下标 i ，将 nums[i] 替换成 nums[i] ，nums[(i - 1 + n) % n] 或者 nums[(i + 1) % n] 三者之一。注意，所有元素会被同时替换。
+ +请你返回将数组 nums 中所有元素变成相等元素所需要的 最少 秒数。
+ +
示例 1：
+ +输入：nums = [1,2,1,2] +输出：1 +解释：我们可以在 1 秒内将数组变成相等元素： +- 第 1 秒，将每个位置的元素分别变为 [nums[3],nums[1],nums[3],nums[3]] 。变化后，nums = [2,2,2,2] 。 +1 秒是将数组变成相等元素所需要的最少秒数。 ++ +
示例 2：
+ +输入：nums = [2,1,3,3,2] +输出：2 +解释：我们可以在 2 秒内将数组变成相等元素： +- 第 1 秒，将每个位置的元素分别变为 [nums[0],nums[2],nums[2],nums[2],nums[3]] 。变化后，nums = [2,3,3,3,3] 。 +- 第 2 秒，将每个位置的元素分别变为 [nums[1],nums[1],nums[2],nums[3],nums[4]] 。变化后，nums = [3,3,3,3,3] 。 +2 秒是将数组变成相等元素所需要的最少秒数。 ++ +
示例 3：
+ +输入：nums = [5,5,5,5] +输出：0 +解释：不需要执行任何操作，因为一开始数组中的元素已经全部相等。 ++ +
+ +
提示：
+ +1 <= n == nums.length <= 1051 <= nums[i] <= 109给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：
0 <= i < nums1.length 的下标 i ，并使 nums1[i] = 0 。同时给你一个整数 x 。
请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。
+ +
示例 1：
+ ++输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4 +输出：3 +解释： +第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6] 。 +第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9] 。 +第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0] 。 +现在 nums1 的和为 4 。不存在更少次数的操作，所以我们返回 3 。 ++ +
示例 2：
+ ++输入：nums1 = [1,2,3], nums2 = [3,3,3], x = 4 +输出：-1 +解释：不管如何操作，nums1 的和总是会超过 x 。 ++ +
+ +
提示：
+ +1 <= nums1.length <= 1031 <= nums1[i] <= 1030 <= nums2[i] <= 103nums1.length == nums2.length0 <= x <= 106你的笔记本键盘存在故障，每当你在上面输入字符 'i' 时，它会反转你所写的字符串。而输入其他字符则可以正常工作。
给你一个下标从 0 开始的字符串 s ，请你用故障键盘依次输入每个字符。
返回最终笔记本屏幕上输出的字符串。
+ ++ +
示例 1：
+ +输入：s = "string" +输出："rtsng" +解释： +输入第 1 个字符后，屏幕上的文本是："s" 。 +输入第 2 个字符后，屏幕上的文本是："st" 。 +输入第 3 个字符后，屏幕上的文本是："str" 。 +因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "rts" 。 +输入第 5 个字符后，屏幕上的文本是："rtsn" 。 +输入第 6 个字符后，屏幕上的文本是： "rtsng" 。 +因此，返回 "rtsng" 。 ++ +
示例 2：
+ +输入：s = "poiinter" +输出："ponter" +解释： +输入第 1 个字符后，屏幕上的文本是："p" 。 +输入第 2 个字符后，屏幕上的文本是："po" 。 +因为第 3 个字符是 'i' ，屏幕上的文本被反转，变成 "op" 。 +因为第 4 个字符是 'i' ，屏幕上的文本被反转，变成 "po" 。 +输入第 5 个字符后，屏幕上的文本是："pon" 。 +输入第 6 个字符后，屏幕上的文本是："pont" 。 +输入第 7 个字符后，屏幕上的文本是："ponte" 。 +输入第 8 个字符后，屏幕上的文本是："ponter" 。 +因此，返回 "ponter" 。+ +
+ +
提示：
+ +1 <= s.length <= 100s 由小写英文字母组成s[0] != 'i'给你一个长度为 n 的数组 nums 和一个整数 m 。请你判断能否执行一系列操作，将数组拆分成 n 个 非空 数组。
在每一步操作中，你可以选择一个 长度至少为 2 的现有数组（之前步骤的结果） 并将其拆分成 2 个子数组，而得到的 每个 子数组，至少 需要满足以下条件之一：
+ +m 。如果你可以将给定数组拆分成 n 个满足要求的数组，返回 true ；否则，返回 false 。
注意：子数组是数组中的一个连续非空元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [2, 2, 1], m = 4 +输出：true +解释： +第 1 步，将数组 nums 拆分成 [2, 2] 和 [1] 。 +第 2 步，将数组 [2, 2] 拆分成 [2] 和 [2] 。 +因此，答案为 true 。+ +
示例 2：
+ ++输入：nums = [2, 1, 3], m = 5 +输出：false +解释： +存在两种不同的拆分方法： +第 1 种，将数组 nums 拆分成 [2, 1] 和 [3] 。 +第 2 种，将数组 nums 拆分成 [2] 和 [1, 3] 。 +然而，这两种方法都不满足题意。因此，答案为 false 。+ +
示例 3：
+ ++输入：nums = [2, 3, 3, 2, 3], m = 6 +输出：true +解释： +第 1 步，将数组 nums 拆分成 [2, 3, 3, 2] 和 [3] 。 +第 2 步，将数组 [2, 3, 3, 2] 拆分成 [2, 3, 3] 和 [2] 。 +第 3 步，将数组 [2, 3, 3] 拆分成 [2] 和 [3, 3] 。 +第 4 步，将数组 [3, 3] 拆分成 [3] 和 [3] 。 +因此，答案为 true 。+ +
+ +
提示：
+ +1 <= n == nums.length <= 1001 <= nums[i] <= 1001 <= m <= 200给你一个下标从 0 开始、大小为 n x n 的二维矩阵 grid ，其中 (r, c) 表示：
grid[r][c] = 1 ，则表示一个存在小偷的单元格grid[r][c] = 0 ，则表示一个空单元格你最开始位于单元格 (0, 0) 。在一步移动中，你可以移动到矩阵中的任一相邻单元格，包括存在小偷的单元格。
矩阵中路径的 安全系数 定义为：从路径中任一单元格到矩阵中任一小偷所在单元格的 最小 曼哈顿距离。
+ +返回所有通向单元格 (n - 1, n - 1) 的路径中的 最大安全系数 。
单元格 (r, c) 的某个 相邻 单元格，是指在矩阵中存在的 (r, c + 1)、(r, c - 1)、(r + 1, c) 和 (r - 1, c) 之一。
两个单元格 (a, b) 和 (x, y) 之间的 曼哈顿距离 等于 | a - x | + | b - y | ，其中 |val| 表示 val 的绝对值。
+ +
示例 1：
+
++输入：grid = [[1,0,0],[0,0,0],[0,0,1]] +输出：0 +解释：从 (0, 0) 到 (n - 1, n - 1) 的每条路径都经过存在小偷的单元格 (0, 0) 和 (n - 1, n - 1) 。 ++ +
示例 2：
+
++输入：grid = [[0,0,1],[0,0,0],[0,0,0]] +输出：2 +解释： +上图所示路径的安全系数为 2： +- 该路径上距离小偷所在单元格（0，2）最近的单元格是（0，0）。它们之间的曼哈顿距离为 | 0 - 0 | + | 0 - 2 | = 2 。 +可以证明，不存在安全系数更高的其他路径。 ++ +
示例 3：
+
++输入：grid = [[0,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,0]] +输出：2 +解释： +上图所示路径的安全系数为 2： +- 该路径上距离小偷所在单元格（0，3）最近的单元格是（1，2）。它们之间的曼哈顿距离为 | 0 - 1 | + | 3 - 2 | = 2 。 +- 该路径上距离小偷所在单元格（3，0）最近的单元格是（3，2）。它们之间的曼哈顿距离为 | 3 - 3 | + | 0 - 2 | = 2 。 +可以证明，不存在安全系数更高的其他路径。+ +
+ +
提示：
+ +1 <= grid.length == n <= 400grid[i].length == ngrid[i][j] 为 0 或 1grid 至少存在一个小偷给你一个长度为 n 的二维整数数组 items 和一个整数 k 。
items[i] = [profiti, categoryi]，其中 profiti 和 categoryi 分别表示第 i 个项目的利润和类别。
现定义 items 的 子序列 的 优雅度 可以用 total_profit + distinct_categories2 计算，其中 total_profit 是子序列中所有项目的利润总和，distinct_categories 是所选子序列所含的所有类别中不同类别的数量。
你的任务是从 items 所有长度为 k 的子序列中，找出 最大优雅度 。
用整数形式表示并返回 items 中所有长度恰好为 k 的子序列的最大优雅度。
注意：数组的子序列是经由原数组删除一些元素（可能不删除）而产生的新数组，且删除不改变其余元素相对顺序。
+ ++ +
示例 1：
+ ++输入：items = [[3,2],[5,1],[10,1]], k = 2 +输出：17 +解释： +在这个例子中，我们需要选出长度为 2 的子序列。 +其中一种方案是 items[0] = [3,2] 和 items[2] = [10,1] 。 +子序列的总利润为 3 + 10 = 13 ，子序列包含 2 种不同类别 [2,1] 。 +因此，优雅度为 13 + 22 = 17 ，可以证明 17 是可以获得的最大优雅度。 ++ +
示例 2：
+ ++输入：items = [[3,1],[3,1],[2,2],[5,3]], k = 3 +输出：19 +解释： +在这个例子中，我们需要选出长度为 3 的子序列。 +其中一种方案是 items[0] = [3,1] ，items[2] = [2,2] 和 items[3] = [5,3] 。 +子序列的总利润为 3 + 2 + 5 = 10 ，子序列包含 3 种不同类别 [1, 2, 3] 。 +因此，优雅度为 10 + 32 = 19 ，可以证明 19 是可以获得的最大优雅度。+ +
示例 3：
+ ++输入：items = [[1,1],[2,1],[3,1]], k = 3 +输出：7 +解释： +在这个例子中，我们需要选出长度为 3 的子序列。 +我们需要选中所有项目。 +子序列的总利润为 1 + 2 + 3 = 6，子序列包含 1 种不同类别 [1] 。 +因此，最大优雅度为 6 + 12 = 7 。+ +
+ +
提示：
+ +1 <= items.length == n <= 105items[i].length == 2items[i][0] == profitiitems[i][1] == categoryi1 <= profiti <= 1091 <= categoryi <= n 1 <= k <= n给你一个下标从 0 开始的整数数组 nums 。请你从 nums 中找出和 最大 的一对数，且这两个数数位上最大的数字相等。
返回最大和，如果不存在满足题意的数字对，返回 -1 。
+ +
示例 1：
+ +输入：nums = [51,71,17,24,42] +输出：88 +解释： +i = 1 和 j = 2 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 71 + 17 = 88 。 +i = 3 和 j = 4 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 24 + 42 = 66 。 +可以证明不存在其他数对满足数位上最大的数字相等，所以答案是 88 。+ +
示例 2：
+ +输入：nums = [1,2,3,4] +输出：-1 +解释：不存在数对满足数位上最大的数字相等。 ++ +
+ +
提示：
+ +2 <= nums.length <= 1001 <= nums[i] <= 104给你一个 非空 链表的头节点 head ，表示一个不含前导零的非负数整数。
将链表 翻倍 后，返回头节点 head 。
+ +
示例 1：
+
++输入：head = [1,8,9] +输出：[3,7,8] +解释：上图中给出的链表，表示数字 189 。返回的链表表示数字 189 * 2 = 378 。+ +
示例 2：
+
++输入：head = [9,9,9] +输出：[1,9,9,8] +解释：上图中给出的链表，表示数字 999 。返回的链表表示数字 999 * 2 = 1998 。 ++ +
+ +
提示：
+ +[1, 104] 内0 <= Node.val <= 90 本身。给你一个下标从 0 开始的整数数组 nums 和一个整数 x 。
请你找到数组中下标距离至少为 x 的两个元素的 差值绝对值 的 最小值 。
换言之，请你找到两个下标 i 和 j ，满足 abs(i - j) >= x 且 abs(nums[i] - nums[j]) 的值最小。
请你返回一个整数，表示下标距离至少为 x 的两个元素之间的差值绝对值的 最小值 。
+ +
示例 1：
+ ++输入：nums = [4,3,2,4], x = 2 +输出：0 +解释：我们选择 nums[0] = 4 和 nums[3] = 4 。 +它们下标距离满足至少为 2 ，差值绝对值为最小值 0 。 +0 是最优解。 ++ +
示例 2：
+ ++输入：nums = [5,3,2,10,15], x = 1 +输出：1 +解释：我们选择 nums[1] = 3 和 nums[2] = 2 。 +它们下标距离满足至少为 1 ，差值绝对值为最小值 1 。 +1 是最优解。 ++ +
示例 3：
+ ++输入：nums = [1,2,3,4], x = 3 +输出：3 +解释：我们选择 nums[0] = 1 和 nums[3] = 4 。 +它们下标距离满足至少为 3 ，差值绝对值为最小值 3 。 +3 是最优解。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 1090 <= x < nums.length给你一个长度为 n 的正整数数组 nums 和一个整数 k 。
一开始，你的分数为 1 。你可以进行以下操作至多 k 次，目标是使你的分数最大：
nums[l, ..., r] 。nums[l, ..., r] 里面选择一个 质数分数 最高的元素 x 。如果多个元素质数分数相同且最高，选择下标最小的一个。x 。nums[l, ..., r] 表示 nums 中起始下标为 l ，结束下标为 r 的子数组，两个端点都包含。
一个整数的 质数分数 等于 x 不同质因子的数目。比方说， 300 的质数分数为 3 ，因为 300 = 2 * 2 * 3 * 5 * 5 。
请你返回进行至多 k 次操作后，可以得到的 最大分数 。
由于答案可能很大，请你将结果对 109 + 7 取余后返回。
+ +
示例 1：
+ ++输入：nums = [8,3,9,3,8], k = 2 +输出：81 +解释：进行以下操作可以得到分数 81 ： +- 选择子数组 nums[2, ..., 2] 。nums[2] 是子数组中唯一的元素。所以我们将分数乘以 nums[2] ，分数变为 1 * 9 = 9 。 +- 选择子数组 nums[2, ..., 3] 。nums[2] 和 nums[3] 质数分数都为 1 ，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 9 * 9 = 81 。 +81 是可以得到的最高得分。+ +
示例 2：
+ ++输入：nums = [19,12,14,6,10,18], k = 3 +输出：4788 +解释：进行以下操作可以得到分数 4788 ： +- 选择子数组 nums[0, ..., 0] 。nums[0] 是子数组中唯一的元素。所以我们将分数乘以 nums[0] ，分数变为 1 * 19 = 19 。 +- 选择子数组 nums[5, ..., 5] 。nums[5] 是子数组中唯一的元素。所以我们将分数乘以 nums[5] ，分数变为 19 * 18 = 342 。 +- 选择子数组 nums[2, ..., 3] 。nums[2] 和 nums[3] 质数分数都为 2，但是 nums[2] 下标更小。所以我们将分数乘以 nums[2] ，分数变为 342 * 14 = 4788 。 +4788 是可以得到的最高的分。 ++ +
+ +
提示：
+ +1 <= nums.length == n <= 1051 <= nums[i] <= 1051 <= k <= min(n * (n + 1) / 2, 109)n 的整数数组 nums 和一个整数 target ，请你返回满足 0 <= i < j < n 且 nums[i] + nums[j] < target 的下标对 (i, j) 的数目。
++ +
示例 1：
+ ++输入：nums = [-1,1,2,3,1], target = 2 +输出：3 +解释：总共有 3 个下标对满足题目描述： +- (0, 1) ，0 < 1 且 nums[0] + nums[1] = 0 < target +- (0, 2) ，0 < 2 且 nums[0] + nums[2] = 1 < target +- (0, 4) ，0 < 4 且 nums[0] + nums[4] = 0 < target +注意 (0, 3) 不计入答案因为 nums[0] + nums[3] 不是严格小于 target 。 ++ +
示例 2：
+ ++输入：nums = [-6,2,5,-2,-7,-1,3], target = -2 +输出：10 +解释：总共有 10 个下标对满足题目描述： +- (0, 1) ，0 < 1 且 nums[0] + nums[1] = -4 < target +- (0, 3) ，0 < 3 且 nums[0] + nums[3] = -8 < target +- (0, 4) ，0 < 4 且 nums[0] + nums[4] = -13 < target +- (0, 5) ，0 < 5 且 nums[0] + nums[5] = -7 < target +- (0, 6) ，0 < 6 且 nums[0] + nums[6] = -3 < target +- (1, 4) ，1 < 4 且 nums[1] + nums[4] = -5 < target +- (3, 4) ，3 < 4 且 nums[3] + nums[4] = -9 < target +- (3, 5) ，3 < 5 且 nums[3] + nums[5] = -3 < target +- (4, 5) ，4 < 5 且 nums[4] + nums[5] = -8 < target +- (4, 6) ，4 < 6 且 nums[4] + nums[6] = -4 < target ++ +
+ +
提示：
+ +1 <= nums.length == n <= 50-50 <= nums[i], target <= 50给你一个下标从 0 开始的字符串 str1 和 str2 。
一次操作中，你选择 str1 中的若干下标。对于选中的每一个下标 i ，你将 str1[i] 循环 递增，变成下一个字符。也就是说 'a' 变成 'b' ，'b' 变成 'c' ，以此类推，'z' 变成 'a' 。
如果执行以上操作 至多一次 ，可以让 str2 成为 str1 的子序列，请你返回 true ，否则返回 false 。
注意：一个字符串的子序列指的是从原字符串中删除一些（可以一个字符也不删）字符后，剩下字符按照原本先后顺序组成的新字符串。
+ ++ +
示例 1：
+ ++输入：str1 = "abc", str2 = "ad" +输出：true +解释：选择 str1 中的下标 2 。 +将 str1[2] 循环递增，得到 'd' 。 +因此，str1 变成 "abd" 且 str2 现在是一个子序列。所以返回 true 。+ +
示例 2：
+ ++输入：str1 = "zc", str2 = "ad" +输出：true +解释：选择 str1 中的下标 0 和 1 。 +将 str1[0] 循环递增得到 'a' 。 +将 str1[1] 循环递增得到 'd' 。 +因此，str1 变成 "ad" 且 str2 现在是一个子序列。所以返回 true 。+ +
示例 3：
+ ++输入：str1 = "ab", str2 = "d" +输出：false +解释：这个例子中，没法在执行一次操作的前提下，将 str2 变为 str1 的子序列。 +所以返回 false 。+ +
+ +
提示：
+ +1 <= str1.length <= 1051 <= str2.length <= 105str1 和 str2 只包含小写英文字母。给你一个下标从 0 开始长度为 n 的整数数组 nums 。
+
+从 0 到 n - 1 的数字被分为编号从 1 到 3 的三个组，数字 i 属于组 nums[i] 。注意，有的组可能是 空的 。
+
+你可以执行以下操作任意次：
x 并改变它的组。更正式的，你可以将 nums[x] 改为数字 1 到 3 中的任意一个。你将按照以下过程构建一个新的数组 res ：
1 ，2 和 3 中的元素 依次 连接以得到 res 。如果得到的 res 是 非递减顺序的，那么我们称数组 nums 是 美丽数组 。
请你返回将 nums 变为 美丽数组 需要的最少步数。
+ +
示例 1：
+ ++输入：nums = [2,1,3,2,1] +输出：3 +解释：以下三步操作是最优方案： +1. 将 nums[0] 变为 1 。 +2. 将 nums[2] 变为 1 。 +3. 将 nums[3] 变为 1 。 +执行以上操作后，将每组中的数字排序，组 1 为 [0,1,2,3,4] ，组 2 和组 3 都为空。所以 res 等于 [0,1,2,3,4] ，它是非递减顺序的。 +三步操作是最少需要的步数。 ++ +
示例 2：
+ ++输入：nums = [1,3,2,1,3,3] +输出：2 +解释：以下两步操作是最优方案： +1. 将 nums[1] 变为 1 。 +2. 将 nums[2] 变为 1 。 +执行以上操作后，将每组中的数字排序，组 1 为 [0,1,2,3] ，组 2 为空，组 3 为 [4,5] 。所以 res 等于 [0,1,2,3,4,5] ，它是非递减顺序的。 +两步操作是最少需要的步数。 ++ +
示例 3：
+ ++输入：nums = [2,2,2,2,3,3] +输出：0 +解释：不需要执行任何操作。 +组 1 为空，组 2 为 [0,1,2,3] ，组 3 为 [4,5] 。所以 res 等于 [0,1,2,3,4,5] ，它是非递减顺序的。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1001 <= nums[i] <= 3给你正整数 low ，high 和 k 。
如果一个数满足以下两个条件，那么它是 美丽的 ：
+ +k 整除。请你返回范围 [low, high] 中美丽整数的数目。
+ +
示例 1：
+ ++输入：low = 10, high = 20, k = 3 +输出：2 +解释：给定范围中有 2 个美丽数字：[12,18] +- 12 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。 +- 18 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 3 整除。 +以下是一些不是美丽整数的例子： +- 16 不是美丽整数，因为它不能被 k = 3 整除。 +- 15 不是美丽整数，因为它的奇数数位和偶数数位的数目不相等。 +给定范围内总共有 2 个美丽整数。 ++ +
示例 2：
+ ++输入：low = 1, high = 10, k = 1 +输出：1 +解释：给定范围中有 1 个美丽数字：[10] +- 10 是美丽整数，因为它有 1 个奇数数位和 1 个偶数数位，而且可以被 k = 1 整除。 +给定范围内总共有 1 个美丽整数。 ++ +
示例 3：
+ ++输入：low = 5, high = 5, k = 2 +输出：0 +解释：给定范围中有 0 个美丽数字。 +- 5 不是美丽整数，因为它的奇数数位和偶数数位的数目不相等。 ++ +
+ +
提示：
+ +0 < low <= high <= 1090 < k <= 20给你一个字符串数组 words 和一个字符串 s ，请你判断 s 是不是 words 的 首字母缩略词 。
如果可以按顺序串联 words 中每个字符串的第一个字符形成字符串 s ，则认为 s 是 words 的首字母缩略词。例如，"ab" 可以由 ["apple", "banana"] 形成，但是无法从 ["bear", "aardvark"] 形成。
如果 s 是 words 的首字母缩略词，返回 true ；否则，返回 false 。
+ +
示例 1：
+ ++输入：words = ["alice","bob","charlie"], s = "abc" +输出：true +解释：words 中 "alice"、"bob" 和 "charlie" 的第一个字符分别是 'a'、'b' 和 'c'。因此，s = "abc" 是首字母缩略词。 ++ +
示例 2：
+ ++输入：words = ["an","apple"], s = "a" +输出：false +解释：words 中 "an" 和 "apple" 的第一个字符分别是 'a' 和 'a'。 +串联这些字符形成的首字母缩略词是 "aa" 。 +因此，s = "a" 不是首字母缩略词。 ++ +
示例 3：
+ ++输入：words = ["never","gonna","give","up","on","you"], s = "ngguoy" +输出：true +解释：串联数组 words 中每个字符串的第一个字符，得到字符串 "ngguoy" 。 +因此，s = "ngguoy" 是首字母缩略词。 ++ +
+ +
提示：
+ +1 <= words.length <= 1001 <= words[i].length <= 101 <= s.length <= 100words[i] 和 s 由小写英文字母组成给你两个整数 n 和 k 。
对于一个由 不同 正整数组成的数组，如果其中不存在任何求和等于 k 的不同元素对，则称其为 k-avoiding 数组。
+ +返回长度为 n 的 k-avoiding 数组的可能的最小总和。
+ +
示例 1：
+ ++输入：n = 5, k = 4 +输出：18 +解释：设若 k-avoiding 数组为 [1,2,4,5,6] ，其元素总和为 18 。 +可以证明不存在总和小于 18 的 k-avoiding 数组。 ++ +
示例 2：
+ ++输入：n = 2, k = 6 +输出：3 +解释：可以构造数组 [1,2] ，其元素总和为 3 。 +可以证明不存在总和小于 3 的 k-avoiding 数组。 ++ +
+ +
提示：
+ +1 <= n, k <= 50给你一个整数 n 表示数轴上的房屋数量，编号从 0 到 n - 1 。
另给你一个二维整数数组 offers ，其中 offers[i] = [starti, endi, goldi] 表示第 i 个买家想要以 goldi 枚金币的价格购买从 starti 到 endi 的所有房屋。
作为一名销售，你需要有策略地选择并销售房屋使自己的收入最大化。
+ +返回你可以赚取的金币的最大数目。
+ +注意 同一所房屋不能卖给不同的买家，并且允许保留一些房屋不进行出售。
+ ++ +
示例 1：
+ ++输入：n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]] +输出：3 +解释： +有 5 所房屋，编号从 0 到 4 ，共有 3 个购买要约。 +将位于 [0,0] 范围内的房屋以 1 金币的价格出售给第 1 位买家，并将位于 [1,3] 范围内的房屋以 2 金币的价格出售给第 3 位买家。 +可以证明我们最多只能获得 3 枚金币。+ +
示例 2：
+ ++输入：n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]] +输出：10 +解释：有 5 所房屋，编号从 0 到 4 ，共有 3 个购买要约。 +将位于 [0,2] 范围内的房屋以 10 金币的价格出售给第 2 位买家。 +可以证明我们最多只能获得 10 枚金币。+ +
+ +
提示：
+ +1 <= n <= 1051 <= offers.length <= 105offers[i].length == 30 <= starti <= endi <= n - 11 <= goldi <= 103给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
如果子数组中所有元素都相等，则认为子数组是一个 等值子数组 。注意，空数组是 等值子数组 。
+ +从 nums 中删除最多 k 个元素后，返回可能的最长等值子数组的长度。
子数组 是数组中一个连续且可能为空的元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [1,3,2,3,1,3], k = 3 +输出：3 +解释：最优的方案是删除下标 2 和下标 4 的元素。 +删除后，nums 等于 [1, 3, 3, 3] 。 +最长等值子数组从 i = 1 开始到 j = 3 结束，长度等于 3 。 +可以证明无法创建更长的等值子数组。 ++ +
示例 2：
+ ++输入：nums = [1,1,2,2,1,1], k = 2 +输出：4 +解释：最优的方案是删除下标 2 和下标 3 的元素。 +删除后，nums 等于 [1, 1, 1, 1] 。 +数组自身就是等值子数组，长度等于 4 。 +可以证明无法创建更长的等值子数组。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= nums.length0 <= k <= nums.length给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。
你的初始位置就在原点（0），第 i 次移动过程中，你可以根据对应字符选择移动方向：
moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离移动 n 次之后，请你找出可以到达的距离原点 最远 的点，并返回 从原点到这一点的距离 。
+ +
示例 1：
+ ++输入：moves = "L_RL__R" +输出：3 +解释：可以到达的距离原点 0 最远的点是 -3 ，移动的序列为 "LLRLLLR" 。 ++ +
示例 2：
+ ++输入：moves = "_R__LL_" +输出：5 +解释：可以到达的距离原点 0 最远的点是 -5 ，移动的序列为 "LRLLLLL" 。 ++ +
示例 3：
+ ++输入：moves = "_______" +输出：7 +解释：可以到达的距离原点 0 最远的点是 7 ，移动的序列为 "RRRRRRR" 。 ++ +
+ +
提示：
+ +1 <= moves.length == n <= 50moves 仅由字符 'L'、'R' 和 '_' 组成给你两个正整数：n 和 target 。
如果数组 nums 满足下述条件，则称其为 美丽数组 。
nums.length == n.nums 由两两互不相同的正整数组成。[0, n-1] 内，不存在 两个 不同 下标 i 和 j ，使得 nums[i] + nums[j] == target 。返回符合条件的美丽数组所可能具备的 最小 和，并对结果进行取模 109 + 7。
+ +
示例 1：
+ ++输入：n = 2, target = 3 +输出：4 +解释：nums = [1,3] 是美丽数组。 +- nums 的长度为 n = 2 。 +- nums 由两两互不相同的正整数组成。 +- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。 +可以证明 4 是符合条件的美丽数组所可能具备的最小和。+ +
示例 2：
+ ++输入：n = 3, target = 3 +输出：8 +解释： +nums = [1,3,4] 是美丽数组。 +- nums 的长度为 n = 3 。 +- nums 由两两互不相同的正整数组成。 +- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。 +可以证明 8 是符合条件的美丽数组所可能具备的最小和。+ +
示例 3：
+ ++输入：n = 1, target = 1 +输出：1 +解释：nums = [1] 是美丽数组。 ++ +
+ +
提示：
+ +1 <= n <= 1091 <= target <= 109给你一个下标从 0 开始的数组 nums ，它包含 非负 整数，且全部为 2 的幂，同时给你一个整数 target 。
一次操作中，你必须对数组做以下修改：
+ +nums[i] ，满足 nums[i] > 1 。nums[i] 从数组中删除。nums 的 末尾 添加 两个 数，值都为 nums[i] / 2 。你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。
数组中一个 子序列 是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。
+ ++ +
示例 1：
+ ++输入：nums = [1,2,8], target = 7 +输出：1 +解释：第一次操作中，我们选择元素 nums[2] 。数组变为 nums = [1,2,4,4] 。 +这时候，nums 包含子序列 [1,2,4] ，和为 7 。 +无法通过更少的操作得到和为 7 的子序列。 ++ +
示例 2：
+ ++输入：nums = [1,32,1,2], target = 12 +输出：2 +解释：第一次操作中，我们选择元素 nums[1] 。数组变为 nums = [1,1,2,16,16] 。 +第二次操作中，我们选择元素 nums[3] 。数组变为 nums = [1,1,2,16,8,8] 。 +这时候，nums 包含子序列 [1,1,2,8] ，和为 12 。 +无法通过更少的操作得到和为 12 的子序列。+ +
示例 3：
+ ++输入：nums = [1,32,1], target = 35 +输出：-1 +解释：无法得到和为 35 的子序列。 ++ +
+ +
提示：
+ +1 <= nums.length <= 10001 <= nums[i] <= 230nums 只包含非负整数，且均为 2 的幂。1 <= target < 231给你一个长度为 n 下标从 0 开始的整数数组 receiver 和一个整数 k 。
总共有 n 名玩家，玩家 编号 互不相同，且为 [0, n - 1] 中的整数。这些玩家玩一个传球游戏，receiver[i] 表示编号为 i 的玩家会传球给编号为 receiver[i] 的玩家。玩家可以传球给自己，也就是说 receiver[i] 可能等于 i 。
你需要从 n 名玩家中选择一名玩家作为游戏开始时唯一手中有球的玩家，球会被传 恰好 k 次。
如果选择编号为 x 的玩家作为开始玩家，定义函数 f(x) 表示从编号为 x 的玩家开始，k 次传球内所有接触过球玩家的编号之 和 ，如果有玩家多次触球，则 累加多次 。换句话说， f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver(k)[x] 。
你的任务时选择开始玩家 x ，目的是 最大化 f(x) 。
请你返回函数的 最大值 。
+ +注意：receiver 可能含有重复元素。
+ +
示例 1：
+ +| 传递次数 | +传球者编号 | +接球者编号 | +x + 所有接球者编号 | +
|---|---|---|---|
| + | + | + | 2 | +
| 1 | +2 | +1 | +3 | +
| 2 | +1 | +0 | +3 | +
| 3 | +0 | +2 | +5 | +
| 4 | +2 | +1 | +6 | +
+ +
+输入：receiver = [2,0,1], k = 4 +输出：6 +解释：上表展示了从编号为 x = 2 开始的游戏过程。 +从表中可知，f(2) 等于 6 。 +6 是能得到最大的函数值。 +所以输出为 6 。 ++ +
示例 2：
+ +| 传递次数 | +传球者编号 | +接球者编号 | +x + 所有接球者编号 | +
|---|---|---|---|
| + | + | + | 4 | +
| 1 | +4 | +3 | +7 | +
| 2 | +3 | +2 | +9 | +
| 3 | +2 | +1 | +10 | +
+ +
+输入：receiver = [1,1,1,2,3], k = 3 +输出：10 +解释：上表展示了从编号为 x = 4 开始的游戏过程。 +从表中可知，f(4) 等于 10 。 +10 是能得到最大的函数值。 +所以输出为 10 。 ++ +
+ +
提示：
+ +1 <= receiver.length == n <= 1050 <= receiver[i] <= n - 11 <= k <= 1010给你两个字符串 s1 和 s2 ，两个字符串的长度都为 4 ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
+ +i 和 j 且满足 j - i = 2 ，然后 交换 这个字符串中两个下标对应的字符。如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
+ +
示例 1：
+ ++输入：s1 = "abcd", s2 = "cdab" +输出：true +解释： 我们可以对 s1 执行以下操作： +- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。 +- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "cdab" = s2 。 ++ +
示例 2：
+ ++输入：s1 = "abcd", s2 = "dacb" +输出：false +解释：无法让两个字符串相等。 ++ +
+ +
提示：
+ +s1.length == s2.length == 4s1 和 s2 只包含小写英文字母。给你一个整数数组 nums 和两个正整数 m 和 k 。
请你返回 nums 中长度为 k 的 几乎唯一 子数组的 最大和 ，如果不存在几乎唯一子数组，请你返回 0 。
如果 nums 的一个子数组有至少 m 个互不相同的元素，我们称它是 几乎唯一 子数组。
子数组指的是一个数组中一段连续 非空 的元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [2,6,7,3,1,7], m = 3, k = 4 +输出：18 +解释：总共有 3 个长度为 k = 4 的几乎唯一子数组。分别为 [2, 6, 7, 3] ，[6, 7, 3, 1] 和 [7, 3, 1, 7] 。这些子数组中，和最大的是 [2, 6, 7, 3] ，和为 18 。 ++ +
示例 2：
+ ++输入：nums = [5,9,9,2,4,5,4], m = 1, k = 3 +输出：23 +解释：总共有 5 个长度为 k = 3 的几乎唯一子数组。分别为 [5, 9, 9] ，[9, 9, 2] ，[9, 2, 4] ，[2, 4, 5] 和 [4, 5, 4] 。这些子数组中，和最大的是 [5, 9, 9] ，和为 23 。 ++ +
示例 3：
+ ++输入：nums = [1,2,1,2,1,2,1], m = 3, k = 3 +输出：0 +解释：输入数组中不存在长度为+ +k = 3的子数组含有至少m = 3个互不相同元素的子数组。所以不存在几乎唯一子数组，最大和为 0 。 +
+ +
提示：
+ +1 <= nums.length <= 2 * 1041 <= m <= k <= nums.length1 <= nums[i] <= 109给你一个字符串 s 和一个整数 k 。
k 子序列指的是 s 的一个长度为 k 的 子序列 ，且所有字符都是 唯一 的，也就是说每个字符在子序列里只出现过一次。
定义 f(c) 为字符 c 在 s 中出现的次数。
k 子序列的 美丽值 定义为这个子序列中每一个字符 c 的 f(c) 之 和 。
比方说，s = "abbbdd" 和 k = 2 ，我们有：
f('a') = 1, f('b') = 3, f('d') = 2s 的部分 k 子序列为：
+ "abbbdd" -> "ab" ，美丽值为 f('a') + f('b') = 4"abbbdd" -> "ad" ，美丽值为 f('a') + f('d') = 3"abbbdd" -> "bd" ，美丽值为 f('b') + f('d') = 5请你返回一个整数，表示所有 k 子序列 里面 美丽值 是 最大值 的子序列数目。由于答案可能很大，将结果对 109 + 7 取余后返回。
一个字符串的子序列指的是从原字符串里面删除一些字符（也可能一个字符也不删除），不改变剩下字符顺序连接得到的新字符串。
+ +注意：
+ +f(c) 指的是字符 c 在字符串 s 的出现次数，不是在 k 子序列里的出现次数。+ +
示例 1：
+ +
+输入：s = "bcca", k = 2
+输出：4
+解释：s 中我们有 f('a') = 1 ，f('b') = 1 和 f('c') = 2 。
+s 的 k 子序列为：
+bcca ，美丽值为 f('b') + f('c') = 3
+bcca ，美丽值为 f('b') + f('c') = 3
+bcca ，美丽值为 f('b') + f('a') = 2
+bcca ，美丽值为 f('c') + f('a') = 3
+bcca ，美丽值为 f('c') + f('a') = 3
+总共有 4 个 k 子序列美丽值为最大值 3 。
+所以答案为 4 。
+
+
+示例 2：
+ ++输入：s = "abbcd", k = 4 +输出：2 +解释：s 中我们有 f('a') = 1 ，f('b') = 2 ，f('c') = 1 和 f('d') = 1 。 +s 的 k 子序列为： +abbcd ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5 +abbcd ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5 +总共有 2 个 k 子序列美丽值为最大值 5 。 +所以答案为 2 。 ++ +
+ +
提示：
+ +1 <= s.length <= 2 * 1051 <= k <= s.lengths 只包含小写英文字母。给你两个正整数 low 和 high 。
对于一个由 2 * n 位数字组成的整数 x ，如果其前 n 位数字之和与后 n 位数字之和相等，则认为这个数字是一个对称整数。
返回在 [low, high] 范围内的 对称整数的数目 。
+ +
示例 1：
+ ++输入：low = 1, high = 100 +输出：9 +解释：在 1 到 100 范围内共有 9 个对称整数：11、22、33、44、55、66、77、88 和 99 。 ++ +
示例 2：
+ ++输入：low = 1200, high = 1230 +输出：4 +解释：在 1200 到 1230 范围内共有 4 个对称整数：1203、1212、1221 和 1230 。 ++ +
+ +
提示：
+ +1 <= low <= high <= 104给你一个下标从 0 开始的字符串 num ，表示一个非负整数。
在一次操作中，您可以选择 num 的任意一位数字并将其删除。请注意，如果你删除 num 中的所有数字，则 num 变为 0。
返回最少需要多少次操作可以使 num 变成特殊数字。
如果整数 x 能被 25 整除，则该整数 x 被认为是特殊数字。
+ +
+ +
示例 1：
+ ++输入：num = "2245047" +输出：2 +解释：删除数字 num[5] 和 num[6] ，得到数字 "22450" ，可以被 25 整除。 +可以证明要使数字变成特殊数字，最少需要删除 2 位数字。+ +
示例 2：
+ ++输入：num = "2908305" +输出：3 +解释：删除 num[3]、num[4] 和 num[6] ，得到数字 "2900" ，可以被 25 整除。 +可以证明要使数字变成特殊数字，最少需要删除 3 位数字。+ +
示例 3：
+ ++输入：num = "10" +输出：1 +解释：删除 num[0] ，得到数字 "0" ，可以被 25 整除。 +可以证明要使数字变成特殊数字，最少需要删除 1 位数字。 ++ +
+ +
提示
+ +1 <= num.length <= 100num 仅由数字 '0' 到 '9' 组成num 不含任何前导零给你一个下标从 0 开始的整数数组 nums ，以及整数 modulo 和整数 k 。
请你找出并统计数组中 趣味子数组 的数目。
+ +如果 子数组 nums[l..r] 满足下述条件，则称其为 趣味子数组 ：
[l, r] 内，设 cnt 为满足 nums[i] % modulo == k 的索引 i 的数量。并且 cnt % modulo == k 。以整数形式表示并返回趣味子数组的数目。
+ +注意：子数组是数组中的一个连续非空的元素序列。
+ ++ +
示例 1：
+ ++输入：nums = [3,2,4], modulo = 2, k = 1 +输出：3 +解释：在这个示例中，趣味子数组分别是： +子数组 nums[0..0] ，也就是 [3] 。 +- 在范围 [0, 0] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。 +- 因此 cnt = 1 ，且 cnt % modulo == k 。 +子数组 nums[0..1] ，也就是 [3,2] 。 +- 在范围 [0, 1] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。 +- 因此 cnt = 1 ，且 cnt % modulo == k 。 +子数组 nums[0..2] ，也就是 [3,2,4] 。 +- 在范围 [0, 2] 内，只存在 1 个下标 i = 0 满足 nums[i] % modulo == k 。 +- 因此 cnt = 1 ，且 cnt % modulo == k 。 +可以证明不存在其他趣味子数组。因此，答案为 3 。+ +
示例 2：
+ ++输入：nums = [3,1,9,6], modulo = 3, k = 0 +输出：2 +解释：在这个示例中，趣味子数组分别是： +子数组 nums[0..3] ，也就是 [3,1,9,6] 。 +- 在范围 [0, 3] 内，只存在 3 个下标 i = 0, 2, 3 满足 nums[i] % modulo == k 。 +- 因此 cnt = 3 ，且 cnt % modulo == k 。 +子数组 nums[1..1] ，也就是 [1] 。 +- 在范围 [1, 1] 内，不存在下标满足 nums[i] % modulo == k 。 +- 因此 cnt = 0 ，且 cnt % modulo == k 。 +可以证明不存在其他趣味子数组，因此答案为 2 。+ +
+ +
提示：
+ +1 <= nums.length <= 105 1 <= nums[i] <= 1091 <= modulo <= 1090 <= k < modulo现有一棵由 n 个节点组成的无向树，节点按从 0 到 n - 1 编号。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi, wi] 表示树中存在一条位于节点 ui 和节点 vi 之间、权重为 wi 的边。
另给你一个长度为 m 的二维整数数组 queries ，其中 queries[i] = [ai, bi] 。对于每条查询，请你找出使从 ai 到 bi 路径上每条边的权重相等所需的 最小操作次数 。在一次操作中，你可以选择树上的任意一条边，并将其权重更改为任意值。
注意：
+ +ai 到 bi的路径是一个由 不同 节点组成的序列，从节点 ai 开始，到节点 bi 结束，且序列中相邻的两个节点在树中共享一条边。返回一个长度为 m 的数组 answer ，其中 answer[i] 是第 i 条查询的答案。
+ +
示例 1：
+
++输入：n = 7, edges = [[0,1,1],[1,2,1],[2,3,1],[3,4,2],[4,5,2],[5,6,2]], queries = [[0,3],[3,6],[2,6],[0,6]] +输出：[0,0,1,3] +解释：第 1 条查询，从节点 0 到节点 3 的路径中的所有边的权重都是 1 。因此，答案为 0 。 +第 2 条查询，从节点 3 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 0 。 +第 3 条查询，将边 [2,3] 的权重变更为 2 。在这次操作之后，从节点 2 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 1 。 +第 4 条查询，将边 [0,1]、[1,2]、[2,3] 的权重变更为 2 。在这次操作之后，从节点 0 到节点 6 的路径中的所有边的权重都是 2 。因此，答案为 3 。 +对于每条查询 queries[i] ，可以证明 answer[i] 是使从 ai 到 bi 的路径中的所有边的权重相等的最小操作次数。 ++ +
示例 2：
+
++输入：n = 8, edges = [[1,2,6],[1,3,4],[2,4,6],[2,5,3],[3,6,6],[3,0,8],[7,0,2]], queries = [[4,6],[0,4],[6,5],[7,4]] +输出：[1,2,2,3] +解释：第 1 条查询，将边 [1,3] 的权重变更为 6 。在这次操作之后，从节点 4 到节点 6 的路径中的所有边的权重都是 6 。因此，答案为 1 。 +第 2 条查询，将边 [0,3]、[3,1] 的权重变更为 6 。在这次操作之后，从节点 0 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 2 。 +第 3 条查询，将边 [1,3]、[5,2] 的权重变更为 6 。在这次操作之后，从节点 6 到节点 5 的路径中的所有边的权重都是 6 。因此，答案为 2 。 +第 4 条查询，将边 [0,7]、[0,3]、[1,3] 的权重变更为 6 。在这次操作之后，从节点 7 到节点 4 的路径中的所有边的权重都是 6 。因此，答案为 3 。 +对于每条查询 queries[i] ，可以证明 answer[i] 是使从 ai 到 bi 的路径中的所有边的权重相等的最小操作次数。 ++ +
+ +
提示：
+ +1 <= n <= 104edges.length == n - 1edges[i].length == 30 <= ui, vi < n1 <= wi <= 26edges 表示一棵有效的树1 <= queries.length == m <= 2 * 104queries[i].length == 20 <= ai, bi < n给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。
返回数轴上被车 任意部分 覆盖的整数点的数目。
+ ++ +
示例 1：
+ ++输入：nums = [[3,6],[1,5],[4,7]] +输出：7 +解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7 。 ++ +
示例 2：
+ ++输入：nums = [[1,3],[5,8]] +输出：7 +解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 100nums[i].length == 21 <= starti <= endi <= 100给你四个整数 sx、sy、fx、fy 以及一个 非负整数 t 。
在一个无限的二维网格中，你从单元格 (sx, sy) 开始出发。每一秒，你 必须 移动到任一与之前所处单元格相邻的单元格中。
如果你能在 恰好 t 秒 后到达单元格 (fx, fy) ，返回 true ；否则，返回 false 。
单元格的 相邻单元格 是指该单元格周围与其至少共享一个角的 8 个单元格。你可以多次访问同一个单元格。
+ ++ +
示例 1：
+
++输入：sx = 2, sy = 4, fx = 7, fy = 7, t = 6 +输出：true +解释：从单元格 (2, 4) 开始出发，穿过上图标注的单元格，可以在恰好 6 秒后到达单元格 (7, 7) 。 ++ +
示例 2：
+
++输入：sx = 3, sy = 1, fx = 7, fy = 3, t = 3 +输出：false +解释：从单元格 (3, 1) 开始出发，穿过上图标注的单元格，至少需要 4 秒后到达单元格 (7, 3) 。 因此，无法在 3 秒后到达单元格 (7, 3) 。 ++ +
+ +
提示：
+ +1 <= sx, sy, fx, fy <= 1090 <= t <= 109给你一个大小为 3 * 3 ，下标从 0 开始的二维整数矩阵 grid ，分别表示每一个格子里石头的数目。网格图中总共恰好有 9 个石头，一个格子里可能会有 多个 石头。
每一次操作中，你可以将一个石头从它当前所在格子移动到一个至少有一条公共边的相邻格子。
+ +请你返回每个格子恰好有一个石头的 最少移动次数 。
+ ++ +
示例 1：
+ +
+输入：grid = [[1,1,0],[1,1,1],[1,2,1]] +输出：3 +解释：让每个格子都有一个石头的一个操作序列为： +1 - 将一个石头从格子 (2,1) 移动到 (2,2) 。 +2 - 将一个石头从格子 (2,2) 移动到 (1,2) 。 +3 - 将一个石头从格子 (1,2) 移动到 (0,2) 。 +总共需要 3 次操作让每个格子都有一个石头。 +让每个格子都有一个石头的最少操作次数为 3 。 ++ +
示例 2：
+ +
+输入：grid = [[1,3,0],[1,0,0],[1,0,3]] +输出：4 +解释：让每个格子都有一个石头的一个操作序列为： +1 - 将一个石头从格子 (0,1) 移动到 (0,2) 。 +2 - 将一个石头从格子 (0,1) 移动到 (1,1) 。 +3 - 将一个石头从格子 (2,2) 移动到 (1,2) 。 +4 - 将一个石头从格子 (2,2) 移动到 (2,1) 。 +总共需要 4 次操作让每个格子都有一个石头。 +让每个格子都有一个石头的最少操作次数为 4 。 ++ +
+ +
提示：
+ +grid.length == grid[i].length == 30 <= grid[i][j] <= 9grid 中元素之和为 9 。给你两个长度都为 n 的字符串 s 和 t 。你可以对字符串 s 执行以下操作：
s 长度为 l （0 < l < n）的 后缀字符串 删除，并将它添加在 s 的开头。s = 'abcd' ，那么一次操作中，你可以删除后缀 'cd' ，并将它添加到 s 的开头，得到 s = 'cdab' 。给你一个整数 k ，请你返回 恰好 k 次操作将 s 变为 t 的方案数。
由于答案可能很大，返回答案对 109 + 7 取余 后的结果。
+ +
示例 1：
+ ++输入：s = "abcd", t = "cdab", k = 2 +输出：2 +解释： +第一种方案： +第一次操作，选择 index = 3 开始的后缀，得到 s = "dabc" 。 +第二次操作，选择 index = 3 开始的后缀，得到 s = "cdab" 。 + +第二种方案： +第一次操作，选择 index = 1 开始的后缀，得到 s = "bcda" 。 +第二次操作，选择 index = 1 开始的后缀，得到 s = "cdab" 。 ++ +
示例 2：
+ ++输入：s = "ababab", t = "ababab", k = 1 +输出：2 +解释： +第一种方案： +选择 index = 2 开始的后缀，得到 s = "ababab" 。 + +第二种方案： +选择 index = 4 开始的后缀，得到 s = "ababab" 。 ++ +
+ +
提示：
+ +2 <= s.length <= 5 * 1051 <= k <= 1015s.length == t.lengths 和 t 都只包含小写英文字母。给你一个长度为 n 下标从 0 开始的数组 nums ，数组中的元素为 互不相同 的正整数。请你返回让 nums 成为递增数组的 最少右移 次数，如果无法得到递增数组，返回 -1 。
一次 右移 指的是同时对所有下标进行操作，将下标为 i 的元素移动到下标 (i + 1) % n 处。
+ +
示例 1：
+ ++输入：nums = [3,4,5,1,2] +输出：2 +解释： +第一次右移后，nums = [2,3,4,5,1] 。 +第二次右移后，nums = [1,2,3,4,5] 。 +现在 nums 是递增数组了，所以答案为 2 。 ++ +
示例 2：
+ ++输入：nums = [1,3,5] +输出：0 +解释：nums 已经是递增数组了，所以答案为 0 。+ +
示例 3：
+ ++输入：nums = [2,1,4] +输出：-1 +解释：无法将数组变为递增数组。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1001 <= nums[i] <= 100nums 中的整数互不相同。给你一个下标从 0 开始的 非递减 整数数组 nums 。
你可以执行以下操作任意次：
+ +i 和 j ，满足 i < j 且 nums[i] < nums[j] 。nums 中下标在 i 和 j 处的元素删除。剩余元素按照原来的顺序组成新的数组，下标也重新从 0 开始编号。请你返回一个整数，表示执行以上操作任意次后（可以执行 0 次），nums 数组的 最小 数组长度。
请注意，nums 数组是按 非降序 排序的。
+ +
示例 1：
+ ++输入：nums = [1,3,4,9] +输出：0 +解释：一开始，nums = [1, 3, 4, 9] 。 +第一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 1 < 3 。 +删除下标 0 和 1 处的元素，nums 变成 [4, 9] 。 +下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 4 < 9 。 +删除下标 0 和 1 处的元素，nums 变成空数组 [] 。 +所以，可以得到的最小数组长度为 0 。+ +
示例 2：
+ ++输入：nums = [2,3,6,9] +输出：0 +解释：一开始，nums = [2, 3, 6, 9] 。 +第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 2 < 6 。 +删除下标 0 和 2 处的元素，nums 变成 [3, 9] 。 +下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 3 < 9 。 +删除下标 0 和 1 处的元素，nums 变成空数组 [] 。 +所以，可以得到的最小数组长度为 0 。 ++ +
示例 3：
+ ++输入：nums = [1,1,2] +输出：1 +解释：一开始，nums = [1, 1, 2] 。 +第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 1 < 2 。 +删除下标 0 和 2 处的元素，nums 变成 [1] 。 +无法对数组再执行操作。 +所以，可以得到的最小数组长度为 1 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 109nums 是 非递减 数组。给你一个 二维 整数数组 coordinates 和一个整数 k ，其中 coordinates[i] = [xi, yi] 是第 i 个点在二维平面里的坐标。
我们定义两个点 (x1, y1) 和 (x2, y2) 的 距离 为 (x1 XOR x2) + (y1 XOR y2) ，XOR 指的是按位异或运算。
请你返回满足 i < j 且点 i 和点 j之间距离为 k 的点对数目。
+ +
示例 1：
+ ++输入：coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5 +输出：2 +解释：以下点对距离为 k ： +- (0, 1)：(1 XOR 4) + (2 XOR 2) = 5 。 +- (2, 3)：(1 XOR 5) + (3 XOR 2) = 5 。 ++ +
示例 2：
+ ++输入：coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0 +输出：10 +解释：任何两个点之间的距离都为 0 ，所以总共有 10 组点对。 ++ +
+ +
提示：
+ +2 <= coordinates.length <= 500000 <= xi, yi <= 1060 <= k <= 100给你一个 n 个点的 简单有向图 （没有重复边的有向图），节点编号为 0 到 n - 1 。如果这些边是双向边，那么这个图形成一棵 树 。
给你一个整数 n 和一个 二维 整数数组 edges ，其中 edges[i] = [ui, vi] 表示从节点 ui 到节点 vi 有一条 有向边 。
边反转 指的是将一条边的方向反转，也就是说一条从节点 ui 到节点 vi 的边会变为一条从节点 vi 到节点 ui 的边。
对于范围 [0, n - 1] 中的每一个节点 i ，你的任务是分别 独立 计算 最少 需要多少次 边反转 ，从节点 i 出发经过 一系列有向边 ，可以到达所有的节点。
请你返回一个长度为 n 的整数数组 answer ，其中 answer[i]表示从节点 i 出发，可以到达所有节点的 最少边反转 次数。
+ +
示例 1：
+ +
+输入：n = 4, edges = [[2,0],[2,1],[1,3]] +输出：[1,1,0,2] +解释：上图表示了与输入对应的简单有向图。 +对于节点 0 ：反转 [2,0] ，从节点 0 出发可以到达所有节点。 +所以 answer[0] = 1 。 +对于节点 1 ：反转 [2,1] ，从节点 1 出发可以到达所有节点。 +所以 answer[1] = 1 。 +对于节点 2 ：不需要反转就可以从节点 2 出发到达所有节点。 +所以 answer[2] = 0 。 +对于节点 3 ：反转 [1,3] 和 [2,1] ，从节点 3 出发可以到达所有节点。 +所以 answer[3] = 2 。 ++ +
示例 2：
+ +
+输入：n = 3, edges = [[1,2],[2,0]] +输出：[2,0,1] +解释：上图表示了与输入对应的简单有向图。 +对于节点 0 ：反转 [2,0] 和 [1,2] ，从节点 0 出发可以到达所有节点。 +所以 answer[0] = 2 。 +对于节点 1 ：不需要反转就可以从节点 2 出发到达所有节点。 +所以 answer[1] = 0 。 +对于节点 2 ：反转 [1,2] ，从节点 2 出发可以到达所有节点。 +所以 answer[2] = 1 。 ++ +
+ +
提示：
+ +2 <= n <= 105edges.length == n - 1edges[i].length == 20 <= ui == edges[i][0] < n0 <= vi == edges[i][1] < nui != vi给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。
请你用整数形式返回 nums 中的特定元素之 和 ，这些特定元素满足：其对应下标的二进制表示中恰存在 k 个置位。
整数的二进制表示中的 1 就是这个整数的 置位 。
+ +例如，21 的二进制表示为 10101 ，其中有 3 个置位。
+ +
示例 1：
+ ++输入：nums = [5,10,1,5,2], k = 1 +输出：13 +解释：下标的二进制表示是： +0 = 0002 +1 = 0012 +2 = 0102 +3 = 0112 +4 = 1002 +下标 1、2 和 4 在其二进制表示中都存在 k = 1 个置位。 +因此，答案为 nums[1] + nums[2] + nums[4] = 13 。+ +
示例 2：
+ ++输入：nums = [4,3,2,1], k = 2 +输出：1 +解释：下标的二进制表示是： +0 = 002 +1 = 012 +2 = 102 +3 = 112 +只有下标 3 的二进制表示中存在 k = 2 个置位。 +因此，答案为 nums[3] = 1 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 10001 <= nums[i] <= 1050 <= k <= 10给你一个下标从 0 开始、长度为 n 的整数数组 nums ，其中 n 是班级中学生的总数。班主任希望能够在让所有学生保持开心的情况下选出一组学生：
如果能够满足下述两个条件之一，则认为第 i 位学生将会保持开心：
nums[i] 。nums[i] 。返回能够满足让所有学生保持开心的分组方法的数目。
+ ++ +
示例 1：
+ ++输入：nums = [1,1] +输出：2 +解释： +有两种可行的方法： +班主任没有选中学生。 +班主任选中所有学生形成一组。 +如果班主任仅选中一个学生来完成分组，那么两个学生都无法保持开心。因此，仅存在两种可行的方法。 ++ +
示例 2：
+ ++输入：nums = [6,0,3,3,6,7,2,7] +输出：3 +解释： +存在三种可行的方法： +班主任选中下标为 1 的学生形成一组。 +班主任选中下标为 1、2、3、6 的学生形成一组。 +班主任选中所有学生形成一组。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1050 <= nums[i] < nums.length假设你是一家合金制造公司的老板，你的公司使用多种金属来制造合金。现在共有 n 种不同类型的金属可以使用，并且你可以使用 k 台机器来制造合金。每台机器都需要特定数量的每种金属来创建合金。
对于第 i 台机器而言，创建合金需要 composition[i][j] 份 j 类型金属。最初，你拥有 stock[i] 份 i 类型金属，而每购入一份 i 类型金属需要花费 cost[i] 的金钱。
给你整数 n、k、budget，下标从 1 开始的二维数组 composition，两个下标从 1 开始的数组 stock 和 cost，请你在预算不超过 budget 金钱的前提下，最大化 公司制造合金的数量。
所有合金都需要由同一台机器制造。
+ +返回公司可以制造的最大合金数。
+ ++ +
示例 1：
+ ++输入：n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,0], cost = [1,2,3] +输出：2 +解释：最优的方法是使用第 1 台机器来制造合金。 +要想制造 2 份合金，我们需要购买： +- 2 份第 1 类金属。 +- 2 份第 2 类金属。 +- 2 份第 3 类金属。 +总共需要 2 * 1 + 2 * 2 + 2 * 3 = 12 的金钱，小于等于预算 15 。 +注意，我们最开始时候没有任何一类金属，所以必须买齐所有需要的金属。 +可以证明在示例条件下最多可以制造 2 份合金。 ++ +
示例 2：
+ ++输入：n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,100], cost = [1,2,3] +输出：5 +解释：最优的方法是使用第 2 台机器来制造合金。 +要想制造 5 份合金，我们需要购买： +- 5 份第 1 类金属。 +- 5 份第 2 类金属。 +- 0 份第 3 类金属。 +总共需要 5 * 1 + 5 * 2 + 0 * 3 = 15 的金钱，小于等于预算 15 。 +可以证明在示例条件下最多可以制造 5 份合金。 ++ +
示例 3：
+ ++输入：n = 2, k = 3, budget = 10, composition = [[2,1],[1,2],[1,1]], stock = [1,1], cost = [5,5] +输出：2 +解释：最优的方法是使用第 3 台机器来制造合金。 +要想制造 2 份合金，我们需要购买： +- 1 份第 1 类金属。 +- 1 份第 2 类金属。 +总共需要 1 * 5 + 1 * 5 = 10 的金钱，小于等于预算 10 。 +可以证明在示例条件下最多可以制造 2 份合金。 ++ +
+ +
提示：
+ +1 <= n, k <= 1000 <= budget <= 108composition.length == kcomposition[i].length == n1 <= composition[i][j] <= 100stock.length == cost.length == n0 <= stock[i] <= 1081 <= cost[i] <= 100给你一个下标从 1 开始、由 n 个整数组成的数组。
如果一组数字中每对元素的乘积都是一个完全平方数，则称这组数字是一个 完全集 。
+ +下标集 {1, 2, ..., n} 的子集可以表示为 {i1, i2, ..., ik}，我们定义对应该子集的 元素和 为 nums[i1] + nums[i2] + ... + nums[ik] 。
返回下标集 {1, 2, ..., n} 的 完全子集 所能取到的 最大元素和 。
完全平方数是指可以表示为一个整数和其自身相乘的数。
+ ++ +
示例 1：
+ +
+输入：nums = [8,7,3,5,7,2,4,9]
+输出：16
+解释：除了由单个下标组成的子集之外，还有两个下标集的完全子集：{1,4} 和 {2,8} 。
+与下标 1 和 4 对应的元素和等于 nums[1] + nums[4] = 8 + 5 = 13 。
+与下标 2 和 8 对应的元素和等于 nums[2] + nums[8] = 7 + 9 = 16 。
+因此，下标集的完全子集可以取到的最大元素和为 16 。
+
+
+示例 2：
+ +
+输入：nums = [5,10,3,10,1,13,7,9,4]
+输出：19
+解释：除了由单个下标组成的子集之外，还有四个下标集的完全子集：{1,4}、{1,9}、{2,8}、{4,9} 和 {1,4,9} 。
+与下标 1 和 4 对应的元素和等于 nums[1] + nums[4] = 5 + 10 = 15 。
+与下标 1 和 9 对应的元素和等于 nums[1] + nums[9] = 5 + 4 = 9 。
+与下标 2 和 8 对应的元素和等于 nums[2] + nums[8] = 10 + 9 = 19 。
+与下标 4 和 9 对应的元素和等于 nums[4] + nums[9] = 10 + 4 = 14 。
+与下标 1、4 和 9 对应的元素和等于 nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19 。
+因此，下标集的完全子集可以取到的最大元素和为 19 。
+
+
++ +
提示：
+ +1 <= n == nums.length <= 1041 <= nums[i] <= 109给你一个 二进制 字符串 s ，其中至少包含一个 '1' 。
你必须按某种方式 重新排列 字符串中的位，使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。
+ +以字符串形式，表示并返回可以由给定组合生成的最大二进制奇数。
+ +注意 返回的结果字符串 可以 含前导零。
+ ++ +
示例 1：
+ ++输入：s = "010" +输出："001" +解释：因为字符串 s 中仅有一个 '1' ，其必须出现在最后一位上。所以答案是 "001" 。 ++ +
示例 2：
+ ++输入：s = "0101" +输出："1001" +解释：其中一个 '1' 必须出现在最后一位上。而由剩下的数字可以生产的最大数字是 "100" 。所以答案是 "1001" 。 ++ +
+ +
提示：
+ +1 <= s.length <= 100s 仅由 '0' 和 '1' 组成s 中至少包含一个 '1'给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
+ +1 <= heights[i] <= maxHeights[i]heights 是一个 山状 数组。如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
0 < j <= i ，都有 heights[j - 1] <= heights[j]i <= k < n - 1 ，都有 heights[k + 1] <= heights[k]请你返回满足 美丽塔 要求的方案中，高度和的最大值 。
+ ++ +
示例 1：
+ ++输入：maxHeights = [5,3,4,1,1] +输出：13 +解释：和最大的美丽塔方案为 heights = [5,3,3,1,1] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，峰值在 i = 0 处。 +13 是所有美丽塔方案中的最大高度和。+ +
示例 2：
+ ++输入：maxHeights = [6,5,3,9,2,7] +输出：22 +解释： 和最大的美丽塔方案为 heights = [3,3,3,9,2,2] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，峰值在 i = 3 处。 +22 是所有美丽塔方案中的最大高度和。+ +
示例 3：
+ ++输入：maxHeights = [3,2,5,5,2,3] +输出：18 +解释：和最大的美丽塔方案为 heights = [2,2,5,5,2,2] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，最大值在 i = 2 处。 +注意，在这个方案中，i = 3 也是一个峰值。 +18 是所有美丽塔方案中的最大高度和。 ++ +
+ +
提示：
+ +1 <= n == maxHeights <= 1031 <= maxHeights[i] <= 109给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。
你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。
如果以下条件满足，我们称这些塔是 美丽 的：
+ +1 <= heights[i] <= maxHeights[i]heights 是一个 山状 数组。如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山状 数组：
0 < j <= i ，都有 heights[j - 1] <= heights[j]i <= k < n - 1 ，都有 heights[k + 1] <= heights[k]请你返回满足 美丽塔 要求的方案中，高度和的最大值 。
+ ++ +
示例 1：
+ ++输入：maxHeights = [5,3,4,1,1] +输出：13 +解释：和最大的美丽塔方案为 heights = [5,3,3,1,1] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，峰值在 i = 0 处。 +13 是所有美丽塔方案中的最大高度和。+ +
示例 2：
+ ++输入：maxHeights = [6,5,3,9,2,7] +输出：22 +解释： 和最大的美丽塔方案为 heights = [3,3,3,9,2,2] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，峰值在 i = 3 处。 +22 是所有美丽塔方案中的最大高度和。+ +
示例 3：
+ ++输入：maxHeights = [3,2,5,5,2,3] +输出：18 +解释：和最大的美丽塔方案为 heights = [2,2,5,5,2,2] ，这是一个美丽塔方案，因为： +- 1 <= heights[i] <= maxHeights[i] +- heights 是个山状数组，最大值在 i = 2 处。 +注意，在这个方案中，i = 3 也是一个峰值。 +18 是所有美丽塔方案中的最大高度和。 ++ +
+ +
提示：
+ +1 <= n == maxHeights <= 1051 <= maxHeights[i] <= 109给你一棵 n 个节点的无向树，节点编号为 1 到 n 。给你一个整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示节点 ui 和 vi 在树中有一条边。
请你返回树中的 合法路径数目 。
+ +如果在节点 a 到节点 b 之间 恰好有一个 节点的编号是质数，那么我们称路径 (a, b) 是 合法的 。
注意：
+ +(a, b) 指的是一条从节点 a 开始到节点 b 结束的一个节点序列，序列中的节点 互不相同 ，且相邻节点之间在树上有一条边。(a, b) 和路径 (b, a) 视为 同一条 路径，且只计入答案 一次 。+ +
示例 1：
+ +
+输入：n = 5, edges = [[1,2],[1,3],[2,4],[2,5]] +输出：4 +解释：恰好有一个质数编号的节点路径有： +- (1, 2) 因为路径 1 到 2 只包含一个质数 2 。 +- (1, 3) 因为路径 1 到 3 只包含一个质数 3 。 +- (1, 4) 因为路径 1 到 4 只包含一个质数 2 。 +- (2, 4) 因为路径 2 到 4 只包含一个质数 2 。 +只有 4 条合法路径。 ++ +
示例 2：
+ +
+输入：n = 6, edges = [[1,2],[1,3],[2,4],[3,5],[3,6]] +输出：6 +解释：恰好有一个质数编号的节点路径有： +- (1, 2) 因为路径 1 到 2 只包含一个质数 2 。 +- (1, 3) 因为路径 1 到 3 只包含一个质数 3 。 +- (1, 4) 因为路径 1 到 4 只包含一个质数 2 。 +- (1, 6) 因为路径 1 到 6 只包含一个质数 3 。 +- (2, 4) 因为路径 2 到 4 只包含一个质数 2 。 +- (3, 6) 因为路径 3 到 6 只包含一个质数 3 。 +只有 6 条合法路径。 ++ +
+ +
提示：
+ +1 <= n <= 105edges.length == n - 1edges[i].length == 21 <= ui, vi <= nedges 形成一棵合法的树。给你一个正整数数组 nums 和一个整数 k 。
一次操作中，你可以将数组的最后一个元素删除，将该元素添加到一个集合中。
+ +请你返回收集元素 1, 2, ..., k 需要的 最少操作次数 。
+ +
示例 1：
+ ++输入：nums = [3,1,5,4,2], k = 2 +输出：4 +解释：4 次操作后，集合中的元素依次添加了 2 ，4 ，5 和 1 。此时集合中包含元素 1 和 2 ，所以答案为 4 。 ++ +
示例 2：
+ ++输入：nums = [3,1,5,4,2], k = 5 +输出：5 +解释：5 次操作后，集合中的元素依次添加了 2 ，4 ，5 ，1 和 3 。此时集合中包含元素 1 到 5 ，所以答案为 5 。 ++ +
示例 3：
+ ++输入：nums = [3,2,5,3,1], k = 3 +输出：4 +解释：4 次操作后，集合中的元素依次添加了 1 ，3 ，5 和 2 。此时集合中包含元素 1 到 3 ，所以答案为 4 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 501 <= nums[i] <= nums.length1 <= k <= nums.length1, 2, ..., k 。给你一个下标从 0 开始的正整数数组 nums 。
你可以对数组执行以下两种操作 任意次 ：
+ +请你返回使数组为空的 最少 操作次数，如果无法达成，请返回 -1 。
+ +
示例 1：
+ ++输入：nums = [2,3,3,2,2,4,2,3,4] +输出：4 +解释：我们可以执行以下操作使数组为空： +- 对下标为 0 和 3 的元素执行第一种操作，得到 nums = [3,3,2,4,2,3,4] 。 +- 对下标为 2 和 4 的元素执行第一种操作，得到 nums = [3,3,4,3,4] 。 +- 对下标为 0 ，1 和 3 的元素执行第二种操作，得到 nums = [4,4] 。 +- 对下标为 0 和 1 的元素执行第一种操作，得到 nums = [] 。 +至少需要 4 步操作使数组为空。 ++ +
示例 2：
+ ++输入：nums = [2,1,2,2,3,3] +输出：-1 +解释：无法使数组为空。 ++ +
+ +
提示：
+ +2 <= nums.length <= 1051 <= nums[i] <= 106给你一个只包含 非负 整数的数组 nums 。
我们定义满足 l <= r 的子数组 nums[l..r] 的分数为 nums[l] AND nums[l + 1] AND ... AND nums[r] ，其中 AND 是按位与运算。
请你将数组分割成一个或者更多子数组，满足：
+ +请你在满足以上要求的条件下，返回 最多 可以得到多少个子数组。
+ +一个 子数组 是一个数组中一段连续的元素。
+ ++ +
示例 1：
+ ++输入：nums = [1,0,2,0,1,2] +输出：3 +解释：我们可以将数组分割成以下子数组： +- [1,0] 。子数组分数为 1 AND 0 = 0 。 +- [2,0] 。子数组分数为 2 AND 0 = 0 。 +- [1,2] 。子数组分数为 1 AND 2 = 0 。 +分数之和为 0 + 0 + 0 = 0 ，是我们可以得到的最小分数之和。 +在分数之和为 0 的前提下，最多可以将数组分割成 3 个子数组。所以返回 3 。 ++ +
示例 2：
+ ++输入：nums = [5,7,1,3] +输出：1 +解释：我们可以将数组分割成一个子数组：[5,7,1,3] ，分数为 1 ，这是可以得到的最小总分数。 +在总分数为 1 的前提下，最多可以将数组分割成 1 个子数组。所以返回 1 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1050 <= nums[i] <= 106给你一棵 n 个节点的无向树，节点编号为 0 到 n - 1 。给你整数 n 和一个长度为 n - 1 的二维整数数组 edges ，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 有一条边。
同时给你一个下标从 0 开始长度为 n 的整数数组 values ，其中 values[i] 是第 i 个节点的 值 。再给你一个整数 k 。
你可以从树中删除一些边，也可以一条边也不删，得到若干连通块。一个 连通块的值 定义为连通块中所有节点值之和。如果所有连通块的值都可以被 k 整除，那么我们说这是一个 合法分割 。
请你返回所有合法分割中，连通块数目的最大值 。
+ ++ +
示例 1：
+ +
+输入：n = 5, edges = [[0,2],[1,2],[1,3],[2,4]], values = [1,8,1,4,4], k = 6 +输出：2 +解释：我们删除节点 1 和 2 之间的边。这是一个合法分割，因为： +- 节点 1 和 3 所在连通块的值为 values[1] + values[3] = 12 。 +- 节点 0 ，2 和 4 所在连通块的值为 values[0] + values[2] + values[4] = 6 。 +最多可以得到 2 个连通块的合法分割。+ +
示例 2：
+ +
+输入：n = 7, edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]], values = [3,0,6,1,5,2,1], k = 3 +输出：3 +解释：我们删除节点 0 和 2 ，以及节点 0 和 1 之间的边。这是一个合法分割，因为： +- 节点 0 的连通块的值为 values[0] = 3 。 +- 节点 2 ，5 和 6 所在连通块的值为 values[2] + values[5] + values[6] = 9 。 +- 节点 1 ，3 和 4 的连通块的值为 values[1] + values[3] + values[4] = 6 。 +最多可以得到 3 个连通块的合法分割。 ++ +
+ +
提示：
+ +1 <= n <= 3 * 104edges.length == n - 1edges[i].length == 20 <= ai, bi < nvalues.length == n0 <= values[i] <= 1091 <= k <= 109values 之和可以被 k 整除。edges 是一棵无向树。给你一个下标从 0 开始的整数数组 nums 。
请你从所有满足 i < j < k 的下标三元组 (i, j, k) 中，找出并返回下标三元组的最大值。如果所有满足条件的三元组的值都是负数，则返回 0 。
下标三元组 (i, j, k) 的值等于 (nums[i] - nums[j]) * nums[k] 。
+ +
示例 1：
+ ++输入：nums = [12,6,1,2,7] +输出：77 +解释：下标三元组 (0, 2, 4) 的值是 (nums[0] - nums[2]) * nums[4] = 77 。 +可以证明不存在值大于 77 的有序下标三元组。 ++ +
示例 2：
+ ++输入：nums = [1,10,3,4,19] +输出：133 +解释：下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133 。 +可以证明不存在值大于 133 的有序下标三元组。 ++ +
示例 3：
+ ++输入：nums = [1,2,3] +输出：0 +解释：唯一的下标三元组 (0, 1, 2) 的值是一个负数，(nums[0] - nums[1]) * nums[2] = -3 。因此，答案是 0 。 ++ +
+ +
提示：
+ +3 <= nums.length <= 1001 <= nums[i] <= 106给你一个下标从 0 开始的整数数组 nums 。
请你从所有满足 i < j < k 的下标三元组 (i, j, k) 中，找出并返回下标三元组的最大值。如果所有满足条件的三元组的值都是负数，则返回 0 。
下标三元组 (i, j, k) 的值等于 (nums[i] - nums[j]) * nums[k] 。
+ +
示例 1：
+ ++输入：nums = [12,6,1,2,7] +输出：77 +解释：下标三元组 (0, 2, 4) 的值是 (nums[0] - nums[2]) * nums[4] = 77 。 +可以证明不存在值大于 77 的有序下标三元组。 ++ +
示例 2：
+ ++输入：nums = [1,10,3,4,19] +输出：133 +解释：下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133 。 +可以证明不存在值大于 133 的有序下标三元组。 ++ +
示例 3：
+ ++输入：nums = [1,2,3] +输出：0 +解释：唯一的下标三元组 (0, 1, 2) 的值是一个负数，(nums[0] - nums[1]) * nums[2] = -3 。因此，答案是 0 。 ++ +
+ +
提示：
+ +3 <= nums.length <= 1051 <= nums[i] <= 106给你一个下标从 0 开始的数组 nums 和一个整数 target 。
下标从 0 开始的数组 infinite_nums 是通过无限地将 nums 的元素追加到自己之后生成的。
请你从 infinite_nums 中找出满足 元素和 等于 target 的 最短 子数组，并返回该子数组的长度。如果不存在满足条件的子数组，返回 -1 。
+ +
示例 1：
+ ++输入：nums = [1,2,3], target = 5 +输出：2 +解释：在这个例子中 infinite_nums = [1,2,3,1,2,3,1,2,...] 。 +区间 [1,2] 内的子数组的元素和等于 target = 5 ，且长度 length = 2 。 +可以证明，当元素和等于目标值 target = 5 时，2 是子数组的最短长度。+ +
示例 2：
+ ++输入：nums = [1,1,1,2,3], target = 4 +输出：2 +解释：在这个例子中 infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...]. +区间 [4,5] 内的子数组的元素和等于 target = 4 ，且长度 length = 2 。 +可以证明，当元素和等于目标值 target = 4 时，2 是子数组的最短长度。 ++ +
示例 3：
+ ++输入：nums = [2,4,6,8], target = 3 +输出：-1 +解释：在这个例子中 infinite_nums = [2,4,6,8,2,4,6,8,...] 。 +可以证明，不存在元素和等于目标值 target = 3 的子数组。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1051 <= nums[i] <= 1051 <= target <= 109现有一个有向图，其中包含 n 个节点，节点编号从 0 到 n - 1 。此外，该图还包含了 n 条有向边。
给你一个下标从 0 开始的数组 edges ，其中 edges[i] 表示存在一条从节点 i 到节点 edges[i] 的边。
想象在图上发生以下过程：
+ +x 开始，通过边访问其他节点，直到你在 此过程 中再次访问到之前已经访问过的节点。返回数组 answer 作为答案，其中 answer[i] 表示如果从节点 i 开始执行该过程，你可以访问到的不同节点数。
+ +
示例 1：
+
++输入：edges = [1,2,0,0] +输出：[3,3,3,4] +解释：从每个节点开始执行该过程，记录如下： +- 从节点 0 开始，访问节点 0 -> 1 -> 2 -> 0 。访问的不同节点数是 3 。 +- 从节点 1 开始，访问节点 1 -> 2 -> 0 -> 1 。访问的不同节点数是 3 。 +- 从节点 2 开始，访问节点 2 -> 0 -> 1 -> 2 。访问的不同节点数是 3 。 +- 从节点 3 开始，访问节点 3 -> 0 -> 1 -> 2 -> 0 。访问的不同节点数是 4 。 ++ +
示例 2：
+
++输入：edges = [1,2,3,4,0] +输出：[5,5,5,5,5] +解释：无论从哪个节点开始，在这个过程中，都可以访问到图中的每一个节点。 ++ +
+ +
提示：
+ +n == edges.length2 <= n <= 1050 <= edges[i] <= n - 1edges[i] != i编写一个解决方案，基于名为 student_data 的二维列表 创建 一个 DataFrame 。这个二维列表包含一些学生的 ID 和年龄信息。
DataFrame 应该有两列， student_id 和 age，并且与原始二维列表的顺序相同。
返回结果格式如下示例所示。
+ ++ +
示例 1：
+ +
+输入：
+student_data:
+[
+ [1, 15],
+ [2, 11],
+ [3, 11],
+ [4, 20]
+]
+输出：
++------------+-----+
+| student_id | age |
++------------+-----+
+| 1 | 15 |
+| 2 | 11 |
+| 3 | 11 |
+| 4 | 20 |
++------------+-----+
+解释：
+基于 student_data 创建了一个 DataFrame，包含 student_id 和 age 两列。
+
+
+
+
\ No newline at end of file
diff --git "a/AllProblems/2878.\350\216\267\345\217\226 DataFrame \347\232\204\345\244\247\345\260\217.md" "b/AllProblems/2878.\350\216\267\345\217\226 DataFrame \347\232\204\345\244\247\345\260\217.md"
new file mode 100644
index 00000000000..e773a0b0f92
--- /dev/null
+++ "b/AllProblems/2878.\350\216\267\345\217\226 DataFrame \347\232\204\345\244\247\345\260\217.md"
@@ -0,0 +1,59 @@
+---
+title: 2878.获取 DataFrame 的大小
+date: 2023-10-10 14-41-37
+tags: [题解, LeetCode, 简单, ]
+---
+
+# 【LetMeFly】2878.获取 DataFrame 的大小
+
+力扣题目链接：[https://leetcode.cn/problems/get-the-size-of-a-dataframe/](https://leetcode.cn/problems/get-the-size-of-a-dataframe/)
+
+
+DataFrame players:
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| player_id | int |
+| name | object |
+| age | int |
+| position | object |
+| ... | ... |
++-------------+--------+
+
+
+编写一个解决方案，计算并显示 players 的 行数和列数。
将结果返回为一个数组：
+ +[number of rows, number of columns]
返回结果格式如下示例所示。
+ ++ +
示例 1：
+ ++输入： ++-----------+----------+-----+-------------+--------------------+ +| player_id | name | age | position | team | ++-----------+----------+-----+-------------+--------------------+ +| 846 | Mason | 21 | Forward | RealMadrid | +| 749 | Riley | 30 | Winger | Barcelona | +| 155 | Bob | 28 | Striker | ManchesterUnited | +| 583 | Isabella | 32 | Goalkeeper | Liverpool | +| 388 | Zachary | 24 | Midfielder | BayernMunich | +| 883 | Ava | 23 | Defender | Chelsea | +| 355 | Violet | 18 | Striker | Juventus | +| 247 | Thomas | 27 | Striker | ParisSaint-Germain | +| 761 | Jack | 33 | Midfielder | ManchesterCity | +| 642 | Charlie | 36 | Center-back | Arsenal | ++-----------+----------+-----+-------------+--------------------+ +输出： +[10, 5] +解释： +这个 DataFrame 包含 10 行和 5 列。 ++ + + \ No newline at end of file diff --git "a/AllProblems/2879.\346\230\276\347\244\272\345\211\215\344\270\211\350\241\214.md" "b/AllProblems/2879.\346\230\276\347\244\272\345\211\215\344\270\211\350\241\214.md" new file mode 100644 index 00000000000..a6f8f62301e --- /dev/null +++ "b/AllProblems/2879.\346\230\276\347\244\272\345\211\215\344\270\211\350\241\214.md" @@ -0,0 +1,54 @@ +--- +title: 2879.显示前三行 +date: 2023-10-10 14-41-37 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2879.显示前三行 + +力扣题目链接：[https://leetcode.cn/problems/display-the-first-three-rows/](https://leetcode.cn/problems/display-the-first-three-rows/) + +
+DataFrame: employees
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| employee_id | int |
+| name | object |
+| department | object |
+| salary | int |
++-------------+--------+
+
+
+编写一个解决方案，显示这个 DataFrame 的 前 3 行。
+ +
示例 1:
+ ++输入： +DataFrame employees ++-------------+-----------+-----------------------+--------+ +| employee_id | name | department | salary | ++-------------+-----------+-----------------------+--------+ +| 3 | Bob | Operations | 48675 | +| 90 | Alice | Sales | 11096 | +| 9 | Tatiana | Engineering | 33805 | +| 60 | Annabelle | InformationTechnology | 37678 | +| 49 | Jonathan | HumanResources | 23793 | +| 43 | Khaled | Administration | 40454 | ++-------------+-----------+-----------------------+--------+ +输出： ++-------------+---------+-------------+--------+ +| employee_id | name | department | salary | ++-------------+---------+-------------+--------+ +| 3 | Bob | Operations | 48675 | +| 90 | Alice | Sales | 11096 | +| 9 | Tatiana | Engineering | 33805 | ++-------------+---------+-------------+--------+ +解释： +只有前 3 行被显示。+ + + \ No newline at end of file diff --git "a/AllProblems/2880.\346\225\260\346\215\256\351\200\211\345\217\226.md" "b/AllProblems/2880.\346\225\260\346\215\256\351\200\211\345\217\226.md" new file mode 100644 index 00000000000..fab61e411dc --- /dev/null +++ "b/AllProblems/2880.\346\225\260\346\215\256\351\200\211\345\217\226.md" @@ -0,0 +1,51 @@ +--- +title: 2880.数据选取 +date: 2023-10-10 14-41-38 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2880.数据选取 + +力扣题目链接：[https://leetcode.cn/problems/select-data/](https://leetcode.cn/problems/select-data/) + +
+DataFrame students ++-------------+--------+ +| Column Name | Type | ++-------------+--------+ +| student_id | int | +| name | object | +| age | int | ++-------------+--------+ + ++ +
编写一个解决方案，选择 student_id = 101 的学生的 name 和 age 并输出。
返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： ++------------+---------+-----+ +| student_id | name | age | ++------------+---------+-----+ +| 101 | Ulysses | 13 | +| 53 | William | 10 | +| 128 | Henry | 6 | +| 3 | Henry | 11 | ++------------+---------+-----+ +输出： ++---------+-----+ +| name | age | ++---------+-----+ +| Ulysses | 13 | ++---------+-----+ +解释： +学生 Ulysses 的 student_id = 101，所以我们输出了他的 name 和 age。+ + + \ No newline at end of file diff --git "a/AllProblems/2881.\345\210\233\345\273\272\346\226\260\345\210\227.md" "b/AllProblems/2881.\345\210\233\345\273\272\346\226\260\345\210\227.md" new file mode 100644 index 00000000000..45c4ac6fbe0 --- /dev/null +++ "b/AllProblems/2881.\345\210\233\345\273\272\346\226\260\345\210\227.md" @@ -0,0 +1,59 @@ +--- +title: 2881.创建新列 +date: 2023-10-10 14-41-38 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2881.创建新列 + +力扣题目链接：[https://leetcode.cn/problems/create-a-new-column/](https://leetcode.cn/problems/create-a-new-column/) + +
+DataFrame employees
++-------------+--------+
+| Column Name | Type. |
++-------------+--------+
+| name | object |
+| salary | int. |
++-------------+--------+
+
+
+一家公司计划为员工提供奖金。
+ +编写一个解决方案，创建一个名为 bonus 的新列，其中包含 salary 值的 两倍。
返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： +DataFrame employees ++---------+--------+ +| name | salary | ++---------+--------+ +| Piper | 4548 | +| Grace | 28150 | +| Georgia | 1103 | +| Willow | 6593 | +| Finn | 74576 | +| Thomas | 24433 | ++---------+--------+ +输出： ++---------+--------+--------+ +| name | salary | bonus | ++---------+--------+--------+ +| Piper | 4548 | 9096 | +| Grace | 28150 | 56300 | +| Georgia | 1103 | 2206 | +| Willow | 593 | 13186 | +| Finn | 74576 | 149152 | +| Thomas | 24433 | 48866 | ++---------+--------+--------+ +解释： +通过将 salary 列中的值加倍创建了一个新的 bonus 列。+ + + \ No newline at end of file diff --git "a/AllProblems/2882.\345\210\240\345\216\273\351\207\215\345\244\215\347\232\204\350\241\214.md" "b/AllProblems/2882.\345\210\240\345\216\273\351\207\215\345\244\215\347\232\204\350\241\214.md" new file mode 100644 index 00000000000..14ec31a5292 --- /dev/null +++ "b/AllProblems/2882.\345\210\240\345\216\273\351\207\215\345\244\215\347\232\204\350\241\214.md" @@ -0,0 +1,59 @@ +--- +title: 2882.删去重复的行 +date: 2023-10-10 14-41-39 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2882.删去重复的行 + +力扣题目链接：[https://leetcode.cn/problems/drop-duplicate-rows/](https://leetcode.cn/problems/drop-duplicate-rows/) + +
+DataFrame customers ++-------------+--------+ +| Column Name | Type | ++-------------+--------+ +| customer_id | int | +| name | object | +| email | object | ++-------------+--------+ ++ +
在 DataFrame 中基于 email 列存在一些重复行。
编写一个解决方案，删除这些重复行，仅保留第一次出现的行。
+ +返回结果格式如下例所示。
+ ++ +
示例 1:
+ ++输入： ++-------------+---------+---------------------+ +| customer_id | name | email | ++-------------+---------+---------------------+ +| 1 | Ella | emily@example.com | +| 2 | David | michael@example.com | +| 3 | Zachary | sarah@example.com | +| 4 | Alice | john@example.com | +| 5 | Finn | john@example.com | +| 6 | Violet | alice@example.com | ++-------------+---------+---------------------+ +输出： ++-------------+---------+---------------------+ +| customer_id | name | email | ++-------------+---------+---------------------+ +| 1 | Ella | emily@example.com | +| 2 | David | michael@example.com | +| 3 | Zachary | sarah@example.com | +| 4 | Alice | john@example.com | +| 6 | Violet | alice@example.com | ++-------------+---------+---------------------+ +解释： +Alice (customer_id = 4) 和 Finn (customer_id = 5) 都使用 john@example.com，因此只保留该邮箱地址的第一次出现。 ++ + + \ No newline at end of file diff --git "a/AllProblems/2883.\345\210\240\345\216\273\344\270\242\345\244\261\347\232\204\346\225\260\346\215\256.md" "b/AllProblems/2883.\345\210\240\345\216\273\344\270\242\345\244\261\347\232\204\346\225\260\346\215\256.md" new file mode 100644 index 00000000000..08e3466c152 --- /dev/null +++ "b/AllProblems/2883.\345\210\240\345\216\273\344\270\242\345\244\261\347\232\204\346\225\260\346\215\256.md" @@ -0,0 +1,53 @@ +--- +title: 2883.删去丢失的数据 +date: 2023-10-10 14-41-39 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2883.删去丢失的数据 + +力扣题目链接：[https://leetcode.cn/problems/drop-missing-data/](https://leetcode.cn/problems/drop-missing-data/) + +
+DataFrame students ++-------------+--------+ +| Column Name | Type | ++-------------+--------+ +| student_id | int | +| name | object | +| age | int | ++-------------+--------+ ++ +
在 name 列里有一些具有缺失值的行。
编写一个解决方案，删除具有缺失值的行。
+ +返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： ++------------+-------+-----+ +| student_id | name | age | ++------------+-------+-----+ +| 32 | Piper | 5 | +| 217 | Grace | 19 | +| 779 | None | 20 | +| 849 | None | 14 | ++------------+-------+-----+ +输出： ++------------+-------+-----+ +| student_id | name | age | ++------------+-------+-----+ +| 32 | Piper | 5 | +| 217 | Grace | 19 | ++------------+-------+-----+ +解释： +学号为 779 和 849 的学生所在行在 name 列中有空值，因此它们将被删除。+ + + \ No newline at end of file diff --git "a/AllProblems/2884.\344\277\256\346\224\271\345\210\227.md" "b/AllProblems/2884.\344\277\256\346\224\271\345\210\227.md" new file mode 100644 index 00000000000..cea66449ec2 --- /dev/null +++ "b/AllProblems/2884.\344\277\256\346\224\271\345\210\227.md" @@ -0,0 +1,55 @@ +--- +title: 2884.修改列 +date: 2023-10-10 14-41-39 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2884.修改列 + +力扣题目链接：[https://leetcode.cn/problems/modify-columns/](https://leetcode.cn/problems/modify-columns/) + +
+DataFrame employees
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| name | object |
+| salary | int |
++-------------+--------+
+
+
+一家公司决定增加员工的薪水。
+ +编写一个解决方案，将每个员工的薪水乘以2来 修改 salary 列。
返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： +DataFrame employees ++---------+--------+ +| name | salary | ++---------+--------+ +| Jack | 19666 | +| Piper | 74754 | +| Mia | 62509 | +| Ulysses | 54866 | ++---------+--------+ +输出： ++---------+--------+ +| name | salary | ++---------+--------+ +| Jack | 39332 | +| Piper | 149508 | +| Mia | 125018 | +| Ulysses | 109732 | ++---------+--------+ +解释： +每个人的薪水都被加倍。+ + + \ No newline at end of file diff --git "a/AllProblems/2885.\351\207\215\345\221\275\345\220\215\345\210\227.md" "b/AllProblems/2885.\351\207\215\345\221\275\345\220\215\345\210\227.md" new file mode 100644 index 00000000000..4c686e4bfcc --- /dev/null +++ "b/AllProblems/2885.\351\207\215\345\221\275\345\220\215\345\210\227.md" @@ -0,0 +1,63 @@ +--- +title: 2885.重命名列 +date: 2023-10-10 14-41-40 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2885.重命名列 + +力扣题目链接：[https://leetcode.cn/problems/rename-columns/](https://leetcode.cn/problems/rename-columns/) + +
+DataFrame students
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| id | int |
+| first | object |
+| last | object |
+| age | int |
++-------------+--------+
+
+
+编写一个解决方案，按以下方式重命名列：
+ +id 重命名为 student_idfirst 重命名为 first_namelast 重命名为 last_nameage 重命名为 age_in_years返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： ++----+---------+----------+-----+ +| id | first | last | age | ++----+---------+----------+-----+ +| 1 | Mason | King | 6 | +| 2 | Ava | Wright | 7 | +| 3 | Taylor | Hall | 16 | +| 4 | Georgia | Thompson | 18 | +| 5 | Thomas | Moore | 10 | ++----+---------+----------+-----+ +输出： ++------------+------------+-----------+--------------+ +| student_id | first_name | last_name | age_in_years | ++------------+------------+-----------+--------------+ +| 1 | Mason | King | 6 | +| 2 | Ava | Wright | 7 | +| 3 | Taylor | Hall | 16 | +| 4 | Georgia | Thompson | 18 | +| 5 | Thomas | Moore | 10 | ++------------+------------+-----------+--------------+ +解释： +列名已相应更换。+ + + \ No newline at end of file diff --git "a/AllProblems/2886.\346\224\271\345\217\230\346\225\260\346\215\256\347\261\273\345\236\213.md" "b/AllProblems/2886.\346\224\271\345\217\230\346\225\260\346\215\256\347\261\273\345\236\213.md" new file mode 100644 index 00000000000..6fc02fa5868 --- /dev/null +++ "b/AllProblems/2886.\346\224\271\345\217\230\346\225\260\346\215\256\347\261\273\345\236\213.md" @@ -0,0 +1,53 @@ +--- +title: 2886.改变数据类型 +date: 2023-10-10 14-41-40 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2886.改变数据类型 + +力扣题目链接：[https://leetcode.cn/problems/change-data-type/](https://leetcode.cn/problems/change-data-type/) + +
+DataFrame students
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| student_id | int |
+| name | object |
+| age | int |
+| grade | float |
++-------------+--------+
+
+
+编写一个解决方案来纠正以下错误：
+ + grade 列被存储为浮点数，将它转换为整数。
返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： +DataFrame students: ++------------+------+-----+-------+ +| student_id | name | age | grade | ++------------+------+-----+-------+ +| 1 | Ava | 6 | 73.0 | +| 2 | Kate | 15 | 87.0 | ++------------+------+-----+-------+ +输出： ++------------+------+-----+-------+ +| student_id | name | age | grade | ++------------+------+-----+-------+ +| 1 | Ava | 6 | 73 | +| 2 | Kate | 15 | 87 | ++------------+------+-----+-------+ +解释： +grade 列的数据类型已转换为整数。+ + + \ No newline at end of file diff --git "a/AllProblems/2887.\345\241\253\345\205\205\347\274\272\345\244\261\345\200\274.md" "b/AllProblems/2887.\345\241\253\345\205\205\347\274\272\345\244\261\345\200\274.md" new file mode 100644 index 00000000000..034034b5070 --- /dev/null +++ "b/AllProblems/2887.\345\241\253\345\205\205\347\274\272\345\244\261\345\200\274.md" @@ -0,0 +1,52 @@ +--- +title: 2887.填充缺失值 +date: 2023-10-10 14-41-40 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2887.填充缺失值 + +力扣题目链接：[https://leetcode.cn/problems/fill-missing-data/](https://leetcode.cn/problems/fill-missing-data/) + +
+DataFrame products
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| name | object |
+| quantity | int |
+| price | int |
++-------------+--------+
+
+
+编写一个解决方案，在 quantity 列中将缺失的值填充为 0。
返回结果如下示例所示。
+ ++示例 1： + +
+输入： ++-----------------+----------+-------+ +| name | quantity | price | ++-----------------+----------+-------+ +| Wristwatch | 32 | 135 | +| WirelessEarbuds | None | 821 | +| GolfClubs | None | 9319 | +| Printer | 849 | 3051 | ++-----------------+----------+-------+ +输出： ++-----------------+----------+-------+ +| name | quantity | price | ++-----------------+----------+-------+ +| Wristwatch | 32 | 135 | +| WirelessEarbuds | 0 | 821 | +| GolfClubs | 0 | 9319 | +| Printer | 849 | 3051 | ++-----------------+----------+-------+ +解释： +Toaster 和 Headphones 的数量被填充为 0。+ + + \ No newline at end of file diff --git "a/AllProblems/2888.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\277\236\347\273\223.md" "b/AllProblems/2888.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\277\236\347\273\223.md" new file mode 100644 index 00000000000..123d63e8895 --- /dev/null +++ "b/AllProblems/2888.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\277\236\347\273\223.md" @@ -0,0 +1,73 @@ +--- +title: 2888.重塑数据：连结 +date: 2023-10-10 14-41-41 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2888.重塑数据：连结 + +力扣题目链接：[https://leetcode.cn/problems/reshape-data-concatenate/](https://leetcode.cn/problems/reshape-data-concatenate/) + +
+DataFrame+ +df1++-------------+--------+ +| Column Name | Type | ++-------------+--------+ +| student_id | int | +| name | object | +| age | int | ++-------------+--------+ + +DataFramedf2++-------------+--------+ +| Column Name | Type | ++-------------+--------+ +| student_id | int | +| name | object | +| age | int | ++-------------+--------+ + +
编写一个解决方案，将两个 DataFrames 垂直 连接成一个 DataFrame。
+ +结果格式如下示例所示。
+ ++ +
示例 1：
+ ++输入： +df1 ++------------+---------+-----+ +| student_id | name | age | ++------------+---------+-----+ +| 1 | Mason | 8 | +| 2 | Ava | 6 | +| 3 | Taylor | 15 | +| 4 | Georgia | 17 | ++------------+---------+-----+ +df2 ++------------+------+-----+ +| student_id | name | age | ++------------+------+-----+ +| 5 | Leo | 7 | +| 6 | Alex | 7 | ++------------+------+-----+ +输出： ++------------+---------+-----+ +| student_id | name | age | ++------------+---------+-----+ +| 1 | Mason | 8 | +| 2 | Ava | 6 | +| 3 | Taylor | 15 | +| 4 | Georgia | 17 | +| 5 | Leo | 7 | +| 6 | Alex | 7 | ++------------+---------+-----+ +解释： +两个 DataFrame 被垂直堆叠，它们的行被合并。+ + + \ No newline at end of file diff --git "a/AllProblems/2889.\346\225\260\346\215\256\351\207\215\345\241\221\357\274\232\351\200\217\350\247\206.md" "b/AllProblems/2889.\346\225\260\346\215\256\351\207\215\345\241\221\357\274\232\351\200\217\350\247\206.md" new file mode 100644 index 00000000000..0e929b591fa --- /dev/null +++ "b/AllProblems/2889.\346\225\260\346\215\256\351\207\215\345\241\221\357\274\232\351\200\217\350\247\206.md" @@ -0,0 +1,59 @@ +--- +title: 2889.数据重塑：透视 +date: 2023-10-10 14-41-41 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2889.数据重塑：透视 + +力扣题目链接：[https://leetcode.cn/problems/reshape-data-pivot/](https://leetcode.cn/problems/reshape-data-pivot/) + +
+DataFrame weather
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| city | object |
+| month | object |
+| temperature | int |
++-------------+--------+
+
+
+编写一个解决方案，以便将数据 旋转，使得每一行代表特定月份的温度，而每个城市都是一个单独的列。
+ +输出结果格式如下示例所示。
+ ++示例 1: + +
+输入：
++--------------+----------+-------------+
+| city | month | temperature |
++--------------+----------+-------------+
+| Jacksonville | January | 13 |
+| Jacksonville | February | 23 |
+| Jacksonville | March | 38 |
+| Jacksonville | April | 5 |
+| Jacksonville | May | 34 |
+| ElPaso | January | 20 |
+| ElPaso | February | 6 |
+| ElPaso | March | 26 |
+| ElPaso | April | 2 |
+| ElPaso | May | 43 |
++--------------+----------+-------------+
+输出：
++----------+--------+--------------+
+| month | ElPaso | Jacksonville |
++----------+--------+--------------+
+| April | 2 | 5 |
+| February | 6 | 23 |
+| January | 20 | 13 |
+| March | 26 | 38 |
+| May | 43 | 34 |
++----------+--------+--------------+
+解释：
+表格被旋转，每一列代表一个城市，每一行代表特定的月份。
+
+
+
\ No newline at end of file
diff --git "a/AllProblems/2890.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\236\215\345\220\210.md" "b/AllProblems/2890.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\236\215\345\220\210.md"
new file mode 100644
index 00000000000..67ec4d1fbe8
--- /dev/null
+++ "b/AllProblems/2890.\351\207\215\345\241\221\346\225\260\346\215\256\357\274\232\350\236\215\345\220\210.md"
@@ -0,0 +1,58 @@
+---
+title: 2890.重塑数据：融合
+date: 2023-10-10 14-41-42
+tags: [题解, LeetCode, 简单, ]
+---
+
+# 【LetMeFly】2890.重塑数据：融合
+
+力扣题目链接：[https://leetcode.cn/problems/reshape-data-melt/](https://leetcode.cn/problems/reshape-data-melt/)
+
+
+DataFrame report
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| product | object |
+| quarter_1 | int |
+| quarter_2 | int |
+| quarter_3 | int |
+| quarter_4 | int |
++-------------+--------+
+
+
+编写一个解决方案，将数据 重塑 成每一行表示特定季度产品销售数据的形式。
+ +结果格式如下例所示：
+ ++ +
示例 1：
+ ++输入： ++-------------+-----------+-----------+-----------+-----------+ +| product | quarter_1 | quarter_2 | quarter_3 | quarter_4 | ++-------------+-----------+-----------+-----------+-----------+ +| Umbrella | 417 | 224 | 379 | 611 | +| SleepingBag | 800 | 936 | 93 | 875 | ++-------------+-----------+-----------+-----------+-----------+ +输出： ++-------------+-----------+-------+ +| product | quarter | sales | ++-------------+-----------+-------+ +| Umbrella | quarter_1 | 417 | +| SleepingBag | quarter_1 | 800 | +| Umbrella | quarter_2 | 224 | +| SleepingBag | quarter_2 | 936 | +| Umbrella | quarter_3 | 379 | +| SleepingBag | quarter_3 | 93 | +| Umbrella | quarter_4 | 611 | +| SleepingBag | quarter_4 | 875 | ++-------------+-----------+-------+ +解释： +DataFrame 已从宽格式重塑为长格式。每一行表示一个季度内产品的销售情况。 ++ + + \ No newline at end of file diff --git "a/AllProblems/2891.\346\226\271\346\263\225\351\223\276.md" "b/AllProblems/2891.\346\226\271\346\263\225\351\223\276.md" new file mode 100644 index 00000000000..12d0c63dc96 --- /dev/null +++ "b/AllProblems/2891.\346\226\271\346\263\225\351\223\276.md" @@ -0,0 +1,67 @@ +--- +title: 2891.方法链 +date: 2023-10-10 14-41-42 +tags: [题解, LeetCode, 简单, ] +--- + +# 【LetMeFly】2891.方法链 + +力扣题目链接：[https://leetcode.cn/problems/method-chaining/](https://leetcode.cn/problems/method-chaining/) + +
+DataFrame animals
++-------------+--------+
+| Column Name | Type |
++-------------+--------+
+| name | object |
+| species | object |
+| age | int |
+| weight | int |
++-------------+--------+
+
+
+编写一个解决方案来列出体重 严格超过 100 千克的动物的名称。
按体重 降序 返回动物。
+ +返回结果格式如下示例所示。
+ ++ +
示例 1:
+ ++输入： +DataFrame animals: ++----------+---------+-----+--------+ +| name | species | age | weight | ++----------+---------+-----+--------+ +| Tatiana | Snake | 98 | 464 | +| Khaled | Giraffe | 50 | 41 | +| Alex | Leopard | 6 | 328 | +| Jonathan | Monkey | 45 | 463 | +| Stefan | Bear | 100 | 50 | +| Tommy | Panda | 26 | 349 | ++----------+---------+-----+--------+ +输出： ++----------+ +| name | ++----------+ +| Tatiana | +| Jonathan | +| Tommy | +| Alex | ++----------+ +解释： +所有体重超过 100 的动物都应包含在结果表中。 +Tatiana 的体重为 464，Jonathan 的体重为 463，Tommy 的体重为 349，Alex 的体重为 328。 +结果应按体重降序排序。+ +
+ +
在 Pandas 中，方法链 允许我们在 DataFrame 上执行操作，而无需将每个操作拆分成单独的行或创建多个临时变量。
+ +你能用 一行 代码的方法链完成这个任务吗？
+ + + \ No newline at end of file diff --git "a/AllProblems/2894.\345\210\206\347\261\273\346\261\202\345\222\214\345\271\266\344\275\234\345\267\256.md" "b/AllProblems/2894.\345\210\206\347\261\273\346\261\202\345\222\214\345\271\266\344\275\234\345\267\256.md" new file mode 100644 index 00000000000..47f2212354a --- /dev/null +++ "b/AllProblems/2894.\345\210\206\347\261\273\346\261\202\345\222\214\345\271\266\344\275\234\345\267\256.md" @@ -0,0 +1,66 @@ +--- +title: 2894.分类求和并作差 +date: 2023-10-10 14-41-43 +tags: [题解, LeetCode, 简单, 数学] +--- + +# 【LetMeFly】2894.分类求和并作差 + +力扣题目链接：[https://leetcode.cn/problems/divisible-and-non-divisible-sums-difference/](https://leetcode.cn/problems/divisible-and-non-divisible-sums-difference/) + +给你两个正整数 n 和 m 。
现定义两个整数 num1 和 num2 ，如下所示：
num1：范围 [1, n] 内所有 无法被 m 整除 的整数之和。num2：范围 [1, n] 内所有 能够被 m 整除 的整数之和。返回整数 num1 - num2 。
+ +
示例 1：
+ ++输入：n = 10, m = 3 +输出：19 +解释：在这个示例中： +- 范围 [1, 10] 内无法被 3 整除的整数为 [1,2,4,5,7,8,10] ，num1 = 这些整数之和 = 37 。 +- 范围 [1, 10] 内能够被 3 整除的整数为 [3,6,9] ，num2 = 这些整数之和 = 18 。 +返回 37 - 18 = 19 作为答案。 ++ +
示例 2：
+ ++输入：n = 5, m = 6 +输出：15 +解释：在这个示例中： +- 范围 [1, 5] 内无法被 6 整除的整数为 [1,2,3,4,5] ，num1 = 这些整数之和 = 15 。 +- 范围 [1, 5] 内能够被 6 整除的整数为 [] ，num2 = 这些整数之和 = 0 。 +返回 15 - 0 = 15 作为答案。 ++ +
示例 3：
+ ++输入：n = 5, m = 1 +输出：-15 +解释：在这个示例中： +- 范围 [1, 5] 内无法被 1 整除的整数为 [] ，num1 = 这些整数之和 = 0 。 +- 范围 [1, 5] 内能够被 1 整除的整数为 [1,2,3,4,5] ，num2 = 这些整数之和 = 15 。 +返回 0 - 15 = -15 作为答案。 ++ +
+ +
提示：
+ +1 <= n, m <= 1000你有 n 颗处理器，每颗处理器都有 4 个核心。现有 n * 4 个待执行任务，每个核心只执行 一个 任务。
给你一个下标从 0 开始的整数数组 processorTime ，表示每颗处理器最早空闲时间。另给你一个下标从 0 开始的整数数组 tasks ，表示执行每个任务所需的时间。返回所有任务都执行完毕需要的 最小时间 。
注意：每个核心独立执行任务。
+ ++ +
示例 1：
+ ++输入：processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5] +输出：16 +解释： +最优的方案是将下标为 4, 5, 6, 7 的任务分配给第一颗处理器（最早空闲时间 time = 8），下标为 0, 1, 2, 3 的任务分配给第二颗处理器（最早空闲时间 time = 10）。 +第一颗处理器执行完所有任务需要花费的时间 = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16 。 +第二颗处理器执行完所有任务需要花费的时间 = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13 。 +因此，可以证明执行完所有任务需要花费的最小时间是 16 。+ +
示例 2：
+ ++输入：processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3] +输出：23 +解释： +最优的方案是将下标为 1, 4, 5, 6 的任务分配给第一颗处理器（最早空闲时间 time = 10），下标为 0, 2, 3, 7 的任务分配给第二颗处理器（最早空闲时间 time = 20）。 +第一颗处理器执行完所有任务需要花费的时间 = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18 。 +第二颗处理器执行完所有任务需要花费的时间 = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23 。 +因此，可以证明执行完所有任务需要花费的最小时间是 23 。 ++ +
+ +
提示：
+ +1 <= n == processorTime.length <= 250001 <= tasks.length <= 1050 <= processorTime[i] <= 1091 <= tasks[i] <= 109tasks.length == 4 * n给你两个下标从 0 开始的二进制字符串 s1 和 s2 ，两个字符串的长度都是 n ，再给你一个正整数 x 。
你可以对字符串 s1 执行以下操作 任意次 ：
i 和 j ，将 s1[i] 和 s1[j] 都反转，操作的代价为 x 。i < n - 1 的下标 i ，反转 s1[i] 和 s1[i + 1] ，操作的代价为 1 。请你返回使字符串 s1 和 s2 相等的 最小 操作代价之和，如果无法让二者相等，返回 -1 。
注意 ，反转字符的意思是将 0 变成 1 ，或者 1 变成 0 。
+ +
示例 1：
+ ++输入：s1 = "1100011000", s2 = "0101001010", x = 2 +输出：4 +解释：我们可以执行以下操作： +- 选择 i = 3 执行第二个操作。结果字符串是 s1 = "1101111000" 。 +- 选择 i = 4 执行第二个操作。结果字符串是 s1 = "1101001000" 。 +- 选择 i = 0 和 j = 8 ，执行第一个操作。结果字符串是 s1 = "0101001010" = s2 。 +总代价是 1 + 1 + 2 = 4 。这是最小代价和。 ++ +
示例 2：
+ ++输入：s1 = "10110", s2 = "00011", x = 4 +输出：-1 +解释：无法使两个字符串相等。 ++ +
+ +
提示：
+ +n == s1.length == s2.length1 <= n, x <= 500s1 和 s2 只包含字符 '0' 和 '1' 。给你一个下标从 0 开始的整数数组 nums 和一个 正 整数 k 。
你可以对数组执行以下操作 任意次 ：
+ +i 和 j ，同时 将 nums[i] 更新为 (nums[i] AND nums[j]) 且将 nums[j] 更新为 (nums[i] OR nums[j]) ，OR 表示按位 或 运算，AND 表示按位 与 运算。你需要从最终的数组里选择 k 个元素，并计算它们的 平方 之和。
请你返回你可以得到的 最大 平方和。
+ +由于答案可能会很大，将答案对 109 + 7 取余 后返回。
+ +
示例 1：
+ ++输入：nums = [2,6,5,8], k = 2 +输出：261 +解释：我们可以对数组执行以下操作： +- 选择 i = 0 和 j = 3 ，同时将 nums[0] 变为 (2 AND 8) = 0 且 nums[3] 变为 (2 OR 8) = 10 ，结果数组为 nums = [0,6,5,10] 。 +- 选择 i = 2 和 j = 3 ，同时将 nums[2] 变为 (5 AND 10) = 0 且 nums[3] 变为 (5 OR 10) = 15 ，结果数组为 nums = [0,6,0,15] 。 +从最终数组里选择元素 15 和 6 ，平方和为 152 + 62 = 261 。 +261 是可以得到的最大结果。 ++ +
示例 2：
+ ++输入：nums = [4,5,4,7], k = 3 +输出：90 +解释：不需要执行任何操作。 +选择元素 7 ，5 和 4 ，平方和为 72 + 52 + 42 = 90 。 +90 是可以得到的最大结果。 ++ +
+ +
提示：
+ +1 <= k <= nums.length <= 1051 <= nums[i] <= 109输入: s = "abcabcbb" 输出: 3 -解释: 因为无重复字符的最长子串是"abc"，所以其长度为 3。 +解释: 因为无重复字符的最长子串是"abc"，所以其长度为 3。
示例 2:
diff --git "a/AllProblems/30.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" "b/AllProblems/30.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" index 3a5c0edaf5f..0641c896354 100644 --- "a/AllProblems/30.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" +++ "b/AllProblems/30.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" @@ -16,7 +16,7 @@ tags: [题解, LeetCode, 困难, 哈希表, 字符串, 滑动窗口]words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。返回所有串联字串在 s 中的开始索引。你可以以 任意顺序 返回答案。
返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。
diff --git "a/AllProblems/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/AllProblems/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 00000000000..73de03c9d0d --- /dev/null +++ "b/AllProblems/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,47 @@ +--- +title: 309.买卖股票的最佳时机含冷冻期 +date: 2023-10-10 14-21-14 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】309.买卖股票的最佳时机含冷冻期 + +力扣题目链接：[https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/) + +
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
+ +注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+ ++ +
示例 1:
+ ++输入: prices = [1,2,3,0,2] +输出: 3 +解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]+ +
示例 2:
+ ++输入: prices = [1] +输出: 0 ++ +
+ +
提示：
+ +1 <= prices.length <= 50000 <= prices[i] <= 1000给定一组 互不相同 的单词， 找出所有 不同 的索引对 (i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。
给定一个由唯一字符串构成的 0 索引 数组 words 。
+
回文对 是一对整数 (i, j) ，满足以下条件：
0 <= i, j < words.length，i != j ，并且words[i] + words[j]（两个字符串的连接）是一个回文。返回一个数组，它包含 words 中所有满足 回文对 条件的字符串。
你必须设计一个时间复杂度为 O(sum of words[i].length) 的算法。
示例 1：
@@ -33,13 +45,13 @@ tags: [题解, LeetCode, 困难, 字典树, 数组, 哈希表, 字符串] 输入：words = ["a",""] 输出：[[0,1],[1,0]] - +提示：
1 <= words.length <= 50000 <= words[i].length <= 3001 <= words.length <= 50000 <= words[i].length <= 300words[i] 由小写英文字母组成给定两个以 升序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。
给定两个以 非递减顺序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。
定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。
-
示例 1:
+示例 1:
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
@@ -25,7 +25,7 @@ tags: [题解, LeetCode, 中等, 数组, 堆（优先队列）]
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
-示例 2:
+示例 2:
输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2 @@ -34,7 +34,7 @@ tags: [题解, LeetCode, 中等, 数组, 堆（优先队列）] [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]-
示例 3:
+示例 3:
输入: nums1 = [1,2], nums2 = [3], k = 3 @@ -50,7 +50,7 @@ tags: [题解, LeetCode, 中等, 数组, 堆（优先队列）]
1 <= nums1.length, nums2.length <= 105-109 <= nums1[i], nums2[i] <= 109nums1 和 nums2 均为升序排列1 <= k <= 10001 <= k <= 104给你一个字符串 s 和一个整数 k ，请你找出 s 中的最长子串， 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。
给你一个字符串 s 和一个整数 k ，请你找出 s 中的最长子串， 要求该子串中的每一字符出现次数都不少于 k 。返回这一子串的长度。
+
如果不存在这样的子字符串，则返回 0。
+ +
示例 1：
@@ -27,14 +29,14 @@ tags: [题解, LeetCode, 中等, 哈希表, 字符串, 分治, 滑动窗口] 输出：5 解释：最长子串为 "ababb" ，其中 'a' 重复了 2 次， 'b' 重复了 3 次。 -+
提示：
1 <= s.length <= 1041 <= s.length <= 104s 仅由小写英文字母组成1 <= k <= 1051 <= k <= 105注意：输入总是有效的。你可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。
-+
注意：未在等式列表中出现的变量是未定义的，因此无法确定它们的答案。
-示例 1：
++ +
示例 1：
输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]] @@ -27,35 +29,35 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查 条件：a / b = 2.0, b / c = 3.0 问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? 结果：[6.0, 0.5, -1.0, 1.0, -1.0 ] -+注意：x 是未定义的 => -1.0 -
示例 2：
+示例 2：
输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]] 输出：[3.75000,0.40000,5.00000,0.20000]-
示例 3：
+示例 3：
输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]] 输出：[0.50000,2.00000,-1.00000,-1.00000]-
+
提示：
1 <= equations.length <= 201 <= equations.length <= 20equations[i].length == 21 <= Ai.length, Bi.length <= 51 <= Ai.length, Bi.length <= 5values.length == equations.length0.0 < values[i] <= 20.01 <= queries.length <= 200.0 < values[i] <= 20.01 <= queries.length <= 20queries[i].length == 21 <= Cj.length, Dj.length <= 51 <= Cj.length, Dj.length <= 5Ai, Bi, Cj, Dj 由小写英文字母与数字组成二进制手表顶部有 4 个 LED 代表 小时（0-11），底部的 6 个 LED 代表 分钟（0-59）。每个 LED 代表一个 0 或 1，最低位在右侧。
"3:25" 。"4:51" 。
（图源：WikiMedia - Binary clock samui moon.jpg ，许可协议：Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) ）
+
给你一个整数 turnedOn ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。你可以 按任意顺序 返回答案。
"10:2" 是无效的时间，正确的写法应该是 "10:02" 。+
示例 1：
@@ -48,12 +46,12 @@ tags: [题解, LeetCode, 简单, 位运算, 回溯] 输出：[] -+
提示：
0 <= turnedOn <= 100 <= turnedOn <= 10给你一个 n * n 矩阵 grid ，矩阵由若干 0 和 1 组成。请你用四叉树表示该矩阵 grid 。
你需要返回能表示矩阵的 四叉树 的根结点。
- -注意，当 isLeaf 为 False 时，你可以把 True 或者 False 赋值给节点，两种值都会被判题机制 接受 。
你需要返回能表示矩阵 grid 的 四叉树 的根结点。
四叉树数据结构中，每个内部节点只有四个子节点。此外，每个节点都有两个属性：
val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False；val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False。注意，当 isLeaf 为 False 时，你可以把 True 或者 False 赋值给节点，两种值都会被判题机制 接受 。isLeaf: 当这个节点是一个叶子结点时为 True，如果它有 4 个子节点则为 False 。class Node {
+
+class Node {
public boolean val;
public boolean isLeaf;
public Node topLeft;
@@ -38,13 +37,13 @@ tags: [题解, LeetCode, 中等, 树, 数组, 分治, 矩阵]
如果你想了解更多关于四叉树的内容，可以参考 wiki 。
四叉树格式：
-输出为使用层序遍历后四叉树的序列化形式，其中 null 表示路径终止符，其下面不存在节点。
你不需要阅读本节来解决这个问题。只有当你想了解输出格式时才会这样做。输出为使用层序遍历后四叉树的序列化形式，其中 null 表示路径终止符，其下面不存在节点。
它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 [isLeaf, val] 。
示例 1：
-
输入：grid = [[0,1],[1,0]] ++输入：grid = [[0,1],[1,0]] 输出：[[0,1],[1,0],[1,1],[1,1],[1,0]] 解释：此示例的解释如下： 请注意，在下面四叉树的图示中，0 表示 false，1 表示 True 。 -+
示例 2：
-+
-
输入：grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]] ++输入：grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]] 输出：[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]] 解释：网格中的所有值都不相同。我们将网格划分为四个子网格。 topLeft，bottomLeft 和 bottomRight 均具有相同的值。 topRight 具有不同的值，因此我们将其再分为 4 个子网格，这样每个子网格都具有相同的值。 解释如下图所示： -- --
示例 3：
- -输入：grid = [[1,1],[1,1]] -输出：[[1,1]] -- -示例 4：
- -输入：grid = [[0]] -输出：[[1,0]] -- -示例 5：
- -输入：grid = [[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]] -输出：[[0,1],[1,1],[1,0],[1,0],[1,1]] +@@ -100,7 +83,7 @@ topRight 具有不同的值，因此我们将其再分为 4 个子网格，这
diff --git "a/AllProblems/460.LFU \347\274\223\345\255\230.md" "b/AllProblems/460.LFU \347\274\223\345\255\230.md" index 1161e56742c..3fbe2c9a08c 100644 --- "a/AllProblems/460.LFU \347\274\223\345\255\230.md" +++ "b/AllProblems/460.LFU \347\274\223\345\255\230.md" @@ -15,7 +15,7 @@ tags: [题解, LeetCode, 困难, 设计, 哈希表, 链表, 双向链表]
- -
n == grid.length == grid[i].length- +
n == 2^x其中0 <= x <= 6n == 2x其中0 <= x <= 6
LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象int get(int key) - 如果键 key 存在于缓存中，则获取键的值，否则返回 -1 。void put(int key, int value) - 如果键 key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最近最久未使用 的键。void put(int key, int value) - 如果键 key 已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量 capacity 时，则应该在插入新项之前，移除最不经常使用的项。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除 最久未使用 的键。为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。
@@ -61,7 +61,7 @@ lfu.get(4); // 返回 4提示：
0 <= capacity <= 1041 <= capacity <= 1040 <= key <= 1050 <= value <= 1092 * 105 次 get 和 put 方法冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
+冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
在加热器的加热半径范围内的每个房屋都可以获得供暖。
-现在，给出位于一条水平线上的房屋 houses 和供暖器 heaters 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。
现在，给出位于一条水平线上的房屋 houses 和供暖器 heaters 的位置，请你找出并返回可以覆盖所有房屋的最小加热半径。
说明：所有供暖器都遵循你的半径标准，加热的半径也一样。
+注意：所有供暖器 heaters 都遵循你的半径标准，加热的半径也一样。
+
示例 1:
输入: houses = [1,2,3], heaters = [2] 输出: 1 -解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1，那么所有房屋就都能得到供暖。 +解释: 仅在位置 2 上有一个供暖器。如果我们将加热半径设为 1，那么所有房屋就都能得到供暖。
示例 2:
@@ -31,7 +31,7 @@ tags: [题解, LeetCode, 中等, 数组, 双指针, 二分查找, 排序]输入: houses = [1,2,3,4], heaters = [1,4] 输出: 1 -解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1，这样所有房屋就都能得到供暖。 +解释: 在位置 1, 4 上有两个供暖器。我们需要将加热半径设为 1，这样所有房屋就都能得到供暖。
示例 3：
@@ -41,13 +41,13 @@ tags: [题解, LeetCode, 中等, 数组, 双指针, 二分查找, 排序] 输出：3 -+
提示：
1 <= houses.length, heaters.length <= 3 * 1041 <= houses[i], heaters[i] <= 1091 <= houses.length, heaters.length <= 3 * 1041 <= houses[i], heaters[i] <= 109给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
-字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。
+字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
diff --git "a/AllProblems/494.\347\233\256\346\240\207\345\222\214.md" "b/AllProblems/494.\347\233\256\346\240\207\345\222\214.md" index 54a2018442e..2bd5a11c811 100644 --- "a/AllProblems/494.\347\233\256\346\240\207\345\222\214.md" +++ "b/AllProblems/494.\347\233\256\346\240\207\345\222\214.md" @@ -8,9 +8,9 @@ tags: [题解, LeetCode, 中等, 数组, 动态规划, 回溯] 力扣题目链接：[https://leetcode.cn/problems/target-sum/](https://leetcode.cn/problems/target-sum/) -
给你一个整数数组 nums 和一个整数 target 。
给你一个非负整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：
向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：
nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
+
示例 1：
@@ -40,15 +40,15 @@ tags: [题解, LeetCode, 中等, 数组, 动态规划, 回溯] 输出：1 -+
提示：
1 <= nums.length <= 200 <= nums[i] <= 10000 <= sum(nums[i]) <= 1000-1000 <= target <= 10001 <= nums.length <= 200 <= nums[i] <= 10000 <= sum(nums[i]) <= 1000-1000 <= target <= 1000-
写一条 SQL 查询语句获取每位玩家 第一次登陆平台的日期。
+查询每位玩家 第一次登陆平台的日期。
查询结果的格式如下所示：
diff --git "a/AllProblems/529.\346\211\253\351\233\267\346\270\270\346\210\217.md" "b/AllProblems/529.\346\211\253\351\233\267\346\270\270\346\210\217.md" index 0b7f9bc3738..c6520cf013e 100644 --- "a/AllProblems/529.\346\211\253\351\233\267\346\270\270\346\210\217.md" +++ "b/AllProblems/529.\346\211\253\351\233\267\346\270\270\346\210\217.md" @@ -34,14 +34,14 @@ tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 数组,
示例 1：
-
+
输入：board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0] 输出：[["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
示例 2：
-
+
输入：board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2] 输出：[["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]] diff --git "a/AllProblems/55.\350\267\263\350\267\203\346\270\270\346\210\217.md" "b/AllProblems/55.\350\267\263\350\267\203\346\270\270\346\210\217.md" index 220c6ce802b..954f1f5df2e 100644 --- "a/AllProblems/55.\350\267\263\350\267\203\346\270\270\346\210\217.md" +++ "b/AllProblems/55.\350\267\263\350\267\203\346\270\270\346\210\217.md" @@ -8,15 +8,13 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 动态规划] 力扣题目链接：[https://leetcode.cn/problems/jump-game/](https://leetcode.cn/problems/jump-game/) -给定一个非负整数数组
+nums，你最初位于数组的 第一个下标 。给你一个非负整数数组
-nums，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。数组中的每个元素代表你在该位置可以跳跃的最大长度。
+判断你是否能够到达最后一个下标，如果可以，返回
-true；否则，返回false。判断你是否能够到达最后一个下标。
+-
- -
示例 1：
+示例 1：
输入：nums = [2,3,1,1,4] @@ -24,7 +22,7 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 动态规划] 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。-示例 2：
+示例 2：
输入：nums = [3,2,1,0,4] @@ -32,13 +30,13 @@ tags: [题解, LeetCode, 中等, 贪心, 数组, 动态规划] 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。-+
提示：
1 <= nums.length <= 3 * 1040 <= nums[i] <= 1051 <= nums.length <= 1040 <= nums[i] <= 105Table: Activity
+--------------+---------+ +++--------------+---------+ | Column Name | Type | +--------------+---------+ | player_id | int | @@ -18,18 +19,24 @@ tags: [题解, LeetCode, 中等, 数据库] | event_date | date | | games_played | int | +--------------+---------+ -（player_id，event_date）是此表的主键。 +（player_id，event_date）是此表的主键（具有唯一值的列的组合）。 这张表显示了某些游戏的玩家的活动情况。 每一行是一个玩家的记录，他在某一天使用某个设备注销之前登录并玩了很多游戏（可能是 0）。-
编写一个 SQL 查询，报告在首次登录的第二天再次登录的玩家的比率，四舍五入到小数点后两位。换句话说，您需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。
+编写解决方案，报告在首次登录的第二天再次登录的玩家的 比率，四舍五入到小数点后两位。换句话说，你需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。
+ +结果格式如下所示：
-查询结果格式如下所示：
+-
Activity table: +@@ -36,11 +36,11 @@ name 是这张表的主键。示例 1：
+ ++输入： +Activity table: +-----------+-----------+------------+--------------+ | player_id | device_id | event_date | games_played | +-----------+-----------+------------+--------------+ @@ -39,13 +46,13 @@ tags: [题解, LeetCode, 中等, 数据库] | 3 | 1 | 2016-03-02 | 0 | | 3 | 4 | 2018-07-03 | 5 | +-----------+-----------+------------+--------------+ - -Result table: +输出： +-----------+ | fraction | +-----------+ | 0.33 | +-----------+ +解释： 只有 ID 为 1 的玩家在第一天登录后才重新登录，所以答案是 1/3 = 0.33diff --git "a/AllProblems/560.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" "b/AllProblems/560.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" index d9a78115b41..e5077d44033 100644 --- "a/AllProblems/560.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" +++ "b/AllProblems/560.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -10,6 +10,8 @@ tags: [题解, LeetCode, 中等, 数组, 哈希表, 前缀和]给你一个整数数组
+nums和一个整数k，请你统计并返回 该数组中和为k的连续子数组的个数 。子数组是数组中元素的连续非空序列。
+
示例 1：
diff --git "a/AllProblems/570.\350\207\263\345\260\221\346\234\2115\345\220\215\347\233\264\346\216\245\344\270\213\345\261\236\347\232\204\347\273\217\347\220\206.md" "b/AllProblems/570.\350\207\263\345\260\221\346\234\2115\345\220\215\347\233\264\346\216\245\344\270\213\345\261\236\347\232\204\347\273\217\347\220\206.md" index 48bab639493..4b021866a78 100644 --- "a/AllProblems/570.\350\207\263\345\260\221\346\234\2115\345\220\215\347\233\264\346\216\245\344\270\213\345\261\236\347\232\204\347\273\217\347\220\206.md" +++ "b/AllProblems/570.\350\207\263\345\260\221\346\234\2115\345\220\215\347\233\264\346\216\245\344\270\213\345\261\236\347\232\204\347\273\217\347\220\206.md" @@ -19,7 +19,7 @@ tags: [题解, LeetCode, 中等, 数据库] | department | varchar | | managerId | int | +-------------+---------+ -Id是该表的主键列。 +在 SQL 中，id 是该表的主键列。 该表的每一行都表示雇员的名字、他们的部门和他们的经理的id。 如果managerId为空，则该员工没有经理。 没有员工会成为自己的管理者。 @@ -27,7 +27,7 @@ Id是该表的主键列。-
编写一个SQL查询，查询至少有5名直接下属的经理 。
+查询至少有5名直接下属的经理 。
以 任意顺序 返回结果表。
diff --git "a/AllProblems/577.\345\221\230\345\267\245\345\245\226\351\207\221.md" "b/AllProblems/577.\345\221\230\345\267\245\345\245\226\351\207\221.md" index 4d426225243..1aa6c06ab47 100644 --- "a/AllProblems/577.\345\221\230\345\267\245\345\245\226\351\207\221.md" +++ "b/AllProblems/577.\345\221\230\345\267\245\345\245\226\351\207\221.md" @@ -8,42 +8,75 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/employee-bonus/](https://leetcode.cn/problems/employee-bonus/) -选出所有 bonus < 1000 的员工的 name 及其 bonus。
- -- -
Employee表单+-------+--------+-----------+--------+ -| empId | name | supervisor| salary | -+-------+--------+-----------+--------+ -| 1 | John | 3 | 1000 | -| 2 | Dan | 3 | 2000 | -| 3 | Brad | null | 4000 | -| 4 | Thomas | 3 | 4000 | -+-------+--------+-----------+--------+ -empId 是这张表单的主关键字 +\ No newline at end of file diff --git "a/AllProblems/585.2016\345\271\264\347\232\204\346\212\225\350\265\204.md" "b/AllProblems/585.2016\345\271\264\347\232\204\346\212\225\350\265\204.md" index a00c66ff986..7c1a9c63e3b 100644 --- "a/AllProblems/585.2016\345\271\264\347\232\204\346\212\225\350\265\204.md" +++ "b/AllProblems/585.2016\345\271\264\347\232\204\346\212\225\350\265\204.md" @@ -8,56 +8,69 @@ tags: [题解, LeetCode, 中等, 数据库] 力扣题目链接：[https://leetcode.cn/problems/investments-in-2016/](https://leetcode.cn/problems/investments-in-2016/) -表：
+ +Employee++-------------+---------+ +| Column Name | Type | ++-------------+---------+ +| empId | int | +| name | varchar | +| supervisor | int | +| salary | int | ++-------------+---------+ +empId 是该表中具有唯一值的列。 +该表的每一行都表示员工的姓名和 id，以及他们的工资和经理的 id。-+
Bonus表单-
+-------+-------+ -| empId | bonus | -+-------+-------+ -| 2 | 500 | -| 4 | 2000 | -+-------+-------+ -empId 是这张表单的主关键字 ++ +表：
+ +Bonus++-------------+------+ +| Column Name | Type | ++-------------+------+ +| empId | int | +| bonus | int | ++-------------+------+ +empId 是该表具有唯一值的列。 +empId 是 Employee 表中 empId 的外键(reference 列)。 +该表的每一行都包含一个员工的 id 和他们各自的奖金。-输出示例：
++ +
编写解决方案，报告每个奖金 少于
+ +1000的员工的姓名和奖金数额。以 任意顺序 返回结果表。
-+-------+-------+ -| name | bonus | +\ No newline at end of file diff --git "a/AllProblems/584.\345\257\273\346\211\276\347\224\250\346\210\267\346\216\250\350\215\220\344\272\272.md" "b/AllProblems/584.\345\257\273\346\211\276\347\224\250\346\210\267\346\216\250\350\215\220\344\272\272.md" index 54be153072f..a11cfaa40f4 100644 --- "a/AllProblems/584.\345\257\273\346\211\276\347\224\250\346\210\267\346\216\250\350\215\220\344\272\272.md" +++ "b/AllProblems/584.\345\257\273\346\211\276\347\224\250\346\210\267\346\216\250\350\215\220\344\272\272.md" @@ -8,26 +8,43 @@ tags: [题解, LeetCode, 简单, 数据库] 力扣题目链接：[https://leetcode.cn/problems/find-customer-referee/](https://leetcode.cn/problems/find-customer-referee/) -结果格式如下所示。
+ ++ +
示例 1：
+ ++输入： +Employee table: ++-------+--------+------------+--------+ +| empId | name | supervisor | salary | ++-------+--------+------------+--------+ +| 3 | Brad | null | 4000 | +| 1 | John | 3 | 1000 | +| 2 | Dan | 3 | 2000 | +| 4 | Thomas | 3 | 4000 | ++-------+--------+------------+--------+ +Bonus table: ++-------+-------+ +| empId | bonus | +-------+-------+ -| John | null | -| Dan | 500 | -| Brad | null | +| 2 | 500 | +| 4 | 2000 | +-------+-------+ -+输出： ++------+-------+ +| name | bonus | ++------+-------+ +| Brad | null | +| John | null | +| Dan | 500 | ++------+-------+给定表
+customer，里面保存了所有客户信息和他们的推荐人。表:
Customer-+------+------+-----------+ -| id | name | referee_id| -+------+------+-----------+ -| 1 | Will | NULL | -| 2 | Jane | NULL | -| 3 | Alex | 2 | -| 4 | Bill | NULL | -| 5 | Zack | 1 | -| 6 | Mark | 2 | -+------+------+-----------+ -- -写一个查询语句，返回一个客户列表，列表中客户的推荐人的编号都 不是 2。
- -对于上面的示例数据，结果为：
++-------------+---------+ +| Column Name | Type | ++-------------+---------+ +| id | int | +| name | varchar | +| referee_id | int | ++-------------+---------+ +在 SQL 中，id 是该表的主键列。 +该表的每一行表示一个客户的 id、姓名以及推荐他们的客户的 id。找出那些 没有被
+ +id = 2的客户 推荐 的客户的姓名。以 任意顺序 返回结果表。
+ +结果格式如下所示。
+ ++ +
示例 1：
+输入： +Customer 表: ++----+------+------------+ +| id | name | referee_id | ++----+------+------------+ +| 1 | Will | null | +| 2 | Jane | null | +| 3 | Alex | 2 | +| 4 | Bill | null | +| 5 | Zack | 1 | +| 6 | Mark | 2 | ++----+------+------------+ +输出： +------+ | name | +------+ @@ -35,8 +52,7 @@ tags: [题解, LeetCode, 简单, 数据库] | Jane | | Bill | | Zack | -+------+ -++------+写一个查询语句，将 2016 年 (TIV_2016) 所有成功投资的金额加起来，保留 2 位小数。
- -对于一个投保人，他在 2016 年成功投资的条件是：
- --
- -- 他在 2015 年的投保额 (TIV_2015) 至少跟一个其他投保人在 2015 年的投保额相同。
-- 他所在的城市必须与其他投保人都不同（也就是说维度和经度不能跟其他任何一个投保人完全相同）。
-输入格式:
- -
-表 insurance 格式如下：| Column Name | Type | -|-------------|---------------| -| PID | INTEGER(11) | -| TIV_2015 | NUMERIC(15,2) | -| TIV_2016 | NUMERIC(15,2) | -| LAT | NUMERIC(5,2) | -| LON | NUMERIC(5,2) | -- -PID 字段是投保人的投保编号， TIV_2015 是该投保人在2015年的总投保金额， TIV_2016 是该投保人在2016年的投保金额， LAT 是投保人所在城市的维度， LON 是投保人所在城市的经度。
- -样例输入
- -| PID | TIV_2015 | TIV_2016 | LAT | LON | -|-----|----------|----------|-----|-----| ++ +
Insurance表：+\ No newline at end of file diff --git "a/AllProblems/586.\350\256\242\345\215\225\346\234\200\345\244\232\347\232\204\345\256\242\346\210\267.md" "b/AllProblems/586.\350\256\242\345\215\225\346\234\200\345\244\232\347\232\204\345\256\242\346\210\267.md" index 8fe79735870..1827863eeb6 100644 --- "a/AllProblems/586.\350\256\242\345\215\225\346\234\200\345\244\232\347\232\204\345\256\242\346\210\267.md" +++ "b/AllProblems/586.\350\256\242\345\215\225\346\234\200\345\244\232\347\232\204\345\256\242\346\210\267.md" @@ -17,13 +17,13 @@ tags: [题解, LeetCode, 简单, 数据库] | order_number | int | | customer_number | int | +-----------------+----------+ -Order_number是该表的主键。 +在 SQL 中，Order_number是该表的主键。 此表包含关于订单ID和客户ID的信息。++++-------------+-------+ +| Column Name | Type | ++-------------+-------+ +| pid | int | +| tiv_2015 | float | +| tiv_2016 | float | +| lat | float | +| lon | float | ++-------------+-------+ +pid 是这张表的主键(具有唯一值的列)。 +表中的每一行都包含一条保险信息，其中： +pid 是投保人的投保编号。 +tiv_2015 是该投保人在 2015 年的总投保金额，tiv_2016 是该投保人在 2016 年的总投保金额。 +lat 是投保人所在城市的纬度。题目数据确保 lat 不为空。 +lon 是投保人所在城市的经度。题目数据确保 lon 不为空。+ ++ +
编写解决方案报告 2016 年 (
+ +tiv_2016) 所有满足下述条件的投保人的投保金额之和：+
+ +- 他在 2015 年的投保额 (
+tiv_2015) 至少跟一个其他投保人在 2015 年的投保额相同。- 他所在的城市必须与其他投保人都不同（也就是说 (
+lat, lon) 不能跟其他任何一个投保人完全相同）。+ +
tiv_2016四舍五入的 两位小数 。查询结果格式如下例所示。
+ ++ +
示例 1：
+ ++输入： +Insurance 表： ++-----+----------+----------+-----+-----+ +| pid | tiv_2015 | tiv_2016 | lat | lon | ++-----+----------+----------+-----+-----+ | 1 | 10 | 5 | 10 | 10 | | 2 | 20 | 20 | 20 | 20 | | 3 | 10 | 30 | 20 | 20 | | 4 | 10 | 40 | 40 | 40 | -- -样例输出
- -| TIV_2016 | -|----------| ++-----+----------+----------+-----+-----+ +输出： ++----------+ +| tiv_2016 | ++----------+ | 45.00 | -- -解释
- -就如最后一个投保人，第一个投保人同时满足两个条件： -1. 他在 2015 年的投保金额 TIV_2015 为 '10' ，与第三个和第四个投保人在 2015 年的投保金额相同。 -2. 他所在城市的经纬度是独一无二的。 - -第二个投保人两个条件都不满足。他在 2015 年的投资 TIV_2015 与其他任何投保人都不相同。 -且他所在城市的经纬度与第三个投保人相同。基于同样的原因，第三个投保人投资失败。 - -所以返回的结果是第一个投保人和最后一个投保人的 TIV_2016 之和，结果是 45 。++----------+ +解释： +表中的第一条记录和最后一条记录都满足两个条件。 +tiv_2015 值为 10 与第三条和第四条记录相同，且其位置是唯一的。 + +第二条记录不符合任何一个条件。其 tiv_2015 与其他投保人不同，并且位置与第三条记录相同，这也导致了第三条记录不符合题目要求。 +因此，结果是第一条记录和最后一条记录的 tiv_2016 之和，即 45 。 +-
编写一个SQL查询，为下了 最多订单 的客户查找
+customer_number。查找下了 最多订单 的客户的
customer_number。测试用例生成后， 恰好有一个客户 比任何其他客户下了更多的订单。
diff --git "a/AllProblems/595.\345\244\247\347\232\204\345\233\275\345\256\266.md" "b/AllProblems/595.\345\244\247\347\232\204\345\233\275\345\256\266.md" index f7d24455449..6a18a72fcb8 100644 --- "a/AllProblems/595.\345\244\247\347\232\204\345\233\275\345\256\266.md" +++ "b/AllProblems/595.\345\244\247\347\232\204\345\233\275\345\256\266.md" @@ -23,7 +23,7 @@ tags: [题解, LeetCode, 简单, 数据库] | population | int | | gdp | bigint | +-------------+---------+ -name 是这张表的主键。 +name是该表的主键（具有唯一值的列）。 这张表的每一行提供：国家名称、所属大陆、面积、人口和 GDP 值。
25000000）编写一个 SQL 查询以报告 大国 的国家名称、人口和面积。
+编写解决方案找出 大国 的国家名称、人口和面积。
按 任意顺序 返回结果表。
-查询结果格式如下例所示。
+返回结果格式如下例所示。
diff --git "a/AllProblems/596.\350\266\205\350\277\2075\345\220\215\345\255\246\347\224\237\347\232\204\350\257\276.md" "b/AllProblems/596.\350\266\205\350\277\2075\345\220\215\345\255\246\347\224\237\347\232\204\350\257\276.md" index 2e7a49b1c8a..15b759fa686 100644 --- "a/AllProblems/596.\350\266\205\350\277\2075\345\220\215\345\255\246\347\224\237\347\232\204\350\257\276.md" +++ "b/AllProblems/596.\350\266\205\350\277\2075\345\220\215\345\255\246\347\224\237\347\232\204\350\257\276.md" @@ -17,13 +17,13 @@ tags: [题解, LeetCode, 简单, 数据库] | student | varchar | | class | varchar | +-------------+---------+ -(student, class)是该表的主键列。 +在 SQL 中，(student, class)是该表的主键列。 该表的每一行表示学生的名字和他们注册的班级。
-
编写一个SQL查询来报告 至少有5个学生 的所有班级。
+查询 至少有5个学生 的所有班级。
以 任意顺序 返回结果表。
diff --git "a/AllProblems/601.\344\275\223\350\202\262\351\246\206\347\232\204\344\272\272\346\265\201\351\207\217.md" "b/AllProblems/601.\344\275\223\350\202\262\351\246\206\347\232\204\344\272\272\346\265\201\351\207\217.md" index 69f6b7f10e2..4b5f62f1534 100644 --- "a/AllProblems/601.\344\275\223\350\202\262\351\246\206\347\232\204\344\272\272\346\265\201\351\207\217.md" +++ "b/AllProblems/601.\344\275\223\350\202\262\351\246\206\347\232\204\344\272\272\346\265\201\351\207\217.md" @@ -17,14 +17,14 @@ tags: [题解, LeetCode, 困难, 数据库] | visit_date | date | | people | int | +---------------+---------+ -visit_date 是表的主键 +visit_date 是该表中具有唯一值的列。 每日人流量信息被记录在这三列信息中：序号 (id)、日期 (visit_date)、 人流量 (people) 每天只有一行记录，日期随着 id 的增加而增加-
编写一个 SQL 查询以找出每行的人数大于或等于 100 且 id 连续的三行或更多行记录。
编写解决方案找出每行的人数大于或等于 100 且 id 连续的三行或更多行记录。
返回按 visit_date 升序排列 的结果表。
在 Facebook 或者 Twitter 这样的社交应用中，人们经常会发好友申请也会收到其他人的好友申请。
+RequestAccepted 表：
RequestAccepted 表：
+----------------+---------+ | Column Name | Type | @@ -22,13 +20,13 @@ tags: [题解, LeetCode, 中等, 数据库] | accepter_id | int | | accept_date | date | +----------------+---------+ -(requester_id, accepter_id) 是这张表的主键。 +(requester_id, accepter_id) 是这张表的主键(具有唯一值的列的组合)。 这张表包含发送好友请求的人的 ID ，接收好友请求的人的 ID ，以及好友请求通过的日期。
-
写一个查询语句，找出拥有最多的好友的人和他拥有的好友数目。
+编写解决方案，找出拥有最多的好友的人和他拥有的好友数目。
生成的测试用例保证拥有最多好友数目的只有 1 个人。
@@ -36,7 +34,7 @@ tags: [题解, LeetCode, 中等, 数据库]-
示例：
+示例 1：
输入： diff --git "a/AllProblems/607.\351\224\200\345\224\256\345\221\230.md" "b/AllProblems/607.\351\224\200\345\224\256\345\221\230.md" index 6d3c129b435..ef8bd12fd42 100644 --- "a/AllProblems/607.\351\224\200\345\224\256\345\221\230.md" +++ "b/AllProblems/607.\351\224\200\345\224\256\345\221\230.md" @@ -20,7 +20,7 @@ tags: [题解, LeetCode, 简单, 数据库] | commission_rate | int | | hire_date | date | +-----------------+---------+ -sales_id 是该表的主键列。 +sales_id 是该表的主键列(具有唯一值的列)。 该表的每一行都显示了销售人员的姓名和 ID ，以及他们的工资、佣金率和雇佣日期。@@ -36,7 +36,7 @@ sales_id 是该表的主键列。 | name | varchar | | city | varchar | +-------------+---------+ -com_id 是该表的主键列。 +com_id 是该表的主键列(具有唯一值的列)。 该表的每一行都表示公司的名称和 ID ，以及公司所在的城市。 @@ -54,23 +54,23 @@ com_id 是该表的主键列。 | sales_id | int | | amount | int | +-------------+------+ -order_id 是该表的主键列。 -com_id 是 Company 表中 com_id 的外键。 -sales_id 是来自销售员表 sales_id 的外键。 +order_id 是该表的主键列(具有唯一值的列)。 +com_id 是 Company 表中 com_id 的外键（reference 列）。 +sales_id 是来自销售员表 sales_id 的外键（reference 列）。 该表的每一行包含一个订单的信息。这包括公司的 ID 、销售人员的 ID 、订单日期和支付的金额。
-
编写一个SQL查询，报告没有任何与名为 “RED” 的公司相关的订单的所有销售人员的姓名。
+编写解决方案，找出没有任何与名为 “RED” 的公司相关的订单的所有销售人员的姓名。
以 任意顺序 返回结果表。
-查询结果格式如下所示。
+返回结果格式如下所示。
-
示例：
+示例 1：
输入： diff --git "a/AllProblems/608.\346\240\221\350\212\202\347\202\271.md" "b/AllProblems/608.\346\240\221\350\212\202\347\202\271.md" index 362131b90e8..ca492718757 100644 --- "a/AllProblems/608.\346\240\221\350\212\202\347\202\271.md" +++ "b/AllProblems/608.\346\240\221\350\212\202\347\202\271.md" @@ -8,68 +8,86 @@ tags: [题解, LeetCode, 中等, 数据库] 力扣题目链接：[https://leetcode.cn/problems/tree-node/](https://leetcode.cn/problems/tree-node/) -给定一个表
+tree，id 是树节点的编号， p_id 是它父节点的 id 。表：
+ +Tree++-------------+------+ +| Column Name | Type | ++-------------+------+ +| id | int | +| p_id | int | ++-------------+------+ +id 是该表中具有唯一值的列。 +该表的每行包含树中节点的 id 及其父节点的 id 信息。 +给定的结构总是一个有效的树。 +-+----+------+ -| id | p_id | -+----+------+ -| 1 | null | -| 2 | 1 | -| 3 | 1 | -| 4 | 2 | -| 5 | 2 | -+----+------++-
树中每个节点属于以下三种类型之一：
+树中的每个节点可以是以下三种类型之一：
+
编写一个解决方案来报告树中每个节点的类型。
-写一个查询语句，输出所有节点的编号和节点的类型，并将结果按照节点编号排序。上面样例的结果为：
+以 任意顺序 返回结果表。
+ +结果格式如下所示。
-
+----+------+ -| id | Type | +示例 1：
++
+输入： +Tree table: ++----+------+ +| id | p_id | +----+------+ -| 1 | Root | -| 2 | Inner| -| 3 | Leaf | -| 4 | Leaf | -| 5 | Leaf | +| 1 | null | +| 2 | 1 | +| 3 | 1 | +| 4 | 2 | +| 5 | 2 | +----+------+ +输出： ++----+-------+ +| id | type | ++----+-------+ +| 1 | Root | +| 2 | Inner | +| 3 | Leaf | +| 4 | Leaf | +| 5 | Leaf | ++----+-------+ +解释： +节点 1 是根节点，因为它的父节点为空，并且它有子节点 2 和 3。 +节点 2 是一个内部节点，因为它有父节点 1 和子节点 4 和 5。 +节点 3、4 和 5 是叶子节点，因为它们有父节点而没有子节点。-- -
解释
- -
- -
1 - / \ - 2 3 - / \ - 4 5 +示例 2：
++
+输入： +Tree table: ++----+------+ +| id | p_id | ++----+------+ +| 1 | null | ++----+------+ +输出： ++----+-------+ +| id | type | ++----+-------+ +| 1 | Root | ++----+-------+ +解释：如果树中只有一个节点，则只需要输出其根属性。--
注意
- -如果树中只有一个节点，你只需要输出它的根属性。
- \ No newline at end of file diff --git "a/AllProblems/610.\345\210\244\346\226\255\344\270\211\350\247\222\345\275\242.md" "b/AllProblems/610.\345\210\244\346\226\255\344\270\211\350\247\222\345\275\242.md" index 3303c127695..5912ffa025c 100644 --- "a/AllProblems/610.\345\210\244\346\226\255\344\270\211\350\247\222\345\275\242.md" +++ "b/AllProblems/610.\345\210\244\346\226\255\344\270\211\350\247\222\345\275\242.md" @@ -18,13 +18,13 @@ tags: [题解, LeetCode, 简单, 数据库] | y | int | | z | int | +-------------+------+ -(x, y, z)是该表的主键列。 +在 SQL 中，(x, y, z)是该表的主键列。 该表的每一行包含三个线段的长度。-
写一个SQL查询，每三个线段报告它们是否可以形成一个三角形。
+对每三个线段报告它们是否可以形成一个三角形。
以 任意顺序 返回结果表。
diff --git "a/AllProblems/619.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\234\200\345\244\247\346\225\260\345\255\227.md" "b/AllProblems/619.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\234\200\345\244\247\346\225\260\345\255\227.md" index 9c8acde7b16..df406ad19af 100644 --- "a/AllProblems/619.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\234\200\345\244\247\346\225\260\345\255\227.md" +++ "b/AllProblems/619.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\234\200\345\244\247\346\225\260\345\255\227.md" @@ -18,7 +18,7 @@ tags: [题解, LeetCode, 简单, 数据库] +-------------+------+ | num | int | +-------------+------+ -这张表没有主键。可能包含重复数字。 +该表可能包含重复项（换句话说，在SQL中，该表没有主键）。 这张表的每一行都含有一个整数。 @@ -26,7 +26,7 @@ tags: [题解, LeetCode, 简单, 数据库]单一数字 是在 MyNumbers 表中只出现一次的数字。
请你编写一个 SQL 查询来报告最大的 单一数字 。如果不存在 单一数字 ，查询需报告 null 。
找出最大的 单一数字 。如果不存在 单一数字 ，则返回 null 。
查询结果如下例所示。
某城市开了一家新的电影院，吸引了很多人过来看电影。该电影院特别注意用户体验，专门有个 LED显示板做电影推荐，上面公布着影评和相关电影描述。
+表：cinema
作为该电影院的信息部主管，您需要编写一个 SQL查询，找出所有影片描述为非 boring (不无聊) 的并且 id 为奇数 的影片，结果请按等级 rating 排列。
++----------------+----------+ +| Column Name | Type | ++----------------+----------+ +| id | int | +| movie | varchar | +| description | varchar | +| rating | float | ++----------------+----------+ +id 是该表的主键(具有唯一值的列)。 +每行包含有关电影名称、类型和评级的信息。 +评级为 [0,10] 范围内的小数点后 2 位浮点数。 ++ +
+ +
编写解决方案，找出所有影片描述为 非 boring (不无聊) 的并且 id 为奇数 的影片。
返回结果按 rating 降序排列。
结果格式如下示例。
-
例如，下表 cinema:
示例 1：
+输入： +---------+-----------+--------------+-----------+ | id | movie | description | rating | +---------+-----------+--------------+-----------+ @@ -25,21 +46,17 @@ tags: [题解, LeetCode, 简单, 数据库] | 3 | irish | boring | 6.2 | | 4 | Ice song | Fantacy | 8.6 | | 5 | House card| Interesting| 9.1 | -+---------+-----------+--------------+-----------+ -- -
对于上面的例子，则正确的输出是为：
- -++---------+-----------+--------------+-----------+ +输出： +---------+-----------+--------------+-----------+ | id | movie | description | rating | +---------+-----------+--------------+-----------+ | 5 | House card| Interesting| 9.1 | | 1 | War | great 3D | 8.9 | +---------+-----------+--------------+-----------+ +解释： +我们有三部电影，它们的 id 是奇数:1、3 和 5。id = 3 的电影是 boring 的，所以我们不把它包括在答案中。-
- \ No newline at end of file diff --git "a/AllProblems/626.\346\215\242\345\272\247\344\275\215.md" "b/AllProblems/626.\346\215\242\345\272\247\344\275\215.md" index 476b1573e4c..8c268b6fe48 100644 --- "a/AllProblems/626.\346\215\242\345\272\247\344\275\215.md" +++ "b/AllProblems/626.\346\215\242\345\272\247\344\275\215.md" @@ -15,16 +15,16 @@ tags: [题解, LeetCode, 中等, 数据库] | Column Name | Type | +-------------+---------+ | id | int | -| name | varchar | +| student | varchar | +-------------+---------+ -Id是该表的主键列。 -该表的每一行都表示学生的姓名和ID。 -Id是一个连续的增量。 +
id 是该表的主键（唯一值）列。
+该表的每一行都表示学生的姓名和 ID。
+id 是一个连续的增量。
-
编写SQL查询来交换每两个连续的学生的座位号。如果学生的数量是奇数，则最后一个学生的id不交换。
+编写解决方案来交换每两个连续的学生的座位号。如果学生的数量是奇数，则最后一个学生的id不交换。
按 id 升序 返回结果表。
-
请你编写一个 SQL 查询来交换所有的 'f' 和 'm' （即，将所有 'f' 变为 'm' ，反之亦然），仅使用 单个 update 语句 ，且不产生中间临时表。
请你编写一个解决方案来交换所有的 'f' 和 'm' （即，将所有 'f' 变为 'm' ，反之亦然），仅使用 单个 update 语句 ，且不产生中间临时表。
注意，你必须仅使用一条 update 语句，且 不能 使用 select 语句。
-查询结果如下例所示。
+结果如下例所示。
diff --git "a/AllProblems/630.\350\257\276\347\250\213\350\241\250 III.md" "b/AllProblems/630.\350\257\276\347\250\213\350\241\250 III.md" index 147f399c1f4..d1d02e85787 100644 --- "a/AllProblems/630.\350\257\276\347\250\213\350\241\250 III.md" +++ "b/AllProblems/630.\350\257\276\347\250\213\350\241\250 III.md" @@ -1,7 +1,7 @@ --- title: 630.课程表 III date: 2022-06-02 19-59-14 -tags: [题解, LeetCode, 困难, 贪心, 数组, 堆（优先队列）] +tags: [题解, LeetCode, 困难, 贪心, 数组, 排序, 堆（优先队列）] --- # 【LetMeFly】630.课程表 III diff --git "a/AllProblems/676.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" "b/AllProblems/676.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" index 120ab585d2f..f56e7dd5974 100644 --- "a/AllProblems/676.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" +++ "b/AllProblems/676.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" @@ -1,7 +1,7 @@ --- title: 676.实现一个魔法字典 date: 2022-06-02 19-59-37 -tags: [题解, LeetCode, 中等, 设计, 字典树, 哈希表, 字符串] +tags: [题解, LeetCode, 中等, 深度优先搜索, 设计, 字典树, 哈希表, 字符串] --- # 【LetMeFly】676.实现一个魔法字典 diff --git "a/AllProblems/721.\350\264\246\346\210\267\345\220\210\345\271\266.md" "b/AllProblems/721.\350\264\246\346\210\267\345\220\210\345\271\266.md" index dd537caf5e0..6015f656b0a 100644 --- "a/AllProblems/721.\350\264\246\346\210\267\345\220\210\345\271\266.md" +++ "b/AllProblems/721.\350\264\246\346\210\267\345\220\210\345\271\266.md" @@ -1,7 +1,7 @@ --- title: 721.账户合并 date: 2022-06-02 20-00-01 -tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 数组, 字符串] +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 数组, 哈希表, 字符串, 排序] --- # 【LetMeFly】721.账户合并 diff --git "a/AllProblems/722.\345\210\240\351\231\244\346\263\250\351\207\212.md" "b/AllProblems/722.\345\210\240\351\231\244\346\263\250\351\207\212.md" index 32a4fa5512a..57062997a50 100644 --- "a/AllProblems/722.\345\210\240\351\231\244\346\263\250\351\207\212.md" +++ "b/AllProblems/722.\345\210\240\351\231\244\346\263\250\351\207\212.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 中等, 数组, 字符串] 力扣题目链接：[https://leetcode.cn/problems/remove-comments/](https://leetcode.cn/problems/remove-comments/) -
给一个 C++ 程序，删除程序中的注释。这个程序source是一个数组，其中source[i]表示第 i 行源码。 这表示每行源码由 '\n' 分隔。
给一个 C++ 程序，删除程序中的注释。这个程序source是一个数组，其中source[i]表示第 i 行源码。 这表示每行源码由 '\n' 分隔。
在 C++ 中有两种注释风格，行内注释和块注释。
diff --git "a/AllProblems/735.\345\260\217\350\241\214\346\230\237\347\242\260\346\222\236.md" "b/AllProblems/735.\345\260\217\350\241\214\346\230\237\347\242\260\346\222\236.md" new file mode 100644 index 00000000000..f208b4549e3 --- /dev/null +++ "b/AllProblems/735.\345\260\217\350\241\214\346\230\237\347\242\260\346\222\236.md" @@ -0,0 +1,51 @@ +--- +title: 735.小行星碰撞 +date: 2023-10-10 14-24-22 +tags: [题解, LeetCode, 中等, 栈, 数组, 模拟] +--- + +# 【LetMeFly】735.小行星碰撞 + +力扣题目链接：[https://leetcode.cn/problems/asteroid-collision/](https://leetcode.cn/problems/asteroid-collision/) + +给定一个整数数组 asteroids，表示在同一行的小行星。
对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。
+ +找出碰撞后剩下的所有小行星。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。如果两颗小行星大小相同，则两颗小行星都会爆炸。两颗移动方向相同的小行星，永远不会发生碰撞。
+ ++ +
示例 1：
+ ++输入：asteroids = [5,10,-5] +输出：[5,10] +解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。+ +
示例 2：
+ ++输入：asteroids = [8,-8] +输出：[] +解释：8 和 -8 碰撞后，两者都发生爆炸。+ +
示例 3：
+ ++输入：asteroids = [10,2,-5] +输出：[10] +解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。+ +
+ +
提示：
+ +2 <= asteroids.length <= 104-1000 <= asteroids[i] <= 1000asteroids[i] != 0编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
给你一个满足下述两条属性的 m x n 整数矩阵：
+
给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。
示例 1：
@@ -31,15 +33,15 @@ tags: [题解, LeetCode, 中等, 数组, 二分查找, 矩阵]
输出：false
-+
提示：
m == matrix.lengthn == matrix[i].length1 <= m, n <= 100-104 <= matrix[i][j], target <= 1041 <= m, n <= 100-104 <= matrix[i][j], target <= 104输入：nums = [1,1,1,2,2,3] 输出：5, nums = [1,1,2,2,3] -解释：函数应返回新长度 length =5, 并且原数组的前五个元素被修改为1, 1, 2, 2,3 。 不需要考虑数组中超出新长度后面的元素。 +解释：函数应返回新长度 length =5, 并且原数组的前五个元素被修改为1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
示例 2：
@@ -48,7 +48,7 @@ for (int i = 0; i < len; i++) {输入：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 。 不需要考虑数组中超出新长度后面的元素。 +解释：函数应返回新长度 length =7, 并且原数组的前五个元素被修改为0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。
diff --git "a/AllProblems/813.\346\234\200\345\244\247\345\271\263\345\235\207\345\200\274\345\222\214\347\232\204\345\210\206\347\273\204.md" "b/AllProblems/813.\346\234\200\345\244\247\345\271\263\345\235\207\345\200\274\345\222\214\347\232\204\345\210\206\347\273\204.md" index e5db56e4ea3..56b7a3e024e 100644 --- "a/AllProblems/813.\346\234\200\345\244\247\345\271\263\345\235\207\345\200\274\345\222\214\347\232\204\345\210\206\347\273\204.md" +++ "b/AllProblems/813.\346\234\200\345\244\247\345\271\263\345\235\207\345\200\274\345\222\214\347\232\204\345\210\206\347\273\204.md" @@ -8,7 +8,7 @@ tags: [题解, LeetCode, 中等, 数组, 动态规划, 前缀和] 力扣题目链接：[https://leetcode.cn/problems/largest-sum-of-averages/](https://leetcode.cn/problems/largest-sum-of-averages/) -
给定数组 nums 和一个整数 k 。我们将给定的数组 nums 分成 最多 k 个相邻的非空子数组 。 分数 由每个子数组内的平均值的总和构成。
给定数组 nums 和一个整数 k 。我们将给定的数组 nums 分成 最多 k 个非空子数组，且数组内部是连续的 。 分数 由每个子数组内的平均值的总和构成。
注意我们必须使用 nums 数组中的每一个数进行分组，并且分数不一定需要是整数。
在桌子上有 N 张卡片，每张卡片的正面和背面都写着一个正数（正面与背面上的数有可能不一样）。
在桌子上有 n 张卡片，每张卡片的正面和背面都写着一个正数（正面与背面上的数有可能不一样）。
我们可以先翻转任意张卡片，然后选择其中一张卡片。
-如果选中的那张卡片背面的数字 X 与任意一张卡片的正面的数字都不同，那么这个数字是我们想要的数字。
如果选中的那张卡片背面的数字 x 与任意一张卡片的正面的数字都不同，那么这个数字是我们想要的数字。
哪个数是这些想要的数字中最小的数（找到这些数中的最小值）呢？如果没有一个数字符合要求的，输出 0。
+哪个数是这些想要的数字中最小的数（找到这些数中的最小值）呢？如果没有一个数字符合要求的，输出 0 。
其中, fronts[i] 和 backs[i] 分别代表第 i 张卡片的正面和背面的数字。
如果我们通过翻转卡片来交换正面与背面上的数，那么当初在正面的数就变成背面的数，背面的数就变成正面的数。
-示例：
++ +
示例 1：
输入：fronts = [1,2,4,4,7], backs = [1,3,4,1,3] @@ -28,15 +30,24 @@ tags: [题解, LeetCode, 中等, 数组, 哈希表] 解释：假设我们翻转第二张卡片，那么在正面的数变成了+[1,3,4,4,7]， 背面的数变成了[1,2,4,1,3]。接着我们选择第二张卡片，因为现在该卡片的背面的数是 2，2 与任意卡片上正面的数都不同，所以 2 就是我们想要的数字。
示例 2：
+ ++输入：fronts = [1], backs = [1] +输出：0 +解释： +无论如何翻转都无法得到想要的数字，所以返回 0 。 ++
提示：
-1 <= fronts.length == backs.length <= 10001 <= fronts[i] <= 20001 <= backs[i] <= 2000n == fronts.length == backs.length1 <= n <= 10001 <= fronts[i], backs[i] <= 2000-
示例 1：
+示例 1：
输入: s = "ABC"
@@ -28,7 +28,7 @@ tags: [题解, LeetCode, 困难, 哈希表, 字符串, 动态规划]
所以其长度总和为：1 + 1 + 1 + 2 + 2 + 3 = 10
-示例 2：
+示例 2：
输入: s = "ABA"
@@ -36,7 +36,7 @@ tags: [题解, LeetCode, 困难, 哈希表, 字符串, 动态规划]
解释: 除了 countUniqueChars("ABA") = 1 之外，其余与示例 1 相同。
-示例 3：
+示例 3：
输入：s = "LEETCODE" @@ -48,7 +48,7 @@ tags: [题解, LeetCode, 困难, 哈希表, 字符串, 动态规划]提示：
1 <= s.length <= 10^51 <= s.length <= 105s 只包含大写英文字符示例 1：
-
-输入：s = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"] +输入：s = "abcd", indices = [0,2], sources = ["a","cd"], targets = ["eee","ffff"] 输出："eeebffff" 解释： "a" 从 s 中的索引 0 开始，所以它被替换为 "eee"。 "cd" 从 s 中的索引 2 开始，所以它被替换为 "ffff"。-
示例 2：
示例 2：
-输入：s = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"] +输入：s = "abcd", indices = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"] 输出："eeecd" 解释： "ab" 从 s 中的索引 0 开始，所以它被替换为 "eee"。 @@ -62,7 +62,7 @@ tags: [题解, LeetCode, 中等, 数组, 字符串, 排序]
1 <= s.length <= 1000k == indices.length == sources.length == targets.length1 <= k <= 1000 <= indexes[i] < s.length0 <= indices[i] < s.length1 <= sources[i].length, targets[i].length <= 50s 仅由小写英文字母组成sources[i] 和 targets[i] 仅由小写英文字母组成Alice 手中有一把牌，她想要重新排列这些牌，分成若干组，使每一组的牌数都是 groupSize ，并且由 groupSize 张连续的牌组成。
给你一个整数数组 hand 其中 hand[i] 是写在第 i 张牌，和一个整数 groupSize 。如果她可能重新排列这些牌，返回 true ；否则，返回 false 。
给你一个整数数组 hand 其中 hand[i] 是写在第 i 张牌上的数值。如果她可能重新排列这些牌，返回 true ；否则，返回 false 。
diff --git "a/AllProblems/874.\346\250\241\346\213\237\350\241\214\350\265\260\346\234\272\345\231\250\344\272\272.md" "b/AllProblems/874.\346\250\241\346\213\237\350\241\214\350\265\260\346\234\272\345\231\250\344\272\272.md" index 073df54ee11..58c8e2c425f 100644 --- "a/AllProblems/874.\346\250\241\346\213\237\350\241\214\350\265\260\346\234\272\345\231\250\344\272\272.md" +++ "b/AllProblems/874.\346\250\241\346\213\237\350\241\214\350\265\260\346\234\272\345\231\250\344\272\272.md" @@ -8,42 +8,43 @@ tags: [题解, LeetCode, 中等, 数组, 模拟] 力扣题目链接：[https://leetcode.cn/problems/walking-robot-simulation/](https://leetcode.cn/problems/walking-robot-simulation/) -
机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ：
机器人在一个无限大小的 XY 网格平面上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令 commands ：
-2 ：向左转 90 度-2 ：向左转 90 度-1 ：向右转 90 度1 <= x <= 9 ：向前移动 x 个单位长度1 <= x <= 9 ：向前移动 x 个单位长度在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点 obstacles[i] = (xi, yi) 。
在网格上有一些格子被视为障碍物 obstacles 。第 i 个障碍物位于网格点 obstacles[i] = (xi, yi) 。
机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，但仍然可以继续尝试进行该路线的其余部分。
+机器人无法走到障碍物上，它将会停留在障碍物的前一个网格方块上，并继续执行下一个命令。
-返回从原点到机器人所有经过的路径点（坐标为整数）的最大欧式距离的平方。（即，如果距离为 5 ，则返回 25 ）
返回机器人距离原点的 最大欧式距离 的 平方 。（即，如果距离为 5 ，则返回 25 ）
注意：
+Y 方向。+X 方向。-Y 方向。-X 方向。+
示例 1：
@@ -57,7 +58,7 @@ tags: [题解, LeetCode, 中等, 数组, 模拟] 3. 向东移动 3 个单位，到达 (3, 4) 距离原点最远的是 (3, 4) ，距离为 32 + 42 = 25 -示例 2：
+示例 2：
输入：commands = [4,-1,4,-2,4], obstacles = [[2,4]] @@ -70,15 +71,25 @@ tags: [题解, LeetCode, 中等, 数组, 模拟] 5. 向北走 4 个单位，到达 (1, 8) 距离原点最远的是 (1, 8) ，距离为 12 + 82 = 65-
+
示例 3：
+ ++输入：commands = [6,-1,-1,6], obstacles = [] +输出：36 +解释：机器人开始位于 (0, 0): +1. 向北移动 6 个单位，到达 (0, 6). +2. 右转 +3. 右转 +4. 向南移动 6 个单位，到达 (0, 0). +机器人距离原点最远的点是 (0, 6)，其距离的平方是 62 = 36 个单位。
提示：
1 <= commands.length <= 104commands[i] is one of the values in the list [-2,-1,1,2,3,4,5,6,7,8,9].0 <= obstacles.length <= 104-3 * 104 <= xi, yi <= 3 * 1041 <= commands.length <= 104commands[i] 的值可以取 -2、-1 或者是范围 [1, 9] 内的一个整数。0 <= obstacles.length <= 104-3 * 104 <= xi, yi <= 3 * 104231示例 1：
-输出：graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1] -输入：0 +输入：graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1] +输出：0
示例 2：
diff --git "a/AllProblems/944.\345\210\240\345\210\227\351\200\240\345\272\217.md" "b/AllProblems/944.\345\210\240\345\210\227\351\200\240\345\272\217.md" index 9d1720cad81..8b669ec511d 100644 --- "a/AllProblems/944.\345\210\240\345\210\227\351\200\240\345\272\217.md" +++ "b/AllProblems/944.\345\210\240\345\210\227\351\200\240\345\272\217.md" @@ -17,11 +17,11 @@ abc bce cae -你需要找出并删除 不是按字典序升序排列的 列。在上面的例子（下标从 0 开始）中，列 0（'a', 'b', 'c'）和列 2（'c', 'e', 'e'）都是按升序排列的，而列 1（'b', 'c', 'a'）不是，所以要删除列 1 。
你需要找出并删除 不是按字典序非严格递增排列的 列。在上面的例子（下标从 0 开始）中，列 0（'a', 'b', 'c'）和列 2（'c', 'e', 'e'）都是按字典序非严格递增排列的，而列 1（'b', 'c', 'a'）不是，所以要删除列 1 。
返回你需要删除的列数。
-+
示例 1：
@@ -58,14 +58,14 @@ cae 所有 3 列都是非升序排列的，所以都要删除。 -+
提示：
n == strs.length1 <= n <= 1001 <= strs[i].length <= 10001 <= n <= 1001 <= strs[i].length <= 1000strs[i] 由小写英文字母组成给定一个二叉树的 root ，确定它是否是一个 完全二叉树 。
给你一棵二叉树的根节点 root ，请你判断这棵树是否是一棵 完全二叉树 。
在一个 完全二叉树 中，除了最后一个关卡外，所有关卡都是完全被填满的，并且最后一个关卡中的所有节点都是尽可能靠左的。它可以包含 1 到 2h 节点之间的最后一级 h 。
在一棵 完全二叉树 中，除了最后一层外，所有层都被完全填满，并且最后一层中的所有节点都尽可能靠左。最后一层（第 h 层）中可以包含 1 到 2h 个节点。
@@ -21,7 +21,7 @@ tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 二叉树]
输入：root = [1,2,3,4,5,6]
输出：true
-解释：最后一层前的每一层都是满的（即，结点值为 {1} 和 {2,3} 的两层），且最后一层中的所有结点（{4,5,6}）都尽可能地向左。
+解释：最后一层前的每一层都是满的（即，节点值为 {1} 和 {2,3} 的两层），且最后一层中的所有节点（{4,5,6}）尽可能靠左。
示例 2：
@@ -31,7 +31,7 @@ tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 二叉树]输入：root = [1,2,3,4,5,null,7] 输出：false -解释：值为 7 的结点没有尽可能靠向左侧。 +解释：值为 7 的节点不满足条件「节点尽可能靠左」。
@@ -39,7 +39,7 @@ tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 二叉树]
提示：
[1, 100] 内。[1, 100] 内1 <= Node.val <= 1000示例 2：
diff --git "a/AllProblems/973.\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204 K \344\270\252\347\202\271.md" "b/AllProblems/973.\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204 K \344\270\252\347\202\271.md" index 7554c7b3877..670ad304e0e 100644 --- "a/AllProblems/973.\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204 K \344\270\252\347\202\271.md" +++ "b/AllProblems/973.\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204 K \344\270\252\347\202\271.md" @@ -16,7 +16,7 @@ tags: [题解, LeetCode, 中等, 几何, 数组, 数学, 分治, 快速选择,-
示例 1：
+示例 1：
示例 2：
+示例 2：
输入：points = [[3,3],[5,-1],[-2,4]], k = 2 diff --git "a/AllProblems/979.\345\234\250\344\272\214\345\217\211\346\240\221\344\270\255\345\210\206\351\205\215\347\241\254\345\270\201.md" "b/AllProblems/979.\345\234\250\344\272\214\345\217\211\346\240\221\344\270\255\345\210\206\351\205\215\347\241\254\345\270\201.md" index 8d85edea5ae..33e93472645 100644 --- "a/AllProblems/979.\345\234\250\344\272\214\345\217\211\346\240\221\344\270\255\345\210\206\351\205\215\347\241\254\345\270\201.md" +++ "b/AllProblems/979.\345\234\250\344\272\214\345\217\211\346\240\221\344\270\255\345\210\206\351\205\215\347\241\254\345\270\201.md" @@ -8,56 +8,40 @@ tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉树] 力扣题目链接：[https://leetcode.cn/problems/distribute-coins-in-binary-tree/](https://leetcode.cn/problems/distribute-coins-in-binary-tree/) -给定一个有
+N个结点的二叉树的根结点root，树中的每个结点上都对应有node.val枚硬币，并且总共有N枚硬币。给你一个有
-n个结点的二叉树的根结点root，其中树中每个结点node都对应有node.val枚硬币。整棵树上一共有n枚硬币。在一次移动中，我们可以选择两个相邻的结点，然后将一枚硬币从其中一个结点移动到另一个结点。(移动可以是从父结点到子结点，或者从子结点移动到父结点。)。
+在一次移动中，我们可以选择两个相邻的结点，然后将一枚硬币从其中一个结点移动到另一个结点。移动可以是从父结点到子结点，或者从子结点移动到父结点。
-返回使每个结点上只有一枚硬币所需的移动次数。
+返回使每个结点上 只有 一枚硬币所需的 最少 移动次数。
-
示例 1：
- -- -
输入：[3,0,0] +示例 1：
++
+输入：root = [3,0,0] 输出：2 -解释：从树的根结点开始，我们将一枚硬币移到它的左子结点上，一枚硬币移到它的右子结点上。 +解释：一枚硬币从根结点移动到左子结点，一枚硬币从根结点移动到右子结点。-示例 2：
- -- -
输入：[0,3,0] +示例 2：
++
+输入：root = [0,3,0] 输出：3 -解释：从根结点的左子结点开始，我们将两枚硬币移到根结点上 [移动两次]。然后，我们把一枚硬币从根结点移到右子结点上。 -- -示例 3：
- -- -
输入：[1,0,2] -输出：2 -- -示例 4：
- -- -
输入：[1,0,0,null,3] -输出：4 +解释：将两枚硬币从根结点的左子结点移动到根结点（两次移动）。然后，将一枚硬币从根结点移动到右子结点。
提示：
--
+- -
1<= N <= 100- -
0 <= node.val <= N
n1 <= n <= 1000 <= Node.val <= nNode.val 的值之和是 n给定一个正整数数组 nums和一个整数 k ，返回 num 中 「好子数组」 的数目。
给定一个正整数数组 nums和一个整数 k，返回 nums 中 「好子数组」 的数目。
如果 nums 的某个子数组中不同整数的个数恰好为 k，则称 nums 的这个连续、不一定不同的子数组为 「好子数组 」。
小 A 和小 B 负责审核面试者，他们均有所有面试者的简历，并且将各自根据面试者能力值从大到小的顺序浏览。由于简历事先被打乱过，能力值相同的简历的出现顺序是从它们的全排列中等可能地取一个。现在给定 n 名面试者的能力值 scores，设 X 代表小 A 和小 B 的浏览顺序中出现在同一位置的简历数，求 X 的期望。
提示：离散的非负随机变量的期望计算公式为 。在本题中，由于
X 的取值为 0 到 n 之间，期望计算公式可以是 。
提示：离散的非负随机变量的期望计算公式为 
。在本题中，由于 X 的取值为 0 到 n 之间，期望计算公式可以是 
。
示例 1：
diff --git "a/AllProblems/LCP 53.\345\256\210\346\212\244\345\244\252\347\251\272\345\237\216.md" "b/AllProblems/LCP 53.\345\256\210\346\212\244\345\244\252\347\251\272\345\237\216.md" index 7d29a6d6e45..f1e464250b1 100644 --- "a/AllProblems/LCP 53.\345\256\210\346\212\244\345\244\252\347\251\272\345\237\216.md" +++ "b/AllProblems/LCP 53.\345\256\210\346\212\244\345\244\252\347\251\272\345\237\216.md" @@ -8,48 +8,56 @@ tags: [题解, LeetCode, 困难, 位运算, 数组, 动态规划, 状态压缩] 力扣题目链接：[https://leetcode.cn/problems/EJvmW4/](https://leetcode.cn/problems/EJvmW4/) -各位勇者请注意，力扣太空城发布陨石雨红色预警。 - -太空城中的一些舱室将要受到陨石雨的冲击，这些舱室按照编号 `0 ~ N` 的顺序依次排列。为了阻挡陨石损毁舱室，太空城可以使用能量展开防护屏障，具体消耗如下： - -- 选择一个舱室开启屏障，能量消耗为 `2` -- 选择相邻两个舱室开启联合屏障，能量消耗为 `3` -- 对于已开启的**一个**屏障，**多维持一时刻**，能量消耗为 `1` - -已知陨石雨的影响范围和到达时刻，`time[i]` 和 `position[i]` 分别表示该陨石的到达时刻和冲击位置。请返回太空舱能够守护所有舱室所需要的最少能量。 - -**注意：** -- 同一时间，一个舱室不能被多个屏障覆盖 -- 陨石雨仅在到达时刻对冲击位置处的舱室有影响 - - -**示例 1：** ->输入：`time = [1,2,1], position = [6,3,3]` -> ->输出：`5` -> ->解释： -> 时刻 1，分别开启编号 3、6 舱室的屏障，能量消耗 2*2 = 4 -> 时刻 2，维持编号 3 舱室的屏障，能量消耗 1 -> 因此，最少需要能量 5 - -**示例 2：** ->输入：`time = [1,1,1,2,2,3,5], position = [1,2,3,1,2,1,3]` -> ->输出：`9` -> ->解释： -> 时刻 1，开启编号 1、2 舱室的联合屏障，能量消耗 3 -> 时刻 1，开启编号 3 舱室的屏障，能量消耗 2 -> 时刻 2，维持编号 1、2 舱室的联合屏障，能量消耗 1 -> 时刻 3，维持编号 1、2 舱室的联合屏障，能量消耗 1 -> 时刻 5，重新开启编号 3 舱室的联合屏障，能量消耗 2 -> 因此，最少需要能量 9 - -**提示：** -+ `1 <= time.length == position.length <= 500` -+ `1 <= time[i] <= 5` -+ `0 <= position[i] <= 100` +各位勇者请注意，力扣太空城发布陨石雨红色预警。
+ +太空城中的一些舱室将要受到陨石雨的冲击，这些舱室按照编号 0 ~ N 的顺序依次排列。为了阻挡陨石损毁舱室，太空城可以使用能量展开防护屏障，具体消耗如下：
231已知陨石雨的影响范围和到达时刻，time[i] 和 position[i] 分别表示该陨石的到达时刻和冲击位置。请返回太空舱能够守护所有舱室所需要的最少能量。
注意：
+ +示例 1：
+ ++输入：time = [1,2,1], position = [6,3,3] + +输出：5 + +解释：时刻 1，分别开启编号 3、6 舱室的屏障，能量消耗 2*2 = 4。时刻 2，维持编号 3 舱室的屏障，能量消耗 1。因此，最少需要能量 5。 ++ +
+ +
示例 2：
+ ++输入：time = [1,1,1,2,2,3,5], position = [1,2,3,1,2,1,3] + +输出：9 + +解释：时刻 1，开启编号 1、2 舱室的联合屏障，能量消耗 3。时刻 1，开启编号 3 舱室的屏障，能量消耗 2 。时刻 2，维持编号 1、2 舱室的联合屏障，能量消耗 1。时刻 3，维持编号 1、2 舱室的联合屏障，能量消耗 1。时刻 5，重新开启编号 3 舱室的屏障，能量消耗 2。因此，最少需要能量 9。 ++ +
+ +
提示：
+ +1 <= time.length == position.length <= 5001 <= time[i] <= 50 <= position[i] <= 100「力扣嘉年华」的中心广场放置了一个巨型的二叉树形状的装饰树。每个节点上均有一盏灯和三个开关。节点值为 0 表示灯处于「关闭」状态，节点值为 1 表示灯处于「开启」状态。每个节点上的三个开关各自功能如下：
1：切换当前节点的灯的状态；2：切换 以当前节点为根 的子树中，所有节点上的灯的状态；3：切换 当前节点及其左右子节点（若存在的话） 上的灯的状态；给定该装饰的初始状态 root，请返回最少需要操作多少次开关，可以关闭所有节点的灯。
示例 1：
+ ++输入：root = [1,1,0,null,null,null,1] +输出：2 +解释：以下是最佳的方案之一，如图所示 ++ ++
示例 2：
+ ++输入：root = [1,1,1,1,null,null,1] +输出：1 +解释：以下是最佳的方案，如图所示 ++ ++
示例 3：
+ ++输入：root = [0,null,0] +输出：0 +解释：无需操作开关，当前所有节点上的灯均已关闭 ++ +
提示：
+ +1 <= 节点个数 <= 10^50 <= Node.val <= 1给定两个整数 a 和 b ，求它们的除法的商 a/b ，要求不得使用乘号 '*'、除号 '/' 以及求余符号 '%' 。
+ +
注意：
+ +truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2[−231, 231−1]。本题中，如果除法结果溢出，则返回 231 − 1+ +
示例 1：
+ +
+输入：a = 15, b = 2
+输出：7
+解释：15/2 = truncate(7.5) = 7
+
+
+示例 2：
+ ++输入：a = 7, b = -3 +输出：-2 +解释：7/-3 = truncate(-2.33333..) = -2+ +
示例 3：
+ +
+输入：a = 0, b = 1
+输出：0
+
+示例 4：
+ +
+输入：a = 1, b = 1
+输出：1
+
++ +
提示:
+ +-231 <= a, b <= 231 - 1b != 0+ +
注意：本题与主站 29 题相同：https://leetcode-cn.com/problems/divide-two-integers/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 002.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.md" "b/AllProblems/LCR 002.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.md" new file mode 100644 index 00000000000..95fab931f7b --- /dev/null +++ "b/AllProblems/LCR 002.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.md" @@ -0,0 +1,44 @@ +--- +title: LCR 002.二进制求和 +date: 2023-10-10 14-42-32 +tags: [题解, LeetCode, 简单, 位运算, 数学, 字符串, 模拟] +--- + +# 【LetMeFly】LCR 002.二进制求和 + +力扣题目链接：[https://leetcode.cn/problems/JFETK5/](https://leetcode.cn/problems/JFETK5/) + +
给定两个 01 字符串 a 和 b ，请计算它们的和，并以二进制字符串的形式输出。
输入为 非空 字符串且只包含数字 1 和 0。
+ +
示例 1:
+ ++输入: a = "11", b = "10" +输出: "101"+ +
示例 2:
+ ++输入: a = "1010", b = "1011" +输出: "10101"+ +
+ +
提示：
+ +'0' 或 '1' 组成。1 <= a.length, b.length <= 10^4"0" ，就都不含前导零。+ +
注意：本题与主站 67 题相同：https://leetcode-cn.com/problems/add-binary/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 003.\346\257\224\347\211\271\344\275\215\350\256\241\346\225\260.md" "b/AllProblems/LCR 003.\346\257\224\347\211\271\344\275\215\350\256\241\346\225\260.md" new file mode 100644 index 00000000000..d74a709b638 --- /dev/null +++ "b/AllProblems/LCR 003.\346\257\224\347\211\271\344\275\215\350\256\241\346\225\260.md" @@ -0,0 +1,63 @@ +--- +title: LCR 003.比特位计数 +date: 2023-10-10 14-42-32 +tags: [题解, LeetCode, 简单, 位运算, 动态规划] +--- + +# 【LetMeFly】LCR 003.比特位计数 + +力扣题目链接：[https://leetcode.cn/problems/w3tCBm/](https://leetcode.cn/problems/w3tCBm/) + +给定一个非负整数 n ，请计算 0 到 n 之间的每个数字的二进制表示中 1 的个数，并输出一个数组。
+ +
示例 1:
+ ++输入: n = 2 +输出: [0,1,1] +解释: +0 --> 0 +1 --> 1 +2 --> 10 ++ +
示例 2:
+ +
+输入: n = 5
+输出: [0,1,1,2,1,2]
+解释:
+0 --> 0
+1 --> 1
+2 --> 10
+3 --> 11
+4 --> 100
+5 --> 101
+
+
++ +
说明 :
+ +0 <= n <= 105+ +
进阶:
+ +O(n*sizeof(integer)) 的解答非常容易。但你可以在线性时间 O(n) 内用一趟扫描做到吗？O(n) 。__builtin_popcount ）来执行此操作。+ +
注意：本题与主站 338 题相同：https://leetcode-cn.com/problems/counting-bits/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 004.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II.md" "b/AllProblems/LCR 004.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II.md" new file mode 100644 index 00000000000..ea7d592d48b --- /dev/null +++ "b/AllProblems/LCR 004.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227 II.md" @@ -0,0 +1,48 @@ +--- +title: LCR 004.只出现一次的数字 II +date: 2023-10-10 14-42-33 +tags: [题解, LeetCode, 中等, 位运算, 数组] +--- + +# 【LetMeFly】LCR 004.只出现一次的数字 II + +力扣题目链接：[https://leetcode.cn/problems/WGki4K/](https://leetcode.cn/problems/WGki4K/) + +给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。
+ +
示例 1：
+ ++输入：nums = [2,2,3,2] +输出：3 ++ +
示例 2：
+ ++输入：nums = [0,1,0,1,0,1,100] +输出：100 ++ +
+ +
提示：
+ +1 <= nums.length <= 3 * 104-231 <= nums[i] <= 231 - 1nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次+ +
进阶：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
+ ++ +
注意：本题与主站 137 题相同：https://leetcode-cn.com/problems/single-number-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 005.\346\234\200\345\244\247\345\215\225\350\257\215\351\225\277\345\272\246\344\271\230\347\247\257.md" "b/AllProblems/LCR 005.\346\234\200\345\244\247\345\215\225\350\257\215\351\225\277\345\272\246\344\271\230\347\247\257.md" new file mode 100644 index 00000000000..48adf2a20e5 --- /dev/null +++ "b/AllProblems/LCR 005.\346\234\200\345\244\247\345\215\225\350\257\215\351\225\277\345\272\246\344\271\230\347\247\257.md" @@ -0,0 +1,52 @@ +--- +title: LCR 005.最大单词长度乘积 +date: 2023-10-10 14-42-33 +tags: [题解, LeetCode, 中等, 位运算, 数组, 字符串] +--- + +# 【LetMeFly】LCR 005.最大单词长度乘积 + +力扣题目链接：[https://leetcode.cn/problems/aseY1I/](https://leetcode.cn/problems/aseY1I/) + +给定一个字符串数组 words，请计算当两个字符串 words[i] 和 words[j] 不包含相同字符时，它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串，返回 0。
+ +
示例 1:
+ ++输入: words =+ +["abcw","baz","foo","bar","fxyz","abcdef"]+输出:16 +解释: 这两个单词为"abcw", "fxyz"。它们不包含相同字符，且长度的乘积最大。
示例 2:
+ ++输入: words =+ +["a","ab","abc","d","cd","bcd","abcd"]+输出:4 +解释:这两个单词为"ab", "cd"。
示例 3:
+ ++输入: words =+ +["a","aa","aaa","aaaa"]+输出:0 +解释: 不存在这样的两个单词。+
+ +
提示：
+ +2 <= words.length <= 10001 <= words[i].length <= 1000words[i] 仅包含小写字母+ +
注意：本题与主站 318 题相同：https://leetcode-cn.com/problems/maximum-product-of-word-lengths/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 006.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md" "b/AllProblems/LCR 006.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md" new file mode 100644 index 00000000000..6fb9fd6e476 --- /dev/null +++ "b/AllProblems/LCR 006.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md" @@ -0,0 +1,58 @@ +--- +title: LCR 006.两数之和 II - 输入有序数组 +date: 2023-10-10 14-42-34 +tags: [题解, LeetCode, 简单, 数组, 双指针, 二分查找] +--- + +# 【LetMeFly】LCR 006.两数之和 II - 输入有序数组 + +力扣题目链接：[https://leetcode.cn/problems/kLl5u1/](https://leetcode.cn/problems/kLl5u1/) + +给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 0 开始计数 ，所以答案数组应当满足 0 <= answer[0] < answer[1] < numbers.length 。
假设数组中存在且只存在一对符合条件的数字，同时一个数字不能使用两次。
+ ++ +
示例 1：
+ ++输入：numbers = [1,2,4,6,10], target = 8 +输出：[1,3] +解释：2 与 6 之和等于目标数 8 。因此 index1 = 1, index2 = 3 。 ++ +
示例 2：
+ ++输入：numbers = [2,3,4], target = 6 +输出：[0,2] ++ +
示例 3：
+ ++输入：numbers = [-1,0], target = -1 +输出：[0,1] ++ +
+ +
提示：
+ +2 <= numbers.length <= 3 * 104-1000 <= numbers[i] <= 1000numbers 按 非递减顺序 排列-1000 <= target <= 1000+ +
注意：本题与主站 167 题相似（下标起点不同）：https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 007.\344\270\211\346\225\260\344\271\213\345\222\214.md" "b/AllProblems/LCR 007.\344\270\211\346\225\260\344\271\213\345\222\214.md" new file mode 100644 index 00000000000..96a646c2faf --- /dev/null +++ "b/AllProblems/LCR 007.\344\270\211\346\225\260\344\271\213\345\222\214.md" @@ -0,0 +1,50 @@ +--- +title: LCR 007.三数之和 +date: 2023-10-10 14-42-34 +tags: [题解, LeetCode, 中等, 数组, 双指针, 排序] +--- + +# 【LetMeFly】LCR 007.三数之和 + +力扣题目链接：[https://leetcode.cn/problems/1fGaJU/](https://leetcode.cn/problems/1fGaJU/) + +给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a ，b ，c ，使得 a + b + c = 0 ？请找出所有和为 0 且 不重复 的三元组。
+ +
示例 1：
+ ++输入：nums = [-1,0,1,2,-1,-4] +输出：[[-1,-1,2],[-1,0,1]] ++ +
示例 2：
+ ++输入：nums = [] +输出：[] ++ +
示例 3：
+ ++输入：nums = [0] +输出：[] ++ +
+ +
提示：
+ +0 <= nums.length <= 3000-105 <= nums[i] <= 105+ +
注意：本题与主站 15 题相同：https://leetcode-cn.com/problems/3sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 008.\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/AllProblems/LCR 008.\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 00000000000..d0765443e92 --- /dev/null +++ "b/AllProblems/LCR 008.\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,62 @@ +--- +title: LCR 008.长度最小的子数组 +date: 2023-10-10 14-42-35 +tags: [题解, LeetCode, 中等, 数组, 二分查找, 前缀和, 滑动窗口] +--- + +# 【LetMeFly】LCR 008.长度最小的子数组 + +力扣题目链接：[https://leetcode.cn/problems/2VG8Kg/](https://leetcode.cn/problems/2VG8Kg/) + +给定一个含有 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 <= 1091 <= nums.length <= 1051 <= nums[i] <= 105+ +
进阶：
+ +O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。+ +
注意：本题与主站 209 题相同：https://leetcode-cn.com/problems/minimum-size-subarray-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 009.\344\271\230\347\247\257\345\260\217\344\272\216 K \347\232\204\345\255\220\346\225\260\347\273\204.md" "b/AllProblems/LCR 009.\344\271\230\347\247\257\345\260\217\344\272\216 K \347\232\204\345\255\220\346\225\260\347\273\204.md" new file mode 100644 index 00000000000..da6a90076a9 --- /dev/null +++ "b/AllProblems/LCR 009.\344\271\230\347\247\257\345\260\217\344\272\216 K \347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -0,0 +1,45 @@ +--- +title: LCR 009.乘积小于 K 的子数组 +date: 2023-10-10 14-42-35 +tags: [题解, LeetCode, 中等, 数组, 滑动窗口] +--- + +# 【LetMeFly】LCR 009.乘积小于 K 的子数组 + +力扣题目链接：[https://leetcode.cn/problems/ZVAVXX/](https://leetcode.cn/problems/ZVAVXX/) + +给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。
+ +
示例 1:
+ ++输入: nums = [10,5,2,6], k = 100 +输出: 8 +解释: 8 个乘积小于 100 的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。 +需要注意的是 [10,5,2] 并不是乘积小于100的子数组。 ++ +
示例 2:
+ ++输入: nums = [1,2,3], k = 0 +输出: 0+ +
+ +
提示:
+ +1 <= nums.length <= 3 * 1041 <= nums[i] <= 10000 <= k <= 106+ +
注意：本题与主站 713 题相同：https://leetcode-cn.com/problems/subarray-product-less-than-k/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 010.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" "b/AllProblems/LCR 010.\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 00000000000..f38da54a35a --- /dev/null +++ "b/AllProblems/LCR 010.\345\222\214\344\270\272 K \347\232\204\345\255\220\346\225\260\347\273\204.md" @@ -0,0 +1,47 @@ +--- +title: LCR 010.和为 K 的子数组 +date: 2023-10-10 14-42-36 +tags: [题解, LeetCode, 中等, 数组, 哈希表, 前缀和] +--- + +# 【LetMeFly】LCR 010.和为 K 的子数组 + +力扣题目链接：[https://leetcode.cn/problems/QTMn0o/](https://leetcode.cn/problems/QTMn0o/) + +给定一个整数数组和一个整数 k ，请找到该数组中和为 k 的连续子数组的个数。
+ +
示例 1：
+ ++输入:nums = [1,1,1], k = 2 +输出: 2 +解释: 此题 [1,1] 与 [1,1] 为两种不同的情况 ++ +
示例 2：
+ ++输入:nums = [1,2,3], k = 3 +输出: 2 ++ +
+ +
提示:
+ +1 <= nums.length <= 2 * 104-1000 <= nums[i] <= 1000-107 <= k <= 107
+ +
注意：本题与主站 560 题相同： https://leetcode-cn.com/problems/subarray-sum-equals-k/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 011.\350\277\236\347\273\255\346\225\260\347\273\204.md" "b/AllProblems/LCR 011.\350\277\236\347\273\255\346\225\260\347\273\204.md" new file mode 100644 index 00000000000..023e629f573 --- /dev/null +++ "b/AllProblems/LCR 011.\350\277\236\347\273\255\346\225\260\347\273\204.md" @@ -0,0 +1,43 @@ +--- +title: LCR 011.连续数组 +date: 2023-10-10 14-42-36 +tags: [题解, LeetCode, 中等, 数组, 哈希表, 前缀和] +--- + +# 【LetMeFly】LCR 011.连续数组 + +力扣题目链接：[https://leetcode.cn/problems/A1NYOS/](https://leetcode.cn/problems/A1NYOS/) + +给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。
+ +
示例 1：
+ ++输入: nums = [0,1] +输出: 2 +说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。+ +
示例 2：
+ ++输入: nums = [0,1,0] +输出: 2 +说明: [0, 1] (或 [1, 0]) 是具有相同数量 0 和 1 的最长连续子数组。+ +
+ +
提示：
+ +1 <= nums.length <= 105nums[i] 不是 0 就是 1+ +
注意：本题与主站 525 题相同： https://leetcode-cn.com/problems/contiguous-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 012.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.md" "b/AllProblems/LCR 012.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.md" new file mode 100644 index 00000000000..172f2c23743 --- /dev/null +++ "b/AllProblems/LCR 012.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\344\270\213\346\240\207.md" @@ -0,0 +1,64 @@ +--- +title: LCR 012.寻找数组的中心下标 +date: 2023-10-10 14-42-37 +tags: [题解, LeetCode, 简单, 数组, 前缀和] +--- + +# 【LetMeFly】LCR 012.寻找数组的中心下标 + +力扣题目链接：[https://leetcode.cn/problems/tvdfij/](https://leetcode.cn/problems/tvdfij/) + +给你一个整数数组 nums ，请计算数组的 中心下标 。
数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
+ +如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。
+ +
示例 1：
+ ++输入：nums = [1,7,3,6,5,6] +输出：3 +解释： +中心下标是 3 。 +左侧数之和 sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11 ， +右侧数之和 sum = nums[4] + nums[5] = 5 + 6 = 11 ，二者相等。 ++ +
示例 2：
+ ++输入：nums = [1, 2, 3] +输出：-1 +解释： +数组中不存在满足此条件的中心下标。+ +
示例 3：
+ ++输入：nums = [2, 1, -1] +输出：0 +解释： +中心下标是 0 。 +左侧数之和 sum = 0 ，（下标 0 左侧不存在元素）， +右侧数之和 sum = nums[1] + nums[2] = 1 + -1 = 0 。+ +
+ +
提示：
+ +1 <= nums.length <= 104-1000 <= nums[i] <= 1000+ +
注意：本题与主站 724 题相同： https://leetcode-cn.com/problems/find-pivot-index/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 013.\344\272\214\347\273\264\345\214\272\345\237\237\345\222\214\346\243\200\347\264\242 - \347\237\251\351\230\265\344\270\215\345\217\257\345\217\230.md" "b/AllProblems/LCR 013.\344\272\214\347\273\264\345\214\272\345\237\237\345\222\214\346\243\200\347\264\242 - \347\237\251\351\230\265\344\270\215\345\217\257\345\217\230.md" new file mode 100644 index 00000000000..6d63ecbaf7c --- /dev/null +++ "b/AllProblems/LCR 013.\344\272\214\347\273\264\345\214\272\345\237\237\345\222\214\346\243\200\347\264\242 - \347\237\251\351\230\265\344\270\215\345\217\257\345\217\230.md" @@ -0,0 +1,63 @@ +--- +title: LCR 013.二维区域和检索 - 矩阵不可变 +date: 2023-10-10 14-42-37 +tags: [题解, LeetCode, 中等, 设计, 数组, 矩阵, 前缀和] +--- + +# 【LetMeFly】LCR 013.二维区域和检索 - 矩阵不可变 + +力扣题目链接：[https://leetcode.cn/problems/O4NDxx/](https://leetcode.cn/problems/O4NDxx/) + +给定一个二维矩阵 matrix，以下类型的多个请求：
(row1, col1) ，右下角为 (row2, col2) 。实现 NumMatrix 类：
NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化int sumRegion(int row1, int col1, int row2, int col2) 返回左上角 (row1, col1) 、右下角 (row2, col2) 的子矩阵的元素总和。+ +
示例 1：
+ +
+输入: +["NumMatrix","sumRegion","sumRegion","sumRegion"] +[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]] +输出: +[null, 8, 11, 12] + +解释: +NumMatrix numMatrix = new NumMatrix([[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]]); +numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和) +numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和) +numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和) ++ +
+ +
提示：
+ +m == matrix.lengthn == matrix[i].length1 <= m, n <= 200-105 <= matrix[i][j] <= 1050 <= row1 <= row2 < m0 <= col1 <= col2 < n104 次 sumRegion 方法+ +
注意：本题与主站 304 题相同： https://leetcode-cn.com/problems/range-sum-query-2d-immutable/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 014.\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" "b/AllProblems/LCR 014.\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" new file mode 100644 index 00000000000..6bb6b1f6eac --- /dev/null +++ "b/AllProblems/LCR 014.\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227.md" @@ -0,0 +1,46 @@ +--- +title: LCR 014.字符串的排列 +date: 2023-10-10 14-42-38 +tags: [题解, LeetCode, 中等, 哈希表, 双指针, 字符串, 滑动窗口] +--- + +# 【LetMeFly】LCR 014.字符串的排列 + +力扣题目链接：[https://leetcode.cn/problems/MPnaiL/](https://leetcode.cn/problems/MPnaiL/) + +给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的某个变位词。
换句话说，第一个字符串的排列之一是第二个字符串的 子串 。
+ ++ +
示例 1：
+ +
+输入: s1 = "ab" s2 = "eidbaooo"
+输出: True
+解释: s2 包含 s1 的排列之一 ("ba").
+
+
+示例 2：
+ ++输入: s1= "ab" s2 = "eidboaoo" +输出: False ++ +
+ +
提示：
+ +1 <= s1.length, s2.length <= 104s1 和 s2 仅包含小写字母+ +
注意：本题与主站 567 题相同： https://leetcode-cn.com/problems/permutation-in-string/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 015.\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/AllProblems/LCR 015.\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 00000000000..61944c5df46 --- /dev/null +++ "b/AllProblems/LCR 015.\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,52 @@ +--- +title: LCR 015.找到字符串中所有字母异位词 +date: 2023-10-10 14-42-38 +tags: [题解, LeetCode, 中等, 哈希表, 字符串, 滑动窗口] +--- + +# 【LetMeFly】LCR 015.找到字符串中所有字母异位词 + +力扣题目链接：[https://leetcode.cn/problems/VabMRr/](https://leetcode.cn/problems/VabMRr/) + +给定两个字符串 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 * 104s 和 p 仅包含小写字母+ +
注意：本题与主站 438 题相同： https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 016.\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/AllProblems/LCR 016.\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 00000000000..6ac6e14f9f6 --- /dev/null +++ "b/AllProblems/LCR 016.\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,61 @@ +--- +title: LCR 016.无重复字符的最长子串 +date: 2023-10-10 14-42-38 +tags: [题解, LeetCode, 中等, 哈希表, 字符串, 滑动窗口] +--- + +# 【LetMeFly】LCR 016.无重复字符的最长子串 + +力扣题目链接：[https://leetcode.cn/problems/wtcaE1/](https://leetcode.cn/problems/wtcaE1/) + +给定一个字符串 s ，请你找出其中不含有重复字符的 最长连续子字符串 的长度。
+ +
示例 1:
+ +
+输入: s = "abcabcbb"
+输出: 3
+解释: 因为无重复字符的最长子字符串是 "abc"，所以其长度为 3。
+
+
+示例 2:
+ +
+输入: s = "bbbbb"
+输出: 1
+解释: 因为无重复字符的最长子字符串是 "b"，所以其长度为 1。
+
+
+示例 3:
+ ++输入: s = "pwwkew" +输出: 3 +解释: 因为无重复字符的最长子串是+ +"wke"，所以其长度为 3。 + 请注意，你的答案必须是 子串 的长度，"pwke"是一个子序列，不是子串。 +
示例 4:
+ ++输入: s = "" +输出: 0 ++ +
+ +
提示：
+ +0 <= s.length <= 5 * 104s 由英文字母、数字、符号和空格组成+ +
注意：本题与主站 3 题相同： https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 017.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" "b/AllProblems/LCR 017.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" new file mode 100644 index 00000000000..be49e7e0b8b --- /dev/null +++ "b/AllProblems/LCR 017.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" @@ -0,0 +1,60 @@ +--- +title: LCR 017.最小覆盖子串 +date: 2023-10-10 14-42-39 +tags: [题解, LeetCode, 困难, 哈希表, 字符串, 滑动窗口] +--- + +# 【LetMeFly】LCR 017.最小覆盖子串 + +力扣题目链接：[https://leetcode.cn/problems/M1oyTv/](https://leetcode.cn/problems/M1oyTv/) + +给定两个字符串 s 和 t 。返回 s 中包含 t 的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 "" 。
如果 s 中存在多个符合条件的子字符串，返回任意一个。
+ +
注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
+ +
示例 1：
+ ++输入：s = "ADOBECODEBANC", t = "ABC" +输出："BANC" +解释：最短子字符串 "BANC" 包含了字符串 t 的所有字符 'A'、'B'、'C'+ +
示例 2：
+ ++输入：s = "a", t = "a" +输出："a" ++ +
示例 3：
+ ++输入：s = "a", t = "aa" +输出："" +解释：t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。+ +
+ +
提示：
+ +1 <= s.length, t.length <= 105s 和 t 由英文字母组成+ +
进阶：你能设计一个在 o(n) 时间内解决此问题的算法吗？
+ +
注意：本题与主站 76 题相似（本题答案不唯一）：https://leetcode-cn.com/problems/minimum-window-substring/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 018.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" "b/AllProblems/LCR 018.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" new file mode 100644 index 00000000000..a08aa756333 --- /dev/null +++ "b/AllProblems/LCR 018.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" @@ -0,0 +1,45 @@ +--- +title: LCR 018.验证回文串 +date: 2023-10-10 14-42-39 +tags: [题解, LeetCode, 简单, 双指针, 字符串] +--- + +# 【LetMeFly】LCR 018.验证回文串 + +力扣题目链接：[https://leetcode.cn/problems/XltzEq/](https://leetcode.cn/problems/XltzEq/) + +给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。
本题中，将空字符串定义为有效的 回文串 。
+ ++ +
示例 1:
+ ++输入: s = "A man, a plan, a canal: Panama" +输出: true +解释："amanaplanacanalpanama" 是回文串+ +
示例 2:
+ ++输入: s = "race a car" +输出: false +解释："raceacar" 不是回文串+ +
+ +
提示：
+ +1 <= s.length <= 2 * 105s 由 ASCII 字符组成+ +
注意：本题与主站 125 题相同： https://leetcode-cn.com/problems/valid-palindrome/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 019.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262 II.md" "b/AllProblems/LCR 019.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262 II.md" new file mode 100644 index 00000000000..d38132d390b --- /dev/null +++ "b/AllProblems/LCR 019.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262 II.md" @@ -0,0 +1,50 @@ +--- +title: LCR 019.验证回文串 II +date: 2023-10-10 14-42-40 +tags: [题解, LeetCode, 简单, 贪心, 双指针, 字符串] +--- + +# 【LetMeFly】LCR 019.验证回文串 II + +力扣题目链接：[https://leetcode.cn/problems/RQku0D/](https://leetcode.cn/problems/RQku0D/) + +给定一个非空字符串 s，请判断如果 最多 从字符串中删除一个字符能否得到一个回文字符串。
+ +
示例 1:
+ ++输入: s = "aba" +输出: true ++ +
示例 2:
+ ++输入: s = "abca" +输出: true +解释: 可以删除 "c" 字符 或者 "b" 字符 ++ +
示例 3:
+ ++输入: s = "abc" +输出: false+ +
+ +
提示:
+ +1 <= s.length <= 105s 由小写英文字母组成+ +
注意：本题与主站 680 题相同： https://leetcode-cn.com/problems/valid-palindrome-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 020.\345\233\236\346\226\207\345\255\220\344\270\262.md" "b/AllProblems/LCR 020.\345\233\236\346\226\207\345\255\220\344\270\262.md" new file mode 100644 index 00000000000..9eb4ad59072 --- /dev/null +++ "b/AllProblems/LCR 020.\345\233\236\346\226\207\345\255\220\344\270\262.md" @@ -0,0 +1,46 @@ +--- +title: LCR 020.回文子串 +date: 2023-10-10 14-42-40 +tags: [题解, LeetCode, 中等, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 020.回文子串 + +力扣题目链接：[https://leetcode.cn/problems/a7VOhD/](https://leetcode.cn/problems/a7VOhD/) + +给定一个字符串 s ，请计算这个字符串中有多少个回文子字符串。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
+ ++ +
示例 1：
+ ++输入：s = "abc" +输出：3 +解释：三个回文子串: "a", "b", "c" ++ +
示例 2：
+ ++输入：s = "aaa" +输出：6 +解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"+ +
+ +
提示：
+ +1 <= s.length <= 1000s 由小写英文字母组成+ +
注意：本题与主站 70 题相同：https://leetcode-cn.com/problems/palindromic-substrings/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 021.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271.md" "b/AllProblems/LCR 021.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271.md" new file mode 100644 index 00000000000..befb1ff9f15 --- /dev/null +++ "b/AllProblems/LCR 021.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254 N \344\270\252\347\273\223\347\202\271.md" @@ -0,0 +1,58 @@ +--- +title: LCR 021.删除链表的倒数第 N 个结点 +date: 2023-10-10 14-42-41 +tags: [题解, LeetCode, 中等, 链表, 双指针] +--- + +# 【LetMeFly】LCR 021.删除链表的倒数第 N 个结点 + +力扣题目链接：[https://leetcode.cn/problems/SLwz0R/](https://leetcode.cn/problems/SLwz0R/) + +给定一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
+ +
示例 1：
+ +
+输入：head = [1,2,3,4,5], n = 2 +输出：[1,2,3,5] ++ +
示例 2：
+ ++输入：head = [1], n = 1 +输出：[] ++ +
示例 3：
+ ++输入：head = [1,2], n = 1 +输出：[1] ++ +
+ +
提示：
+ +sz1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz+ +
进阶：能尝试使用一趟扫描实现吗？
+ ++ +
注意：本题与主站 19 题相同： https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 022.\347\216\257\345\275\242\351\223\276\350\241\250 II.md" "b/AllProblems/LCR 022.\347\216\257\345\275\242\351\223\276\350\241\250 II.md" new file mode 100644 index 00000000000..3246fecb3ea --- /dev/null +++ "b/AllProblems/LCR 022.\347\216\257\345\275\242\351\223\276\350\241\250 II.md" @@ -0,0 +1,71 @@ +--- +title: LCR 022.环形链表 II +date: 2023-10-10 14-42-41 +tags: [题解, LeetCode, 中等, 哈希表, 链表, 双指针] +--- + +# 【LetMeFly】LCR 022.环形链表 II + +力扣题目链接：[https://leetcode.cn/problems/c32eOV/](https://leetcode.cn/problems/c32eOV/) + +给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
+ ++ +
示例 1：
+ +
+输入：head = [3,2,0,-4], pos = 1 +输出：返回索引为 1 的链表节点 +解释：链表中有一个环，其尾部连接到第二个节点。 ++ +
示例 2：
+ +
+输入：head = [1,2], pos = 0 +输出：返回索引为 0 的链表节点 +解释：链表中有一个环，其尾部连接到第一个节点。 ++ +
示例 3：
+ +
+输入：head = [1], pos = -1 +输出：返回 null +解释：链表中没有环。 ++ +
+ +
提示：
+ +[0, 104] 内-105 <= Node.val <= 105pos 的值为 -1 或者链表中的一个有效索引+ +
进阶：是否可以使用 O(1) 空间解决此题？
+ +
注意：本题与主站 142 题相同： https://leetcode-cn.com/problems/linked-list-cycle-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 023.\347\233\270\344\272\244\351\223\276\350\241\250.md" "b/AllProblems/LCR 023.\347\233\270\344\272\244\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..ca9df91e847 --- /dev/null +++ "b/AllProblems/LCR 023.\347\233\270\344\272\244\351\223\276\350\241\250.md" @@ -0,0 +1,83 @@ +--- +title: LCR 023.相交链表 +date: 2023-10-10 14-42-42 +tags: [题解, LeetCode, 简单, 哈希表, 链表, 双指针] +--- + +# 【LetMeFly】LCR 023.相交链表 + +力扣题目链接：[https://leetcode.cn/problems/3u1WK4/](https://leetcode.cn/problems/3u1WK4/) + +给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
+ +注意，函数返回结果后，链表必须 保持其原始结构 。
+ ++ +
示例 1：
+ +
+输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 +输出：Intersected at '8' +解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。 +从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 +在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 ++ +
示例 2：
+ +
+输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 +输出：Intersected at '2' +解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。 +从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。 +在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 ++ +
示例 3：
+ +
+输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 +输出：null +解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。 +由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 +这两个链表不相交，因此返回 null 。 ++ +
+ +
提示：
+ +listA 中节点数目为 mlistB 中节点数目为 n0 <= m, n <= 3 * 1041 <= Node.val <= 1050 <= skipA <= m0 <= skipB <= nlistA 和 listB 没有交点，intersectVal 为 0listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]+ +
进阶：能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？
+ +
注意：本题与主站 160 题相同：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 024.\345\217\215\350\275\254\351\223\276\350\241\250.md" "b/AllProblems/LCR 024.\345\217\215\350\275\254\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..713cecae7d3 --- /dev/null +++ "b/AllProblems/LCR 024.\345\217\215\350\275\254\351\223\276\350\241\250.md" @@ -0,0 +1,58 @@ +--- +title: LCR 024.反转链表 +date: 2023-10-10 14-42-42 +tags: [题解, LeetCode, 简单, 递归, 链表] +--- + +# 【LetMeFly】LCR 024.反转链表 + +力扣题目链接：[https://leetcode.cn/problems/UHnkqh/](https://leetcode.cn/problems/UHnkqh/) + +给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。
+ +
示例 1：
+
++输入：head = [1,2,3,4,5] +输出：[5,4,3,2,1] ++ +
示例 2：
+
++输入：head = [1,2] +输出：[2,1] ++ +
示例 3：
+ ++输入：head = [] +输出：[] ++ +
+ +
提示：
+ +[0, 5000]-5000 <= Node.val <= 5000+ +
进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
++ +
注意：本题与主站 206 题相同： https://leetcode-cn.com/problems/reverse-linked-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 025.\344\270\244\346\225\260\347\233\270\345\212\240 II.md" "b/AllProblems/LCR 025.\344\270\244\346\225\260\347\233\270\345\212\240 II.md" new file mode 100644 index 00000000000..f328c8993ac --- /dev/null +++ "b/AllProblems/LCR 025.\344\270\244\346\225\260\347\233\270\345\212\240 II.md" @@ -0,0 +1,59 @@ +--- +title: LCR 025.两数相加 II +date: 2023-10-10 14-42-43 +tags: [题解, LeetCode, 中等, 栈, 链表, 数学] +--- + +# 【LetMeFly】LCR 025.两数相加 II + +力扣题目链接：[https://leetcode.cn/problems/lMSNwu/](https://leetcode.cn/problems/lMSNwu/) + +给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
可以假设除了数字 0 之外，这两个数字都不会以零开头。
+ ++ +
示例1：
+ +
+输入：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+ +
进阶：如果输入链表不能修改该如何处理？换句话说，不能对列表中的节点进行翻转。
+ ++ +
注意：本题与主站 445 题相同：https://leetcode-cn.com/problems/add-two-numbers-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 026.\351\207\215\346\216\222\351\223\276\350\241\250.md" "b/AllProblems/LCR 026.\351\207\215\346\216\222\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..8d02650b188 --- /dev/null +++ "b/AllProblems/LCR 026.\351\207\215\346\216\222\351\223\276\350\241\250.md" @@ -0,0 +1,52 @@ +--- +title: LCR 026.重排链表 +date: 2023-10-10 14-42-43 +tags: [题解, LeetCode, 中等, 栈, 递归, 链表, 双指针] +--- + +# 【LetMeFly】LCR 026.重排链表 + +力扣题目链接：[https://leetcode.cn/problems/LGjMqU/](https://leetcode.cn/problems/LGjMqU/) + +给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln-1 → Ln
+请将其重新排列后变为：
L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
+ ++ +
示例 1:
+ +
+输入: head = [1,2,3,4] +输出: [1,4,2,3]+ +
示例 2:
+ +
+输入: head = [1,2,3,4,5] +输出: [1,5,2,4,3]+ +
+ +
提示：
+ +[1, 5 * 104]1 <= node.val <= 1000+ +
注意：本题与主站 143 题相同：https://leetcode-cn.com/problems/reorder-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 027.\345\233\236\346\226\207\351\223\276\350\241\250.md" "b/AllProblems/LCR 027.\345\233\236\346\226\207\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..90f3bf64e71 --- /dev/null +++ "b/AllProblems/LCR 027.\345\233\236\346\226\207\351\223\276\350\241\250.md" @@ -0,0 +1,52 @@ +--- +title: LCR 027.回文链表 +date: 2023-10-10 14-42-44 +tags: [题解, LeetCode, 简单, 栈, 递归, 链表, 双指针] +--- + +# 【LetMeFly】LCR 027.回文链表 + +力扣题目链接：[https://leetcode.cn/problems/aMhZSa/](https://leetcode.cn/problems/aMhZSa/) + +给定一个链表的 头节点 head ，请判断其是否为回文链表。
如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。
+ ++ +
示例 1：
+ +
+输入: head = [1,2,3,3,2,1] +输出: true+ +
示例 2：
+ +
+输入: head = [1,2] +输出: false ++ +
+ +
提示：
+ +[1, 105]0 <= node.val <= 9+ +
进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
+ ++ +
注意：本题与主站 234 题相同：https://leetcode-cn.com/problems/palindrome-linked-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 028.\346\211\201\345\271\263\345\214\226\345\244\232\347\272\247\345\217\214\345\220\221\351\223\276\350\241\250.md" "b/AllProblems/LCR 028.\346\211\201\345\271\263\345\214\226\345\244\232\347\272\247\345\217\214\345\220\221\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..b6725d641bd --- /dev/null +++ "b/AllProblems/LCR 028.\346\211\201\345\271\263\345\214\226\345\244\232\347\272\247\345\217\214\345\220\221\351\223\276\350\241\250.md" @@ -0,0 +1,102 @@ +--- +title: LCR 028.扁平化多级双向链表 +date: 2023-10-10 14-42-45 +tags: [题解, LeetCode, 中等, 深度优先搜索, 链表, 双向链表] +--- + +# 【LetMeFly】LCR 028.扁平化多级双向链表 + +力扣题目链接：[https://leetcode.cn/problems/Qv1Da2/](https://leetcode.cn/problems/Qv1Da2/) + +多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。
+ +给定位于列表第一级的头节点，请扁平化列表，即将这样的多级双向链表展平成普通的双向链表，使所有结点出现在单级双链表中。
+ ++ +
示例 1：
+ ++输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12] +输出：[1,2,3,7,8,11,12,9,10,4,5,6] +解释： + +输入的多级列表如下图所示： + ++ ++ +扁平化后的链表如下图： + +
+
示例 2：
+ ++输入：head = [1,2,null,3] +输出：[1,3,2] +解释： + +输入的多级列表如下图所示： + + 1---2---NULL + | + 3---NULL ++ +
示例 3：
+ ++输入：head = [] +输出：[] ++ +
+ +
如何表示测试用例中的多级链表？
+ +以 示例 1 为例：
+ ++ 1---2---3---4---5---6--NULL + | + 7---8---9---10--NULL + | + 11--12--NULL+ +
序列化其中的每一级之后：
+ ++[1,2,3,4,5,6,null] +[7,8,9,10,null] +[11,12,null] ++ +
为了将每一级都序列化到一起，我们需要每一级中添加值为 null 的元素，以表示没有节点连接到上一级的上级节点。
+ ++[1,2,3,4,5,6,null] +[null,null,7,8,9,10,null] +[null,11,12,null] ++ +
合并所有序列化结果，并去除末尾的 null 。
+ ++[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]+ +
+ +
提示：
+ +10001 <= Node.val <= 10^5+ +
注意：本题与主站 430 题相同： https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 029.\345\276\252\347\216\257\346\234\211\345\272\217\345\210\227\350\241\250\347\232\204\346\217\222\345\205\245.md" "b/AllProblems/LCR 029.\345\276\252\347\216\257\346\234\211\345\272\217\345\210\227\350\241\250\347\232\204\346\217\222\345\205\245.md" new file mode 100644 index 00000000000..7669c6f6af8 --- /dev/null +++ "b/AllProblems/LCR 029.\345\276\252\347\216\257\346\234\211\345\272\217\345\210\227\350\241\250\347\232\204\346\217\222\345\205\245.md" @@ -0,0 +1,64 @@ +--- +title: LCR 029.循环有序列表的插入 +date: 2023-10-10 14-42-45 +tags: [题解, LeetCode, 中等, 链表] +--- + +# 【LetMeFly】LCR 029.循环有序列表的插入 + +力扣题目链接：[https://leetcode.cn/problems/4ueAj6/](https://leetcode.cn/problems/4ueAj6/) + +给定循环单调非递减列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。
给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。
+ +如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。
+ +如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。
+ +
示例 1：
+ +
+
+输入：head = [3,4,1], insertVal = 2 +输出：[3,4,1,2] +解释：在上图中，有一个包含三个元素的循环有序列表，你获得值为 3 的节点的指针，我们需要向表中插入元素 2 。新插入的节点应该在 1 和 3 之间，插入之后，整个列表如上图所示，最后返回节点 3 。 + ++ ++
示例 2：
+ +
+输入：head = [], insertVal = 1
+输出：[1]
+解释：列表为空（给定的节点是 null），创建一个循环有序列表并返回这个节点。
+
+
+示例 3：
+ ++输入：head = [1], insertVal = 0 +输出：[1,0] ++ +
+ +
提示：
+ +0 <= Number of Nodes <= 5 * 10^4-10^6 <= Node.val <= 10^6-10^6 <= insertVal <= 10^6+ +
注意：本题与主站 708 题相同： https://leetcode-cn.com/problems/insert-into-a-sorted-circular-linked-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 030.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" "b/AllProblems/LCR 030.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" new file mode 100644 index 00000000000..e2304f7400d --- /dev/null +++ "b/AllProblems/LCR 030.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" @@ -0,0 +1,59 @@ +--- +title: LCR 030.O(1) 时间插入、删除和获取随机元素 +date: 2023-10-10 14-42-46 +tags: [题解, LeetCode, 中等, 设计, 数组, 哈希表, 数学, 随机化] +--- + +# 【LetMeFly】LCR 030.O(1) 时间插入、删除和获取随机元素 + +力扣题目链接：[https://leetcode.cn/problems/FortPu/](https://leetcode.cn/problems/FortPu/) + +设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构：
+ +insert(val)：当元素 val 不存在时返回 true ，并向集合中插入该项，否则返回 false 。remove(val)：当元素 val 存在时返回 true ，并从集合中移除该项，否则返回 false 。getRandom：随机返回现有集合中的一项。每个元素应该有 相同的概率 被返回。+ +
示例 :
+ ++输入: inputs = ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"] +[[], [1], [2], [2], [], [1], [2], []] +输出: [null, true, false, true, 2, true, false, 2] +解释: +RandomizedSet randomSet = new RandomizedSet(); // 初始化一个空的集合 +randomSet.insert(1); // 向集合中插入 1 ， 返回 true 表示 1 被成功地插入 + +randomSet.remove(2); // 返回 false，表示集合中不存在 2 + +randomSet.insert(2); // 向集合中插入 2 返回 true ，集合现在包含 [1,2] + +randomSet.getRandom(); // getRandom 应随机返回 1 或 2 + +randomSet.remove(1); // 从集合中移除 1 返回 true 。集合现在包含 [2] + +randomSet.insert(2); // 2 已在集合中，所以返回 false + +randomSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 ++ +
+ +
提示：
+ +-231 <= val <= 231 - 1 2 * 105 次 insert ， remove 和 getRandom 方法调用getRandom 方法时，集合中至少有一个元素+ +
注意：本题与主站 380 题相同：https://leetcode-cn.com/problems/insert-delete-getrandom-o1/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 031.LRU \347\274\223\345\255\230.md" "b/AllProblems/LCR 031.LRU \347\274\223\345\255\230.md" new file mode 100644 index 00000000000..439b42e1b92 --- /dev/null +++ "b/AllProblems/LCR 031.LRU \347\274\223\345\255\230.md" @@ -0,0 +1,67 @@ +--- +title: LCR 031.LRU 缓存 +date: 2023-10-10 14-42-46 +tags: [题解, LeetCode, 中等, 设计, 哈希表, 链表, 双向链表] +--- + +# 【LetMeFly】LCR 031.LRU 缓存 + +力扣题目链接：[https://leetcode.cn/problems/OrIXps/](https://leetcode.cn/problems/OrIXps/) + +运用所掌握的数据结构，设计和实现一个 LRU (Least Recently Used，最近最少使用) 缓存机制 。
+ +实现 LRUCache 类：
LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。+ +
示例：
+ +
+输入
+["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 <= 30000 <= key <= 100000 <= value <= 1052 * 105 次 get 和 put+ +
进阶：是否可以在 O(1) 时间复杂度内完成这两种操作？
+ +
注意：本题与主站 146 题相同：https://leetcode-cn.com/problems/lru-cache/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 032.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/AllProblems/LCR 032.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" new file mode 100644 index 00000000000..2c857389c7c --- /dev/null +++ "b/AllProblems/LCR 032.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" @@ -0,0 +1,54 @@ +--- +title: LCR 032.有效的字母异位词 +date: 2023-10-10 14-42-46 +tags: [题解, LeetCode, 简单, 哈希表, 字符串, 排序] +--- + +# 【LetMeFly】LCR 032.有效的字母异位词 + +力扣题目链接：[https://leetcode.cn/problems/dKk3P7/](https://leetcode.cn/problems/dKk3P7/) + +给定两个字符串 s 和 t ，编写一个函数来判断它们是不是一组变位词（字母异位词）。
注意：若 s 和 t 中每个字符出现的次数都相同且字符顺序不完全相同，则称 s 和 t 互为变位词（字母异位词）。
+ +
示例 1:
+ ++输入: s = "anagram", t = "nagaram" +输出: true ++ +
示例 2:
+ ++输入: s = "rat", t = "car" +输出: false+ +
示例 3:
+ ++输入: s = "a", t = "a" +输出: false+ +
+ +
提示:
+ +1 <= s.length, t.length <= 5 * 104s and t 仅包含小写字母+ +
进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
+ ++ +
注意：本题与主站 242 题相似（字母异位词定义不同）：https://leetcode-cn.com/problems/valid-anagram/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 033.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" "b/AllProblems/LCR 033.\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 00000000000..4b6a27724d2 --- /dev/null +++ "b/AllProblems/LCR 033.\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,51 @@ +--- +title: LCR 033.字母异位词分组 +date: 2023-10-10 14-42-47 +tags: [题解, LeetCode, 中等, 数组, 哈希表, 字符串, 排序] +--- + +# 【LetMeFly】LCR 033.字母异位词分组 + +力扣题目链接：[https://leetcode.cn/problems/sfvd7V/](https://leetcode.cn/problems/sfvd7V/) + +给定一个字符串数组 strs ，将 变位词 组合在一起。 可以按任意顺序返回结果列表。
注意：若两个字符串中每个字符出现的次数都相同，则称它们互为变位词。
+ ++ +
示例 1:
+ +
+输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+示例 2:
+ +
+输入: strs = [""]
+输出: [[""]]
+
+
+示例 3:
+ +
+输入: strs = ["a"]
+输出: [["a"]]
+
++ +
提示：
+ +1 <= strs.length <= 1040 <= strs[i].length <= 100strs[i] 仅包含小写字母+ +
注意：本题与主站 49 题相同： https://leetcode-cn.com/problems/group-anagrams/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 034.\351\252\214\350\257\201\345\244\226\346\230\237\350\257\255\350\257\215\345\205\270.md" "b/AllProblems/LCR 034.\351\252\214\350\257\201\345\244\226\346\230\237\350\257\255\350\257\215\345\205\270.md" new file mode 100644 index 00000000000..daa972d77a7 --- /dev/null +++ "b/AllProblems/LCR 034.\351\252\214\350\257\201\345\244\226\346\230\237\350\257\255\350\257\215\345\205\270.md" @@ -0,0 +1,55 @@ +--- +title: LCR 034.验证外星语词典 +date: 2023-10-10 14-42-47 +tags: [题解, LeetCode, 简单, 数组, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 034.验证外星语词典 + +力扣题目链接：[https://leetcode.cn/problems/lwyVBB/](https://leetcode.cn/problems/lwyVBB/) + +某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。
给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。
+ +
示例 1：
+ ++输入：words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz" +输出：true +解释：在该语言的字母表中，'h' 位于 'l' 之前，所以单词序列是按字典序排列的。+ +
示例 2：
+ ++输入：words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz" +输出：false +解释：在该语言的字母表中，'d' 位于 'l' 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。+ +
示例 3：
+ ++输入：words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz" +输出：false +解释：当前三个字符 "app" 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 "apple" > "app"，因为 'l' > '∅'，其中 '∅' 是空白字符，定义为比任何其他字符都小（更多信息）。 ++ +
+ +
提示：
+ +1 <= words.length <= 1001 <= words[i].length <= 20order.length == 26words[i] 和 order 中的所有字符都是英文小写字母。+ +
注意：本题与主站 953 题相同： https://leetcode-cn.com/problems/verifying-an-alien-dictionary/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 035.\346\234\200\345\260\217\346\227\266\351\227\264\345\267\256.md" "b/AllProblems/LCR 035.\346\234\200\345\260\217\346\227\266\351\227\264\345\267\256.md" new file mode 100644 index 00000000000..5406da051c4 --- /dev/null +++ "b/AllProblems/LCR 035.\346\234\200\345\260\217\346\227\266\351\227\264\345\267\256.md" @@ -0,0 +1,43 @@ +--- +title: LCR 035.最小时间差 +date: 2023-10-10 14-42-48 +tags: [题解, LeetCode, 中等, 数组, 数学, 字符串, 排序] +--- + +# 【LetMeFly】LCR 035.最小时间差 + +力扣题目链接：[https://leetcode.cn/problems/569nqc/](https://leetcode.cn/problems/569nqc/) + +给定一个 24 小时制（小时:分钟 "HH:MM"）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。
+ ++ +
示例 1：
+ ++输入：timePoints = ["23:59","00:00"] +输出：1 ++ +
示例 2：
+ ++输入：timePoints = ["00:00","23:59","00:00"] +输出：0 ++ +
+ +
提示：
+ +2 <= timePoints <= 2 * 104timePoints[i] 格式为 "HH:MM"+ +
注意：本题与主站 539 题相同： https://leetcode-cn.com/problems/minimum-time-difference/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 036.\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/AllProblems/LCR 036.\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 00000000000..d434db74666 --- /dev/null +++ "b/AllProblems/LCR 036.\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,89 @@ +--- +title: LCR 036.逆波兰表达式求值 +date: 2023-10-10 14-42-48 +tags: [题解, LeetCode, 中等, 栈, 数组, 数学] +--- + +# 【LetMeFly】LCR 036.逆波兰表达式求值 + +力扣题目链接：[https://leetcode.cn/problems/8Zf90G/](https://leetcode.cn/problems/8Zf90G/) + +根据 逆波兰表示法，求该后缀表达式的计算结果。
+ +有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
+ +
说明：
+ ++ +
示例 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 <= 104tokens[i] 要么是一个算符（"+"、"-"、"*" 或 "/"），要么是一个在范围 [-200, 200] 内的整数+ +
逆波兰表达式：
+ +逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
+ +( 1 + 2 ) * ( 3 + 4 ) 。( ( 1 2 + ) ( 3 4 + ) * ) 。逆波兰表达式主要有以下两个优点：
+ +1 2 + 3 4 + * 也可以依据次序计算出正确结果。+ +
注意：本题与主站 150 题相同： https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 037.\350\241\214\346\230\237\347\242\260\346\222\236.md" "b/AllProblems/LCR 037.\350\241\214\346\230\237\347\242\260\346\222\236.md" new file mode 100644 index 00000000000..ad6a306c43d --- /dev/null +++ "b/AllProblems/LCR 037.\350\241\214\346\230\237\347\242\260\346\222\236.md" @@ -0,0 +1,62 @@ +--- +title: LCR 037.行星碰撞 +date: 2023-10-10 14-42-49 +tags: [题解, LeetCode, 中等, 栈, 数组, 模拟] +--- + +# 【LetMeFly】LCR 037.行星碰撞 + +力扣题目链接：[https://leetcode.cn/problems/XagZNi/](https://leetcode.cn/problems/XagZNi/) + +给定一个整数数组 asteroids，表示在同一行的小行星。
对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。
+ +找出碰撞后剩下的所有小行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。
+ ++ +
示例 1：
+ ++输入：asteroids = [5,10,-5] +输出：[5,10] +解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。+ +
示例 2：
+ ++输入：asteroids = [8,-8] +输出：[] +解释：8 和 -8 碰撞后，两者都发生爆炸。+ +
示例 3：
+ ++输入：asteroids = [10,2,-5] +输出：[10] +解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。+ +
示例 4：
+ ++输入：asteroids = [-2,-1,1,2] +输出：[-2,-1,1,2] +解释：-2 和 -1 向左移动，而 1 和 2 向右移动。 由于移动方向相同的行星不会发生碰撞，所以最终没有行星发生碰撞。+ +
+ +
提示：
+ +2 <= asteroids.length <= 104-1000 <= asteroids[i] <= 1000asteroids[i] != 0+ +
注意：本题与主站 735 题相同： https://leetcode-cn.com/problems/asteroid-collision/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 038.\346\257\217\346\227\245\346\270\251\345\272\246.md" "b/AllProblems/LCR 038.\346\257\217\346\227\245\346\270\251\345\272\246.md" new file mode 100644 index 00000000000..88b1ac4c2f2 --- /dev/null +++ "b/AllProblems/LCR 038.\346\257\217\346\227\245\346\270\251\345\272\246.md" @@ -0,0 +1,49 @@ +--- +title: LCR 038.每日温度 +date: 2023-10-10 14-42-49 +tags: [题解, LeetCode, 中等, 栈, 数组, 单调栈] +--- + +# 【LetMeFly】LCR 038.每日温度 + +力扣题目链接：[https://leetcode.cn/problems/iIQa4I/](https://leetcode.cn/problems/iIQa4I/) + +请根据每日 气温 列表 temperatures ，重新生成一个列表，要求其对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 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 <= 10530 <= temperatures[i] <= 100+ +
注意：本题与主站 739 题相同： https://leetcode-cn.com/problems/daily-temperatures/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 039.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md" "b/AllProblems/LCR 039.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md" new file mode 100644 index 00000000000..69c68bb5f38 --- /dev/null +++ "b/AllProblems/LCR 039.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md" @@ -0,0 +1,49 @@ +--- +title: LCR 039.柱状图中最大的矩形 +date: 2023-10-10 14-42-50 +tags: [题解, LeetCode, 困难, 栈, 数组, 单调栈] +--- + +# 【LetMeFly】LCR 039.柱状图中最大的矩形 + +力扣题目链接：[https://leetcode.cn/problems/0ynMMM/](https://leetcode.cn/problems/0ynMMM/) + +给定非负整数数组 heights ，数组中的数字用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。
+ ++ +
示例 1:
+ +
+输入：heights = [2,1,5,6,2,3] +输出：10 +解释：最大的矩形为图中红色区域，面积为 10 ++ +
示例 2：
+ +
+输入： heights = [2,4] +输出： 4+ +
+ +
提示：
+ +1 <= heights.length <=1050 <= heights[i] <= 104+ +
注意：本题与主站 84 题相同： https://leetcode-cn.com/problems/largest-rectangle-in-histogram/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 040.\346\234\200\345\244\247\347\237\251\345\275\242.md" "b/AllProblems/LCR 040.\346\234\200\345\244\247\347\237\251\345\275\242.md" new file mode 100644 index 00000000000..803ca0f1f48 --- /dev/null +++ "b/AllProblems/LCR 040.\346\234\200\345\244\247\347\237\251\345\275\242.md" @@ -0,0 +1,71 @@ +--- +title: LCR 040.最大矩形 +date: 2023-10-10 14-42-50 +tags: [题解, LeetCode, 困难, 栈, 数组, 动态规划, 矩阵, 单调栈] +--- + +# 【LetMeFly】LCR 040.最大矩形 + +力扣题目链接：[https://leetcode.cn/problems/PLYXKQ/](https://leetcode.cn/problems/PLYXKQ/) + +给定一个由 0 和 1 组成的矩阵 matrix ，找出只包含 1 的最大矩形，并返回其面积。
注意：此题 matrix 输入格式为一维 01 字符串数组。
+ +
示例 1：
+ +
+输入：matrix = ["10100","10111","11111","10010"] +输出：6 +解释：最大矩形如上图所示。 ++ +
示例 2：
+ ++输入：matrix = [] +输出：0 ++ +
示例 3：
+ ++输入：matrix = ["0"] +输出：0 ++ +
示例 4：
+ ++输入：matrix = ["1"] +输出：1 ++ +
示例 5：
+ ++输入：matrix = ["00"] +输出：0 ++ +
+ +
提示：
+ +rows == matrix.lengthcols == matrix[0].length0 <= row, cols <= 200matrix[i][j] 为 '0' 或 '1'+ +
注意：本题与主站 85 题相同（输入参数格式不同）： https://leetcode-cn.com/problems/maximal-rectangle/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 041.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\247\273\345\212\250\345\271\263\345\235\207\345\200\274.md" "b/AllProblems/LCR 041.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\247\273\345\212\250\345\271\263\345\235\207\345\200\274.md" new file mode 100644 index 00000000000..e2c0581fb58 --- /dev/null +++ "b/AllProblems/LCR 041.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\247\273\345\212\250\345\271\263\345\235\207\345\200\274.md" @@ -0,0 +1,54 @@ +--- +title: LCR 041.数据流中的移动平均值 +date: 2023-10-10 14-42-51 +tags: [题解, LeetCode, 简单, 设计, 队列, 数组, 数据流] +--- + +# 【LetMeFly】LCR 041.数据流中的移动平均值 + +力扣题目链接：[https://leetcode.cn/problems/qIsx9U/](https://leetcode.cn/problems/qIsx9U/) + +给定一个窗口大小和一个整数数据流，根据该滑动窗口的大小，计算滑动窗口里所有数字的平均值。
+ +实现 MovingAverage 类：
MovingAverage(int size) 用窗口大小 size 初始化对象。double next(int val) 成员函数 next 每次调用的时候都会往滑动窗口增加一个整数，请计算并返回数据流中最后 size 个值的移动平均值，即滑动窗口里所有数字的平均值。+ +
示例：
+ ++输入： +inputs = ["MovingAverage", "next", "next", "next", "next"] +inputs = [[3], [1], [10], [3], [5]] +输出： +[null, 1.0, 5.5, 4.66667, 6.0] + +解释： +MovingAverage movingAverage = new MovingAverage(3); +movingAverage.next(1); // 返回 1.0 = 1 / 1 +movingAverage.next(10); // 返回 5.5 = (1 + 10) / 2 +movingAverage.next(3); // 返回 4.66667 = (1 + 10 + 3) / 3 +movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3 ++ +
+ +
提示：
+ +1 <= size <= 1000-105 <= val <= 105next 方法 104 次+ +
注意：本题与主站 346 题相同： https://leetcode-cn.com/problems/moving-average-from-data-stream/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 042.\346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md" "b/AllProblems/LCR 042.\346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md" new file mode 100644 index 00000000000..486b70f6870 --- /dev/null +++ "b/AllProblems/LCR 042.\346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md" @@ -0,0 +1,56 @@ +--- +title: LCR 042.最近的请求次数 +date: 2023-10-10 14-42-51 +tags: [题解, LeetCode, 简单, 设计, 队列, 数据流] +--- + +# 【LetMeFly】LCR 042.最近的请求次数 + +力扣题目链接：[https://leetcode.cn/problems/H8086Q/](https://leetcode.cn/problems/H8086Q/) + +写一个 RecentCounter 类来计算特定时间范围内最近的请求。
请实现 RecentCounter 类：
RecentCounter() 初始化计数器，请求数为 0 。int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。保证 每次对 ping 的调用都使用比之前更大的 t 值。
+ +
示例：
+ ++输入： +inputs = ["RecentCounter", "ping", "ping", "ping", "ping"] +inputs = [[], [1], [100], [3001], [3002]] +输出： +[null, 1, 2, 3, 3] + +解释： +RecentCounter recentCounter = new RecentCounter(); +recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1 +recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2 +recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3 +recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3 ++ +
+ +
提示：
+ +1 <= t <= 109ping 调用所使用的 t 值都 严格递增ping 方法 104 次+ +
注意：本题与主站 933 题相同： https://leetcode-cn.com/problems/number-of-recent-calls/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 043.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\346\217\222\345\205\245\345\231\250.md" "b/AllProblems/LCR 043.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\346\217\222\345\205\245\345\231\250.md" new file mode 100644 index 00000000000..6d9bc81d056 --- /dev/null +++ "b/AllProblems/LCR 043.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\346\217\222\345\205\245\345\231\250.md" @@ -0,0 +1,55 @@ +--- +title: LCR 043.完全二叉树插入器 +date: 2023-10-10 14-42-51 +tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 设计, 二叉树] +--- + +# 【LetMeFly】LCR 043.完全二叉树插入器 + +力扣题目链接：[https://leetcode.cn/problems/NaqhDT/](https://leetcode.cn/problems/NaqhDT/) + +完全二叉树是每一层（除最后一层外）都是完全填充（即，节点数达到最大，第 n 层有 2n-1 个节点）的，并且所有的节点都尽可能地集中在左侧。
设计一个用完全二叉树初始化的数据结构 CBTInserter，它支持以下几种操作：
CBTInserter(TreeNode root) 使用根节点为 root 的给定树初始化该数据结构；CBTInserter.insert(int v) 向树中插入一个新节点，节点类型为 TreeNode，值为 v 。使树保持完全二叉树的状态，并返回插入的新节点的父节点的值；CBTInserter.get_root() 将返回树的根节点。+ +
示例 1：
+ ++输入：inputs = ["CBTInserter","insert","get_root"], inputs = [[[1]],[2],[]] +输出：[null,1,[1,2]] ++ +
示例 2：
+ ++输入：inputs = ["CBTInserter","insert","insert","get_root"], inputs = [[[1,2,3,4,5,6]],[7],[8],[]] +输出：[null,3,4,[1,2,3,4,5,6,7,8]] ++ +
+ +
提示：
+ +1 到 1000 个节点。CBTInserter.insert 操作 10000 次。0 到 5000 之间。+ +
注意：本题与主站 919 题相同： https://leetcode-cn.com/problems/complete-binary-tree-inserter/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 044.\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.md" "b/AllProblems/LCR 044.\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.md" new file mode 100644 index 00000000000..5eea9b6fd38 --- /dev/null +++ "b/AllProblems/LCR 044.\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.md" @@ -0,0 +1,78 @@ +--- +title: LCR 044.在每个树行中找最大值 +date: 2023-10-10 14-42-52 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 044.在每个树行中找最大值 + +力扣题目链接：[https://leetcode.cn/problems/hPov7L/](https://leetcode.cn/problems/hPov7L/) + +给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
+ +
示例1：
+ ++输入: root = [1,3,2,5,3,null,9] +输出: [1,3,9] +解释: + 1 + / \ + 3 2 + / \ \ + 5 3 9 ++ +
示例2：
+ ++输入: root = [1,2,3] +输出: [1,3] +解释: + 1 + / \ + 2 3 ++ +
示例3：
+ ++输入: root = [1] +输出: [1] ++ +
示例4：
+ ++输入: root = [1,null,2] +输出: [1,2] +解释: + 1 + \ + 2 ++ +
示例5：
+ ++输入: root = [] +输出: [] ++ +
+ +
提示：
+ +[0,104]-231 <= Node.val <= 231 - 1+ +
注意：本题与主站 515 题相同： https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 045.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md" "b/AllProblems/LCR 045.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md" new file mode 100644 index 00000000000..aaec2c4ce78 --- /dev/null +++ "b/AllProblems/LCR 045.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md" @@ -0,0 +1,49 @@ +--- +title: LCR 045.找树左下角的值 +date: 2023-10-10 14-42-52 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 045.找树左下角的值 + +力扣题目链接：[https://leetcode.cn/problems/LwUNpT/](https://leetcode.cn/problems/LwUNpT/) + +给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
+ ++ +
示例 1:
+ +
+输入: root = [2,1,3] +输出: 1 ++ +
示例 2:
+ +
+输入: [1,2,3,4,null,5,6,null,null,7] +输出: 7 ++ +
+ +
提示:
+ +[1,104]-231 <= Node.val <= 231 - 1 + +
注意：本题与主站 513 题相同： https://leetcode-cn.com/problems/find-bottom-left-tree-value/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 046.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md" "b/AllProblems/LCR 046.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md" new file mode 100644 index 00000000000..57d1eb72fa8 --- /dev/null +++ "b/AllProblems/LCR 046.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md" @@ -0,0 +1,52 @@ +--- +title: LCR 046.二叉树的右视图 +date: 2023-10-10 14-42-53 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 046.二叉树的右视图 + +力扣题目链接：[https://leetcode.cn/problems/WNC0Lk/](https://leetcode.cn/problems/WNC0Lk/) + +给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+ +
示例 1:
+ +
+输入: [1,2,3,null,5,null,4] +输出: [1,3,4] ++ +
示例 2:
+ ++输入: [1,null,3] +输出: [1,3] ++ +
示例 3:
+ ++输入: [] +输出: [] ++ +
+ +
提示:
+ +[0,100]-100 <= Node.val <= 100 + +
注意：本题与主站 199 题相同：https://leetcode-cn.com/problems/binary-tree-right-side-view/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 047.\344\272\214\345\217\211\346\240\221\345\211\252\346\236\235.md" "b/AllProblems/LCR 047.\344\272\214\345\217\211\346\240\221\345\211\252\346\236\235.md" new file mode 100644 index 00000000000..6e9302f89cc --- /dev/null +++ "b/AllProblems/LCR 047.\344\272\214\345\217\211\346\240\221\345\211\252\346\236\235.md" @@ -0,0 +1,63 @@ +--- +title: LCR 047.二叉树剪枝 +date: 2023-10-10 14-42-53 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 047.二叉树剪枝 + +力扣题目链接：[https://leetcode.cn/problems/pOCWxh/](https://leetcode.cn/problems/pOCWxh/) + +给定一个二叉树 根节点 root ，树的每个节点的值要么是 0，要么是 1。请剪除该二叉树中所有节点的值为 0 的子树。
节点 node 的子树为 node 本身，以及所有 node 的后代。
+ +
示例 1:
+ ++输入: [1,null,0,0,1] +输出: [1,null,0,null,1] +解释: +只有红色节点满足条件“所有不包含 1 的子树”。 +右图为返回的答案。 + ++ ++
示例 2:
+ ++输入: [1,0,1,0,0,0,1] +输出: [1,null,1,null,1] +解释: + ++ ++
示例 3:
+ ++输入: [1,1,0,1,1,0,1,0] +输出: [1,1,0,1,1,null,1] +解释: + ++ ++
+ +
提示:
+ +[1,200]0 或 1+ +
注意：本题与主站 814 题相同：https://leetcode-cn.com/problems/binary-tree-pruning/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 048.\344\272\214\345\217\211\346\240\221\347\232\204\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226.md" "b/AllProblems/LCR 048.\344\272\214\345\217\211\346\240\221\347\232\204\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226.md" new file mode 100644 index 00000000000..44ca2607042 --- /dev/null +++ "b/AllProblems/LCR 048.\344\272\214\345\217\211\346\240\221\347\232\204\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226.md" @@ -0,0 +1,62 @@ +--- +title: LCR 048.二叉树的序列化与反序列化 +date: 2023-10-10 14-42-54 +tags: [题解, LeetCode, 困难, 树, 深度优先搜索, 广度优先搜索, 设计, 字符串, 二叉树] +--- + +# 【LetMeFly】LCR 048.二叉树的序列化与反序列化 + +力扣题目链接：[https://leetcode.cn/problems/h54YBf/](https://leetcode.cn/problems/h54YBf/) + +序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。
+ +请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
+ ++ +
示例 1：
+ +
+输入：root = [1,2,3,null,null,4,5] +输出：[1,2,3,null,null,4,5] ++ +
示例 2：
+ ++输入：root = [] +输出：[] ++ +
示例 3：
+ ++输入：root = [1] +输出：[1] ++ +
示例 4：
+ ++输入：root = [1,2] +输出：[1,2] ++ +
+ +
提示：
+ +[0, 104] 内-1000 <= Node.val <= 1000+ +
注意：本题与主站 297 题相同：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 049.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md" "b/AllProblems/LCR 049.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md" new file mode 100644 index 00000000000..9aaaa13a670 --- /dev/null +++ "b/AllProblems/LCR 049.\346\261\202\346\240\271\350\212\202\347\202\271\345\210\260\345\217\266\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md" @@ -0,0 +1,66 @@ +--- +title: LCR 049.求根节点到叶节点数字之和 +date: 2023-10-10 14-42-54 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 049.求根节点到叶节点数字之和 + +力扣题目链接：[https://leetcode.cn/problems/3Etpl5/](https://leetcode.cn/problems/3Etpl5/) + +给定一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
每条从根节点到叶节点的路径都代表一个数字：
+ +1 -> 2 -> 3 表示数字 123 。计算从根节点到叶节点生成的 所有数字之和 。
+ +叶节点 是指没有子节点的节点。
+ ++ +
示例 1：
+
++输入：root = [1,2,3] +输出：25 +解释： +从根到叶子节点路径+ +1->2代表数字12+从根到叶子节点路径1->3代表数字13+因此，数字总和 = 12 + 13 =25
示例 2：
+
++输入：root = [4,9,0,5,1] +输出：1026 +解释： +从根到叶子节点路径+ +4->9->5代表数字 495 +从根到叶子节点路径4->9->1代表数字 491 +从根到叶子节点路径4->0代表数字 40 +因此，数字总和 = 495 + 491 + 40 =1026+
+ +
提示：
+ +[1, 1000] 内0 <= Node.val <= 910+ +
注意：本题与主站 129 题相同： https://leetcode-cn.com/problems/sum-root-to-leaf-numbers/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 050.\350\267\257\345\276\204\346\200\273\345\222\214 III.md" "b/AllProblems/LCR 050.\350\267\257\345\276\204\346\200\273\345\222\214 III.md" new file mode 100644 index 00000000000..d424240e1e1 --- /dev/null +++ "b/AllProblems/LCR 050.\350\267\257\345\276\204\346\200\273\345\222\214 III.md" @@ -0,0 +1,49 @@ +--- +title: LCR 050.路径总和 III +date: 2023-10-10 14-42-55 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 050.路径总和 III + +力扣题目链接：[https://leetcode.cn/problems/6eUYwP/](https://leetcode.cn/problems/6eUYwP/) + +给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
+ ++ +
示例 1：
+ +
+输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8 +输出：3 +解释：和等于 8 的路径有 3 条，如图所示。 ++ +
示例 2：
+ ++输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22 +输出：3 ++ +
+ +
提示:
+ +[0,1000]-109 <= Node.val <= 109 -1000 <= targetSum <= 1000 + +
注意：本题与主站 437 题相同：https://leetcode-cn.com/problems/path-sum-iii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 051.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md" "b/AllProblems/LCR 051.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md" new file mode 100644 index 00000000000..03fd6874453 --- /dev/null +++ "b/AllProblems/LCR 051.\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md" @@ -0,0 +1,52 @@ +--- +title: LCR 051.二叉树中的最大路径和 +date: 2023-10-10 14-42-55 +tags: [题解, LeetCode, 困难, 树, 深度优先搜索, 动态规划, 二叉树] +--- + +# 【LetMeFly】LCR 051.二叉树中的最大路径和 + +力扣题目链接：[https://leetcode.cn/problems/jC7MId/](https://leetcode.cn/problems/jC7MId/) + +路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
+ +路径和 是路径中各节点值的总和。
+ +给定一个二叉树的根节点 root ，返回其 最大路径和，即所有路径上节点值之和的最大值。
+ +
示例 1：
+ +
+输入：root = [1,2,3] +输出：6 +解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6+ +
示例 2：
+ +
+输入：root = [-10,9,20,null,null,15,7] +输出：42 +解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42 ++ +
+ +
提示：
+ +[1, 3 * 104]-1000 <= Node.val <= 1000+ +
注意：本题与主站 124 题相同： https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 052.\351\200\222\345\242\236\351\241\272\345\272\217\346\220\234\347\264\242\346\240\221.md" "b/AllProblems/LCR 052.\351\200\222\345\242\236\351\241\272\345\272\217\346\220\234\347\264\242\346\240\221.md" new file mode 100644 index 00000000000..55848dbca38 --- /dev/null +++ "b/AllProblems/LCR 052.\351\200\222\345\242\236\351\241\272\345\272\217\346\220\234\347\264\242\346\240\221.md" @@ -0,0 +1,47 @@ +--- +title: LCR 052.递增顺序搜索树 +date: 2023-10-10 14-42-56 +tags: [题解, LeetCode, 简单, 栈, 树, 深度优先搜索, 二叉搜索树, 二叉树] +--- + +# 【LetMeFly】LCR 052.递增顺序搜索树 + +力扣题目链接：[https://leetcode.cn/problems/NYBBNL/](https://leetcode.cn/problems/NYBBNL/) + +给你一棵二叉搜索树，请 按中序遍历 将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。
+ ++ +
示例 1：
+ +
+输入：root = [5,3,6,2,4,null,8,1,null,null,null,7,9] +输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9] ++ +
示例 2：
+ +
+输入：root = [5,1,7] +输出：[1,null,5,null,7] ++ +
+ +
提示：
+ +[1, 100]0 <= Node.val <= 1000+ +
注意：本题与主站 897 题相同： https://leetcode-cn.com/problems/increasing-order-search-tree/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 053.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\270\255\345\272\217\345\220\216\347\273\247.md" "b/AllProblems/LCR 053.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\270\255\345\272\217\345\220\216\347\273\247.md" new file mode 100644 index 00000000000..79f7aff1bc1 --- /dev/null +++ "b/AllProblems/LCR 053.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\270\255\345\272\217\345\220\216\347\273\247.md" @@ -0,0 +1,52 @@ +--- +title: LCR 053.二叉搜索树中的中序后继 +date: 2023-10-10 14-42-56 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉搜索树, 二叉树] +--- + +# 【LetMeFly】LCR 053.二叉搜索树中的中序后继 + +力扣题目链接：[https://leetcode.cn/problems/P5rCT8/](https://leetcode.cn/problems/P5rCT8/) + +给定一棵二叉搜索树和其中的一个节点 p ，找到该节点在树中的中序后继。如果节点没有中序后继，请返回 null 。
节点 p 的后继是值比 p.val 大的节点中键值最小的节点，即按中序遍历的顺序节点 p 的下一个节点。
+ +
示例 1：
+ +
+输入：root = [2,1,3], p = 1 +输出：2 +解释：这里 1 的中序后继是 2。请注意 p 和返回值都应是 TreeNode 类型。 ++ +
示例 2：
+ +
+输入：root = [5,3,6,2,4,null,null,1], p = 6
+输出：null
+解释：因为给出的节点没有中序后继，所以答案就返回 null 了。
+
+
++ +
提示：
+ +[1, 104] 内。-105 <= Node.val <= 105+ +
注意：本题与主站 285 题相同： https://leetcode-cn.com/problems/inorder-successor-in-bst/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 054.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md" "b/AllProblems/LCR 054.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md" new file mode 100644 index 00000000000..8d0c7c9aff4 --- /dev/null +++ "b/AllProblems/LCR 054.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md" @@ -0,0 +1,76 @@ +--- +title: LCR 054.把二叉搜索树转换为累加树 +date: 2023-10-10 14-42-57 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉搜索树, 二叉树] +--- + +# 【LetMeFly】LCR 054.把二叉搜索树转换为累加树 + +力扣题目链接：[https://leetcode.cn/problems/w6cpku/](https://leetcode.cn/problems/w6cpku/) + +给定一个二叉搜索树，请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。
+ ++ +
提醒一下，二叉搜索树满足下列约束条件：
+ ++ +
示例 1：
+ +
+输入：root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8] +输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8] ++ +
示例 2：
+ ++输入：root = [0,null,1] +输出：[1,null,1] ++ +
示例 3：
+ ++输入：root = [1,0,2] +输出：[3,3,2] ++ +
示例 4：
+ ++输入：root = [3,2,4,1] +输出：[7,9,4,10] ++ +
+ +
提示：
+ +0 和 104 之间。-104 和 104 之间。+ +
注意：
+ +实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。int next()将指针向右移动，然后返回指针处的数字。注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。
+ +
示例：
+ +
+输入 +inputs = ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"] +inputs = [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []] +输出 +[null, 3, 7, true, 9, true, 15, true, 20, false] + +解释 +BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]); +bSTIterator.next(); // 返回 3 +bSTIterator.next(); // 返回 7 +bSTIterator.hasNext(); // 返回 True +bSTIterator.next(); // 返回 9 +bSTIterator.hasNext(); // 返回 True +bSTIterator.next(); // 返回 15 +bSTIterator.hasNext(); // 返回 True +bSTIterator.next(); // 返回 20 +bSTIterator.hasNext(); // 返回 False ++ +
+ +
提示：
+ +[1, 105] 内0 <= Node.val <= 106105 次 hasNext 和 next 操作+ +
进阶：
+ +next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高度。+ +
注意：本题与主站 173 题相同： https://leetcode-cn.com/problems/binary-search-tree-iterator/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 056.\344\270\244\346\225\260\344\271\213\345\222\214 IV - \350\276\223\345\205\245\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/AllProblems/LCR 056.\344\270\244\346\225\260\344\271\213\345\222\214 IV - \350\276\223\345\205\245\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" new file mode 100644 index 00000000000..15b6ff07d81 --- /dev/null +++ "b/AllProblems/LCR 056.\344\270\244\346\225\260\344\271\213\345\222\214 IV - \350\276\223\345\205\245\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" @@ -0,0 +1,47 @@ +--- +title: LCR 056.两数之和 IV - 输入二叉搜索树 +date: 2023-10-10 14-42-58 +tags: [题解, LeetCode, 简单, 数组, 滑动窗口] +--- + +# 【LetMeFly】LCR 056.两数之和 IV - 输入二叉搜索树 + +力扣题目链接：[https://leetcode.cn/problems/opLdQZ/](https://leetcode.cn/problems/opLdQZ/) + +给定一个二叉搜索树的 根节点 root 和一个整数 k , 请判断该二叉搜索树中是否存在两个节点它们的值之和等于 k 。假设二叉搜索树中节点的值均唯一。
+ +
示例 1：
+ ++输入: root = [8,6,10,5,7,9,11], k = 12 +输出: true +解释: 节点 5 和节点 7 之和等于 12 ++ +
示例 2：
+ ++输入: root = [8,6,10,5,7,9,11], k = 22 +输出: false +解释: 不存在两个节点值之和为 22 的节点 ++ +
+ +
提示：
+ +[1, 104].-104 <= Node.val <= 104root 为二叉搜索树-105 <= k <= 105+ +
注意：本题与主站 653 题相同： https://leetcode-cn.com/problems/two-sum-iv-input-is-a-bst/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 057.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" "b/AllProblems/LCR 057.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" new file mode 100644 index 00000000000..a26594b661c --- /dev/null +++ "b/AllProblems/LCR 057.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 III.md" @@ -0,0 +1,51 @@ +--- +title: LCR 057.存在重复元素 III +date: 2023-10-10 14-42-58 +tags: [题解, LeetCode, 中等, 数组, 桶排序, 有序集合, 排序, 滑动窗口] +--- + +# 【LetMeFly】LCR 057.存在重复元素 III + +力扣题目链接：[https://leetcode.cn/problems/7WqeDu/](https://leetcode.cn/problems/7WqeDu/) + +给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。
如果存在则返回 true，不存在返回 false。
+ +
示例 1：
+ ++输入：nums = [1,2,3,1], k = 3, t = 0 +输出：true+ +
示例 2：
+ ++输入：nums = [1,0,1,1], k = 1, t = 2 +输出：true+ +
示例 3：
+ ++输入：nums = [1,5,9,1,5,9], k = 2, t = 3 +输出：false+ +
+ +
提示：
+ +0 <= nums.length <= 2 * 104-231 <= nums[i] <= 231 - 10 <= k <= 1040 <= t <= 231 - 1+ +
注意：本题与主站 220 题相同： https://leetcode-cn.com/problems/contains-duplicate-iii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 058.\346\210\221\347\232\204\346\227\245\347\250\213\345\256\211\346\216\222\350\241\250 I.md" "b/AllProblems/LCR 058.\346\210\221\347\232\204\346\227\245\347\250\213\345\256\211\346\216\222\350\241\250 I.md" new file mode 100644 index 00000000000..a1bf9dde7ad --- /dev/null +++ "b/AllProblems/LCR 058.\346\210\221\347\232\204\346\227\245\347\250\213\345\256\211\346\216\222\350\241\250 I.md" @@ -0,0 +1,53 @@ +--- +title: LCR 058.我的日程安排表 I +date: 2023-10-10 14-42-59 +tags: [题解, LeetCode, 中等, 设计, 线段树, 二分查找, 有序集合] +--- + +# 【LetMeFly】LCR 058.我的日程安排表 I + +力扣题目链接：[https://leetcode.cn/problems/fi9suh/](https://leetcode.cn/problems/fi9suh/) + +请实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排，则可以存储这个新的日程安排。
MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。
当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生重复预订。
+ +每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。
请按照以下步骤调用 MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)
+ +
示例:
+ ++输入: +["MyCalendar","book","book","book"] +[[],[10,20],[15,25],[20,30]] +输出: [null,true,false,true] +解释: +MyCalendar myCalendar = new MyCalendar(); +MyCalendar.book(10, 20); // returns true +MyCalendar.book(15, 25); // returns false ，第二个日程安排不能添加到日历中，因为时间 15 已经被第一个日程安排预定了 +MyCalendar.book(20, 30); // returns true ，第三个日程安排可以添加到日历中，因为第一个日程安排并不包含时间 20 ++ +
+ +
+ +
提示：
+ +MyCalendar.book 函数最多不超过 1000次。0 <= start < end <= 109+ +
注意：本题与主站 729 题相同： https://leetcode-cn.com/problems/my-calendar-i/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 059.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\254\254 K \345\244\247\345\205\203\347\264\240.md" "b/AllProblems/LCR 059.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\254\254 K \345\244\247\345\205\203\347\264\240.md" new file mode 100644 index 00000000000..73b566825a5 --- /dev/null +++ "b/AllProblems/LCR 059.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\347\254\254 K \345\244\247\345\205\203\347\264\240.md" @@ -0,0 +1,58 @@ +--- +title: LCR 059.数据流中的第 K 大元素 +date: 2023-10-10 14-42-59 +tags: [题解, LeetCode, 简单, 树, 设计, 二叉搜索树, 二叉树, 数据流, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 059.数据流中的第 K 大元素 + +力扣题目链接：[https://leetcode.cn/problems/jBjn9C/](https://leetcode.cn/problems/jBjn9C/) + +设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。
请实现 KthLargest 类：
KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。+ +
示例：
+ ++输入： +["KthLargest", "add", "add", "add", "add", "add"] +[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]] +输出： +[null, 4, 5, 5, 8, 8] + +解释： +KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]); +kthLargest.add(3); // return 4 +kthLargest.add(5); // return 5 +kthLargest.add(10); // return 5 +kthLargest.add(9); // return 8 +kthLargest.add(4); // return 8 ++ +
+ +
提示：
+ +1 <= k <= 1040 <= nums.length <= 104-104 <= nums[i] <= 104-104 <= val <= 104add 方法 104 次k 大元素时，数组中至少有 k 个元素+ +
注意：本题与主站 703 题相同： https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 060.\345\211\215 K \344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md" "b/AllProblems/LCR 060.\345\211\215 K \344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md" new file mode 100644 index 00000000000..192b83c12b9 --- /dev/null +++ "b/AllProblems/LCR 060.\345\211\215 K \344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md" @@ -0,0 +1,47 @@ +--- +title: LCR 060.前 K 个高频元素 +date: 2023-10-10 14-42-59 +tags: [题解, LeetCode, 中等, 数组, 哈希表, 分治, 桶排序, 计数, 快速选择, 排序, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 060.前 K 个高频元素 + +力扣题目链接：[https://leetcode.cn/problems/g5c51o/](https://leetcode.cn/problems/g5c51o/) + +给定一个整数数组 nums 和一个整数 k ，请返回其中出现频率前 k 高的元素。可以按 任意顺序 返回答案。
+ +
示例 1:
+ ++输入: nums = [1,1,1,2,2,3], k = 2 +输出: [1,2] ++ +
示例 2:
+ ++输入: nums = [1], k = 1 +输出: [1]+ +
+ +
提示：
+ +1 <= nums.length <= 105k 的取值范围是 [1, 数组中不相同的元素的个数]k 个高频元素的集合是唯一的+ +
进阶：所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
+ +
注意：本题与主站 347 题相同：https://leetcode-cn.com/problems/top-k-frequent-elements/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 061.\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/AllProblems/LCR 061.\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 00000000000..5dc46790acb --- /dev/null +++ "b/AllProblems/LCR 061.\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,61 @@ +--- +title: LCR 061.查找和最小的 K 对数字 +date: 2023-10-10 14-43-00 +tags: [题解, LeetCode, 中等, 数组, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 061.查找和最小的 K 对数字 + +力扣题目链接：[https://leetcode.cn/problems/qn8gGX/](https://leetcode.cn/problems/qn8gGX/) + +给定两个以升序排列的整数数组 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 <= 104-109 <= nums1[i], nums2[i] <= 109nums1, nums2 均为升序排列1 <= k <= 1000+ +
注意：本题与主站 373 题相同：https://leetcode-cn.com/problems/find-k-pairs-with-smallest-sums/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 062.\345\256\236\347\216\260 Trie (\345\211\215\347\274\200\346\240\221).md" "b/AllProblems/LCR 062.\345\256\236\347\216\260 Trie (\345\211\215\347\274\200\346\240\221).md" new file mode 100644 index 00000000000..6c18549ba3b --- /dev/null +++ "b/AllProblems/LCR 062.\345\256\236\347\216\260 Trie (\345\211\215\347\274\200\346\240\221).md" @@ -0,0 +1,60 @@ +--- +title: LCR 062.实现 Trie (前缀树) +date: 2023-10-10 14-43-00 +tags: [题解, LeetCode, 中等, 设计, 字典树, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 062.实现 Trie (前缀树) + +力扣题目链接：[https://leetcode.cn/problems/QC3q1f/](https://leetcode.cn/problems/QC3q1f/) + +Trie（发音类似 "try"）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
+ +请你实现 Trie 类：
+ +Trie() 初始化前缀树对象。void insert(String word) 向前缀树中插入字符串 word 。boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。+ +
示例：
+ +
+输入
+inputs = ["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
+inputs = [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
+输出
+[null, null, true, false, true, null, true]
+
+解释
+Trie trie = new Trie();
+trie.insert("apple");
+trie.search("apple"); // 返回 True
+trie.search("app"); // 返回 False
+trie.startsWith("app"); // 返回 True
+trie.insert("app");
+trie.search("app"); // 返回 True
+
+
++ +
提示：
+ +1 <= word.length, prefix.length <= 2000word 和 prefix 仅由小写英文字母组成insert、search 和 startsWith 调用次数 总计 不超过 3 * 104 次+ +
+ +
注意：本题与主站 208 题相同：https://leetcode-cn.com/problems/implement-trie-prefix-tree/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 063.\345\215\225\350\257\215\346\233\277\346\215\242.md" "b/AllProblems/LCR 063.\345\215\225\350\257\215\346\233\277\346\215\242.md" new file mode 100644 index 00000000000..28bff664a7a --- /dev/null +++ "b/AllProblems/LCR 063.\345\215\225\350\257\215\346\233\277\346\215\242.md" @@ -0,0 +1,75 @@ +--- +title: LCR 063.单词替换 +date: 2023-10-10 14-43-01 +tags: [题解, LeetCode, 中等, 字典树, 数组, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 063.单词替换 + +力扣题目链接：[https://leetcode.cn/problems/UhWRSj/](https://leetcode.cn/problems/UhWRSj/) + +在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。
现在，给定一个由许多词根组成的词典和一个句子，需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。
需要输出替换之后的句子。
+ ++ +
示例 1：
+ ++输入：dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery" +输出："the cat was rat by the bat" ++ +
示例 2：
+ ++输入：dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs" +输出："a a b c" ++ +
示例 3：
+ ++输入：dictionary = ["a", "aa", "aaa", "aaaa"], sentence = "a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa" +输出："a a a a a a a a bbb baba a" ++ +
示例 4：
+ ++输入：dictionary = ["catt","cat","bat","rat"], sentence = "the cattle was rattled by the battery" +输出："the cat was rat by the bat" ++ +
示例 5：
+ ++输入：dictionary = ["ac","ab"], sentence = "it is abnormal that this solution is accepted" +输出："it is ab that this solution is ac" ++ +
+ +
提示：
+ +1 <= dictionary.length <= 10001 <= dictionary[i].length <= 100dictionary[i] 仅由小写字母组成。1 <= sentence.length <= 10^6sentence 仅由小写字母和空格组成。sentence 中单词的总量在范围 [1, 1000] 内。sentence 中每个单词的长度在范围 [1, 1000] 内。sentence 中单词之间由一个空格隔开。sentence 没有前导或尾随空格。+ +
注意：本题与主站 648 题相同： https://leetcode-cn.com/problems/replace-words/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 064.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" "b/AllProblems/LCR 064.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" new file mode 100644 index 00000000000..cc26526158d --- /dev/null +++ "b/AllProblems/LCR 064.\345\256\236\347\216\260\344\270\200\344\270\252\351\255\224\346\263\225\345\255\227\345\205\270.md" @@ -0,0 +1,67 @@ +--- +title: LCR 064.实现一个魔法字典 +date: 2023-10-10 14-43-01 +tags: [题解, LeetCode, 中等, 深度优先搜索, 设计, 字典树, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 064.实现一个魔法字典 + +力扣题目链接：[https://leetcode.cn/problems/US1pGT/](https://leetcode.cn/problems/US1pGT/) + +设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。
+ +实现 MagicDictionary 类：
MagicDictionary() 初始化对象void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中 一个 字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 true ；否则，返回 false 。+ +
示例：
+ +
+输入
+inputs = ["MagicDictionary", "buildDict", "search", "search", "search", "search"]
+inputs = [[], [["hello", "leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]
+输出
+[null, null, false, true, false, false]
+
+解释
+MagicDictionary magicDictionary = new MagicDictionary();
+magicDictionary.buildDict(["hello", "leetcode"]);
+magicDictionary.search("hello"); // 返回 False
+magicDictionary.search("hhllo"); // 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True
+magicDictionary.search("hell"); // 返回 False
+magicDictionary.search("leetcoded"); // 返回 False
+
+
++ +
提示：
+ +1 <= dictionary.length <= 1001 <= dictionary[i].length <= 100dictionary[i] 仅由小写英文字母组成dictionary 中的所有字符串 互不相同1 <= searchWord.length <= 100searchWord 仅由小写英文字母组成buildDict 仅在 search 之前调用一次100 次 search+ +
注意：本题与主站 676 题相同： https://leetcode-cn.com/problems/implement-magic-dictionary/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 065.\345\215\225\350\257\215\347\232\204\345\216\213\347\274\251\347\274\226\347\240\201.md" "b/AllProblems/LCR 065.\345\215\225\350\257\215\347\232\204\345\216\213\347\274\251\347\274\226\347\240\201.md" new file mode 100644 index 00000000000..93fd5449957 --- /dev/null +++ "b/AllProblems/LCR 065.\345\215\225\350\257\215\347\232\204\345\216\213\347\274\251\347\274\226\347\240\201.md" @@ -0,0 +1,57 @@ +--- +title: LCR 065.单词的压缩编码 +date: 2023-10-10 14-43-02 +tags: [题解, LeetCode, 中等, 字典树, 数组, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 065.单词的压缩编码 + +力扣题目链接：[https://leetcode.cn/problems/iSwD2y/](https://leetcode.cn/problems/iSwD2y/) + +单词数组 words 的 有效编码 由任意助记字符串 s 和下标数组 indices 组成，且满足：
words.length == indices.lengths 以 '#' 字符结尾indices[i] ，s 的一个从 indices[i] 开始、到下一个 '#' 字符结束（但不包括 '#'）的 子字符串 恰好与 words[i] 相等给定一个单词数组 words ，返回成功对 words 进行编码的最小助记字符串 s 的长度 。
+ +
示例 1：
+ +
+输入：words = ["time", "me", "bell"]
+输出：10
+解释：一组有效编码为 s = "time#bell#" 和 indices = [0, 2, 5] 。
+words[0] = "time" ，s 开始于 indices[0] = 0 到下一个 '#' 结束的子字符串，如加粗部分所示 "time#bell#"
+words[1] = "me" ，s 开始于 indices[1] = 2 到下一个 '#' 结束的子字符串，如加粗部分所示 "time#bell#"
+words[2] = "bell" ，s 开始于 indices[2] = 5 到下一个 '#' 结束的子字符串，如加粗部分所示 "time#bell#"
+
+
+示例 2：
+ ++输入：words = ["t"] +输出：2 +解释：一组有效编码为 s = "t#" 和 indices = [0] 。 ++ +
+ +
提示：
+ +1 <= words.length <= 20001 <= words[i].length <= 7words[i] 仅由小写字母组成+ +
注意：本题与主站 820 题相同： https://leetcode-cn.com/problems/short-encoding-of-words/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 066. \351\224\256\345\200\274\346\230\240\345\260\204.md" "b/AllProblems/LCR 066. \351\224\256\345\200\274\346\230\240\345\260\204.md" new file mode 100644 index 00000000000..ad188f72fe4 --- /dev/null +++ "b/AllProblems/LCR 066. \351\224\256\345\200\274\346\230\240\345\260\204.md" @@ -0,0 +1,54 @@ +--- +title: LCR 066. 键值映射 +date: 2023-10-10 14-43-02 +tags: [题解, LeetCode, 中等, 设计, 字典树, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 066. 键值映射 + +力扣题目链接：[https://leetcode.cn/problems/z1R5dt/](https://leetcode.cn/problems/z1R5dt/) + +实现一个 MapSum 类，支持两个方法，insert 和 sum：
MapSum() 初始化 MapSum 对象void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键 key 已经存在，那么原来的键值对将被替代成新的键值对。int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。+ +
示例：
+ +
+输入：
+inputs = ["MapSum", "insert", "sum", "insert", "sum"]
+inputs = [[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
+输出：
+[null, null, 3, null, 5]
+
+解释：
+MapSum mapSum = new MapSum();
+mapSum.insert("apple", 3);
+mapSum.sum("ap"); // return 3 (apple = 3)
+mapSum.insert("app", 2);
+mapSum.sum("ap"); // return 5 (apple + app = 3 + 2 = 5)
+
+
++ +
提示：
+ +1 <= key.length, prefix.length <= 50key 和 prefix 仅由小写英文字母组成1 <= val <= 100050 次 insert 和 sum+ +
注意：本题与主站 677 题相同： https://leetcode-cn.com/problems/map-sum-pairs/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 067.\346\225\260\347\273\204\344\270\255\344\270\244\344\270\252\346\225\260\347\232\204\346\234\200\345\244\247\345\274\202\346\210\226\345\200\274.md" "b/AllProblems/LCR 067.\346\225\260\347\273\204\344\270\255\344\270\244\344\270\252\346\225\260\347\232\204\346\234\200\345\244\247\345\274\202\346\210\226\345\200\274.md" new file mode 100644 index 00000000000..b465d3747d7 --- /dev/null +++ "b/AllProblems/LCR 067.\346\225\260\347\273\204\344\270\255\344\270\244\344\270\252\346\225\260\347\232\204\346\234\200\345\244\247\345\274\202\346\210\226\345\200\274.md" @@ -0,0 +1,72 @@ +--- +title: LCR 067.数组中两个数的最大异或值 +date: 2023-10-10 14-43-03 +tags: [题解, LeetCode, 中等, 位运算, 字典树, 数组, 哈希表] +--- + +# 【LetMeFly】LCR 067.数组中两个数的最大异或值 + +力扣题目链接：[https://leetcode.cn/problems/ms70jA/](https://leetcode.cn/problems/ms70jA/) + +给定一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
+ +
示例 1：
+ ++输入：nums = [3,10,5,25,2,8] +输出：28 +解释：最大运算结果是 5 XOR 25 = 28.+ +
示例 2：
+ ++输入：nums = [0] +输出：0 ++ +
示例 3：
+ ++输入：nums = [2,4] +输出：6 ++ +
示例 4：
+ ++输入：nums = [8,10,2] +输出：10 ++ +
示例 5：
+ ++输入：nums = [14,70,53,83,49,91,36,80,92,51,66,70] +输出：127 ++ +
+ +
提示：
+ +1 <= nums.length <= 2 * 1050 <= nums[i] <= 231 - 1+ +
进阶：你可以在 O(n) 的时间解决这个问题吗？
+ +
注意：本题与主站 421 题相同： https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 068.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md" "b/AllProblems/LCR 068.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md" new file mode 100644 index 00000000000..d9166f42370 --- /dev/null +++ "b/AllProblems/LCR 068.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md" @@ -0,0 +1,68 @@ +--- +title: LCR 068.搜索插入位置 +date: 2023-10-10 14-43-03 +tags: [题解, LeetCode, 简单, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 068.搜索插入位置 + +力扣题目链接：[https://leetcode.cn/problems/N6YdxV/](https://leetcode.cn/problems/N6YdxV/) + +给定一个排序的整数数组 nums 和一个整数目标值 target ，请在数组中找到 target ，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
+ +
示例 1:
+ ++输入: nums = [1,3,5,6], target = 5 +输出: 2 ++ +
示例 2:
+ ++输入: nums = [1,3,5,6], target = 2 +输出: 1 ++ +
示例 3:
+ ++输入: nums = [1,3,5,6], target = 7 +输出: 4 ++ +
示例 4:
+ ++输入: nums = [1,3,5,6], target = 0 +输出: 0 ++ +
示例 5:
+ ++输入: nums = [1], target = 0 +输出: 0 ++ +
+ +
提示:
+ +1 <= nums.length <= 104-104 <= nums[i] <= 104nums 为无重复元素的升序排列数组-104 <= target <= 104+ +
注意：本题与主站 35 题相同： https://leetcode-cn.com/problems/search-insert-position/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 069.\345\261\261\350\204\211\346\225\260\347\273\204\347\232\204\345\263\260\351\241\266\347\264\242\345\274\225.md" "b/AllProblems/LCR 069.\345\261\261\350\204\211\346\225\260\347\273\204\347\232\204\345\263\260\351\241\266\347\264\242\345\274\225.md" new file mode 100644 index 00000000000..8ed1ea53a25 --- /dev/null +++ "b/AllProblems/LCR 069.\345\261\261\350\204\211\346\225\260\347\273\204\347\232\204\345\263\260\351\241\266\347\264\242\345\274\225.md" @@ -0,0 +1,81 @@ +--- +title: LCR 069.山脉数组的峰顶索引 +date: 2023-10-10 14-43-04 +tags: [题解, LeetCode, 简单, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 069.山脉数组的峰顶索引 + +力扣题目链接：[https://leetcode.cn/problems/B1IidL/](https://leetcode.cn/problems/B1IidL/) + +符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：
arr.length >= 3i（0 < i < arr.length - 1）使得：
+ arr[0] < arr[1] < ... arr[i-1] < arr[i] arr[i] > arr[i+1] > ... > arr[arr.length - 1]给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。
+ +
示例 1：
+ ++输入：arr = [0,1,0] +输出：1 ++ +
示例 2：
+ ++输入：arr = [1,3,5,4,2] +输出：2 ++ +
示例 3：
+ ++输入：arr = [0,10,5,2] +输出：1 ++ +
示例 4：
+ ++输入：arr = [3,4,5,1] +输出：2 ++ +
示例 5：
+ ++输入：arr = [24,69,100,99,79,78,67,36,26,19] +输出：2 ++ +
+ +
提示：
+ +3 <= arr.length <= 1040 <= arr[i] <= 106arr 是一个山脉数组+ +
进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(n)) 的解决方案吗？
+ +
注意：本题与主站 852 题相同：https://leetcode-cn.com/problems/peak-index-in-a-mountain-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 070.\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\345\215\225\344\270\200\345\205\203\347\264\240.md" "b/AllProblems/LCR 070.\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\345\215\225\344\270\200\345\205\203\347\264\240.md" new file mode 100644 index 00000000000..1f40541248c --- /dev/null +++ "b/AllProblems/LCR 070.\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\345\215\225\344\270\200\345\205\203\347\264\240.md" @@ -0,0 +1,51 @@ +--- +title: LCR 070.有序数组中的单一元素 +date: 2023-10-10 14-43-04 +tags: [题解, LeetCode, 中等, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 070.有序数组中的单一元素 + +力扣题目链接：[https://leetcode.cn/problems/skFtm2/](https://leetcode.cn/problems/skFtm2/) + +给定一个只包含整数的有序数组 nums ，每个元素都会出现两次，唯有一个数只会出现一次，请找出这个唯一的数字。
+ +
示例 1:
+ ++输入: nums = [1,1,2,3,3,4,4,8,8] +输出: 2 ++ +
示例 2:
+ ++输入: nums = [3,3,7,7,10,11,11] +输出: 10 ++ +
+ +
+ + + +
提示:
+ +1 <= nums.length <= 1050 <= nums[i] <= 105+ +
进阶: 采用的方案可以在 O(log n) 时间复杂度和 O(1) 空间复杂度中运行吗？
+ +
注意：本题与主站 540 题相同：https://leetcode-cn.com/problems/single-element-in-a-sorted-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 071.\346\214\211\346\235\203\351\207\215\351\232\217\346\234\272\351\200\211\346\213\251.md" "b/AllProblems/LCR 071.\346\214\211\346\235\203\351\207\215\351\232\217\346\234\272\351\200\211\346\213\251.md" new file mode 100644 index 00000000000..9d974bc9267 --- /dev/null +++ "b/AllProblems/LCR 071.\346\214\211\346\235\203\351\207\215\351\232\217\346\234\272\351\200\211\346\213\251.md" @@ -0,0 +1,75 @@ +--- +title: LCR 071.按权重随机选择 +date: 2023-10-10 14-43-05 +tags: [题解, LeetCode, 中等, 数组, 数学, 二分查找, 前缀和, 随机化] +--- + +# 【LetMeFly】LCR 071.按权重随机选择 + +力扣题目链接：[https://leetcode.cn/problems/cuyjEf/](https://leetcode.cn/problems/cuyjEf/) + +给定一个正整数数组 w ，其中 w[i] 代表下标 i 的权重（下标从 0 开始），请写一个函数 pickIndex ，它可以随机地获取下标 i，选取下标 i 的概率与 w[i] 成正比。
例如，对于 w = [1, 3]，挑选下标 0 的概率为 1 / (1 + 3) = 0.25 （即，25%），而选取下标 1 的概率为 3 / (1 + 3) = 0.75（即，75%）。
也就是说，选取下标 i 的概率为 w[i] / sum(w) 。
+ +
示例 1：
+ ++输入： +inputs = ["Solution","pickIndex"] +inputs = [[[1]],[]] +输出： +[null,0] +解释： +Solution solution = new Solution([1]); +solution.pickIndex(); // 返回 0，因为数组中只有一个元素，所以唯一的选择是返回下标 0。+ +
示例 2：
+ ++输入： +inputs = ["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"] +inputs = [[[1,3]],[],[],[],[],[]] +输出： +[null,1,1,1,1,0] +解释： +Solution solution = new Solution([1, 3]); +solution.pickIndex(); // 返回 1，返回下标 1，返回该下标概率为 3/4 。 +solution.pickIndex(); // 返回 1 +solution.pickIndex(); // 返回 1 +solution.pickIndex(); // 返回 1 +solution.pickIndex(); // 返回 0，返回下标 0，返回该下标概率为 1/4 。 + +由于这是一个随机问题，允许多个答案，因此下列输出都可以被认为是正确的: +[null,1,1,1,1,0] +[null,1,1,1,1,1] +[null,1,1,1,0,0] +[null,1,1,1,0,1] +[null,1,0,1,0,0] +...... +诸若此类。 ++ +
+ +
提示：
+ +1 <= w.length <= 100001 <= w[i] <= 10^5pickIndex 将被调用不超过 10000 次+ +
注意：本题与主站 528 题相同： https://leetcode-cn.com/problems/random-pick-with-weight/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 072.x \347\232\204\345\271\263\346\226\271\346\240\271.md" "b/AllProblems/LCR 072.x \347\232\204\345\271\263\346\226\271\346\240\271.md" new file mode 100644 index 00000000000..e18b85594b6 --- /dev/null +++ "b/AllProblems/LCR 072.x \347\232\204\345\271\263\346\226\271\346\240\271.md" @@ -0,0 +1,47 @@ +--- +title: LCR 072.x 的平方根 +date: 2023-10-10 14-43-05 +tags: [题解, LeetCode, 简单, 数学, 二分查找] +--- + +# 【LetMeFly】LCR 072.x 的平方根 + +力扣题目链接：[https://leetcode.cn/problems/jJ0w9p/](https://leetcode.cn/problems/jJ0w9p/) + +给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
+ +如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。
+ ++ +
示例 1:
+ ++输入: x = 4 +输出: 2 ++ +
示例 2:
+ ++输入: x = 8 +输出: 2 +解释: 8 的平方根是 2.82842...，由于小数部分将被舍去，所以返回 2 ++ +
+ +
提示:
+ +0 <= x <= 231 - 1+ +
注意：本题与主站 69 题相同： https://leetcode-cn.com/problems/sqrtx/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 073.\347\210\261\345\220\203\351\246\231\350\225\211\347\232\204\347\213\222\347\213\222.md" "b/AllProblems/LCR 073.\347\210\261\345\220\203\351\246\231\350\225\211\347\232\204\347\213\222\347\213\222.md" new file mode 100644 index 00000000000..76ec2cda7b8 --- /dev/null +++ "b/AllProblems/LCR 073.\347\210\261\345\220\203\351\246\231\350\225\211\347\232\204\347\213\222\347\213\222.md" @@ -0,0 +1,60 @@ +--- +title: LCR 073.爱吃香蕉的狒狒 +date: 2023-10-10 14-43-06 +tags: [题解, LeetCode, 中等, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 073.爱吃香蕉的狒狒 + +力扣题目链接：[https://leetcode.cn/problems/nZZqjQ/](https://leetcode.cn/problems/nZZqjQ/) + +狒狒喜欢吃香蕉。这里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。
狒狒可以决定她吃香蕉的速度 K （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 K 根。如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉，下一个小时才会开始吃另一堆的香蕉。
狒狒喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。
+ +返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。
+ +
示例 1：
+ ++输入: piles = [3,6,7,11], H = 8 +输出: 4 ++ +
示例 2：
+ ++输入: piles = [30,11,23,4,20], H = 5 +输出: 30 ++ +
示例 3：
+ ++输入: piles = [30,11,23,4,20], H = 6 +输出: 23 ++ +
+ +
提示：
+ +1 <= piles.length <= 10^4piles.length <= H <= 10^91 <= piles[i] <= 10^9+ +
注意：本题与主站 875 题相同： https://leetcode-cn.com/problems/koko-eating-bananas/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 074.\345\220\210\345\271\266\345\214\272\351\227\264.md" "b/AllProblems/LCR 074.\345\220\210\345\271\266\345\214\272\351\227\264.md" new file mode 100644 index 00000000000..71cc7a77ffd --- /dev/null +++ "b/AllProblems/LCR 074.\345\220\210\345\271\266\345\214\272\351\227\264.md" @@ -0,0 +1,45 @@ +--- +title: LCR 074.合并区间 +date: 2023-10-10 14-43-06 +tags: [题解, LeetCode, 中等, 数组, 排序] +--- + +# 【LetMeFly】LCR 074.合并区间 + +力扣题目链接：[https://leetcode.cn/problems/SsGoHC/](https://leetcode.cn/problems/SsGoHC/) + +以数组 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 <= 104intervals[i].length == 20 <= starti <= endi <= 104+ +
注意：本题与主站 56 题相同： https://leetcode-cn.com/problems/merge-intervals/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 075.\346\225\260\347\273\204\347\232\204\347\233\270\345\257\271\346\216\222\345\272\217.md" "b/AllProblems/LCR 075.\346\225\260\347\273\204\347\232\204\347\233\270\345\257\271\346\216\222\345\272\217.md" new file mode 100644 index 00000000000..27f0cf98177 --- /dev/null +++ "b/AllProblems/LCR 075.\346\225\260\347\273\204\347\232\204\347\233\270\345\257\271\346\216\222\345\272\217.md" @@ -0,0 +1,45 @@ +--- +title: LCR 075.数组的相对排序 +date: 2023-10-10 14-43-06 +tags: [题解, LeetCode, 简单, 数组, 哈希表, 计数排序, 排序] +--- + +# 【LetMeFly】LCR 075.数组的相对排序 + +力扣题目链接：[https://leetcode.cn/problems/0H97ZC/](https://leetcode.cn/problems/0H97ZC/) + +给定两个数组，arr1 和 arr2，
arr2 中的元素各不相同arr2 中的每个元素都出现在 arr1 中对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
+ +
示例：
+ ++输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6] +输出：[2,2,2,1,4,3,3,9,6,7,19] ++ +
+ +
提示：
+ +1 <= arr1.length, arr2.length <= 10000 <= arr1[i], arr2[i] <= 1000arr2 中的元素 arr2[i] 各不相同arr2 中的每个元素 arr2[i] 都出现在 arr1 中+ +
注意：本题与主站 1122 题相同：https://leetcode-cn.com/problems/relative-sort-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 076.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254 K \344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" "b/AllProblems/LCR 076.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254 K \344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" new file mode 100644 index 00000000000..1c4632e3ba1 --- /dev/null +++ "b/AllProblems/LCR 076.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254 K \344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.md" @@ -0,0 +1,44 @@ +--- +title: LCR 076.数组中的第 K 个最大元素 +date: 2023-10-10 14-43-07 +tags: [题解, LeetCode, 中等, 数组, 分治, 快速选择, 排序, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 076.数组中的第 K 个最大元素 + +力扣题目链接：[https://leetcode.cn/problems/xx4gT2/](https://leetcode.cn/problems/xx4gT2/) + +给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
+ +
示例 1:
+ +
+输入: [3,2,1,5,6,4] 和 k = 2
+输出: 5
+
+
+示例 2:
+ +
+输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
+输出: 4
+
++ +
提示：
+ +1 <= k <= nums.length <= 104-104 <= nums[i] <= 104+ +
注意：本题与主站 215 题相同： https://leetcode-cn.com/problems/kth-largest-element-in-an-array/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 077.\346\216\222\345\272\217\351\223\276\350\241\250.md" "b/AllProblems/LCR 077.\346\216\222\345\272\217\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..706c31d17ae --- /dev/null +++ "b/AllProblems/LCR 077.\346\216\222\345\272\217\351\223\276\350\241\250.md" @@ -0,0 +1,61 @@ +--- +title: LCR 077.排序链表 +date: 2023-10-10 14-43-07 +tags: [题解, LeetCode, 中等, 链表, 双指针, 分治, 排序, 归并排序] +--- + +# 【LetMeFly】LCR 077.排序链表 + +力扣题目链接：[https://leetcode.cn/problems/7WHec2/](https://leetcode.cn/problems/7WHec2/) + +给定链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
+ +
示例 1：
+ +
+输入：head = [4,2,1,3] +输出：[1,2,3,4] ++ +
示例 2：
+ +
+输入：head = [-1,5,3,4,0] +输出：[-1,0,3,4,5] ++ +
示例 3：
+ ++输入：head = [] +输出：[] ++ +
+ +
提示：
+ +[0, 5 * 104] 内-105 <= Node.val <= 105+ +
进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
+ +
注意：本题与主站 148 题相同：https://leetcode-cn.com/problems/sort-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 078.\345\220\210\345\271\266 K \344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md" "b/AllProblems/LCR 078.\345\220\210\345\271\266 K \344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..d6c4f82db8e --- /dev/null +++ "b/AllProblems/LCR 078.\345\220\210\345\271\266 K \344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md" @@ -0,0 +1,64 @@ +--- +title: LCR 078.合并 K 个升序链表 +date: 2023-10-10 14-43-08 +tags: [题解, LeetCode, 困难, 链表, 分治, 堆（优先队列）, 归并排序] +--- + +# 【LetMeFly】LCR 078.合并 K 个升序链表 + +力扣题目链接：[https://leetcode.cn/problems/vvXgSW/](https://leetcode.cn/problems/vvXgSW/) + +给定一个链表数组，每个链表都已经按升序排列。
+ +请将所有链表合并到一个升序链表中，返回合并后的链表。
+ ++ +
示例 1：
+ ++输入：lists = [[1,4,5],[1,3,4],[2,6]] +输出：[1,1,2,3,4,4,5,6] +解释：链表数组如下： +[ + 1->4->5, + 1->3->4, + 2->6 +] +将它们合并到一个有序链表中得到。 +1->1->2->3->4->4->5->6 ++ +
示例 2：
+ ++输入：lists = [] +输出：[] ++ +
示例 3：
+ ++输入：lists = [[]] +输出：[] ++ +
+ +
提示：
+ +k == lists.length0 <= k <= 10^40 <= lists[i].length <= 500-10^4 <= lists[i][j] <= 10^4lists[i] 按 升序 排列lists[i].length 的总和不超过 10^4+ +
注意：本题与主站 23 题相同： https://leetcode-cn.com/problems/merge-k-sorted-lists/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 079.\345\255\220\351\233\206.md" "b/AllProblems/LCR 079.\345\255\220\351\233\206.md" new file mode 100644 index 00000000000..14cf9a28480 --- /dev/null +++ "b/AllProblems/LCR 079.\345\255\220\351\233\206.md" @@ -0,0 +1,46 @@ +--- +title: LCR 079.子集 +date: 2023-10-10 14-43-08 +tags: [题解, LeetCode, 中等, 位运算, 数组, 回溯] +--- + +# 【LetMeFly】LCR 079.子集 + +力扣题目链接：[https://leetcode.cn/problems/TVdhkn/](https://leetcode.cn/problems/TVdhkn/) + +给定一个整数数组 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] <= 10nums 中的所有元素 互不相同+ +
注意：本题与主站 78 题相同： https://leetcode-cn.com/problems/subsets/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 080.\347\273\204\345\220\210.md" "b/AllProblems/LCR 080.\347\273\204\345\220\210.md" new file mode 100644 index 00000000000..8d56eda4040 --- /dev/null +++ "b/AllProblems/LCR 080.\347\273\204\345\220\210.md" @@ -0,0 +1,49 @@ +--- +title: LCR 080.组合 +date: 2023-10-10 14-43-09 +tags: [题解, LeetCode, 中等, 数组, 回溯] +--- + +# 【LetMeFly】LCR 080.组合 + +力扣题目链接：[https://leetcode.cn/problems/uUsW3B/](https://leetcode.cn/problems/uUsW3B/) + +给定两个整数 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 <= 201 <= k <= n+ +
注意：本题与主站 77 题相同： https://leetcode-cn.com/problems/combinations/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 081.\347\273\204\345\220\210\346\200\273\345\222\214.md" "b/AllProblems/LCR 081.\347\273\204\345\220\210\346\200\273\345\222\214.md" new file mode 100644 index 00000000000..9ee87e2793d --- /dev/null +++ "b/AllProblems/LCR 081.\347\273\204\345\220\210\346\200\273\345\222\214.md" @@ -0,0 +1,69 @@ +--- +title: LCR 081.组合总和 +date: 2023-10-10 14-43-09 +tags: [题解, LeetCode, 中等, 数组, 回溯] +--- + +# 【LetMeFly】LCR 081.组合总和 + +力扣题目链接：[https://leetcode.cn/problems/Ygoe9J/](https://leetcode.cn/problems/Ygoe9J/) + +给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。
candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的唯一组合数少于 150 个。
+ +
示例 1：
+ ++输入: candidates = [2,3,6,7], target = 7 +输出: [[7],[2,2,3]] ++ +
示例 2：
+ ++输入: candidates = [2,3,5], target = 8 +输出: [[2,2,2,2],[2,3,3],[3,5]]+ +
示例 3：
+ ++输入: candidates = [2], target = 1 +输出: [] ++ +
示例 4：
+ ++输入: candidates = [1], target = 1 +输出: [[1]] ++ +
示例 5：
+ ++输入: candidates = [1], target = 2 +输出: [[1,1]] ++ +
+ +
提示：
+ +1 <= candidates.length <= 301 <= candidates[i] <= 200candidate 中的每个元素都是独一无二的。1 <= target <= 500+ +
注意：本题与主站 39 题相同： https://leetcode-cn.com/problems/combination-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 082.\347\273\204\345\220\210\346\200\273\345\222\214 II.md" "b/AllProblems/LCR 082.\347\273\204\345\220\210\346\200\273\345\222\214 II.md" new file mode 100644 index 00000000000..3fabeb1e786 --- /dev/null +++ "b/AllProblems/LCR 082.\347\273\204\345\220\210\346\200\273\345\222\214 II.md" @@ -0,0 +1,54 @@ +--- +title: LCR 082.组合总和 II +date: 2023-10-10 14-43-09 +tags: [题解, LeetCode, 中等, 数组, 回溯] +--- + +# 【LetMeFly】LCR 082.组合总和 II + +力扣题目链接：[https://leetcode.cn/problems/4sjJUc/](https://leetcode.cn/problems/4sjJUc/) + +给定一个可能有重复数字的整数数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次，解集不能包含重复的组合。
+ +
示例 1:
+ ++输入: candidates =+ +[10,1,2,7,6,1,5], target =8, +输出: +[ +[1,1,6], +[1,2,5], +[1,7], +[2,6] +]
示例 2:
+ ++输入: candidates = [2,5,2,1,2], target = 5, +输出: +[ +[1,2,2], +[5] +]+ +
+ +
提示:
+ +1 <= candidates.length <= 1001 <= candidates[i] <= 501 <= target <= 30+ +
注意：本题与主站 40 题相同： https://leetcode-cn.com/problems/combination-sum-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 083.\345\205\250\346\216\222\345\210\227.md" "b/AllProblems/LCR 083.\345\205\250\346\216\222\345\210\227.md" new file mode 100644 index 00000000000..95c5522c7d9 --- /dev/null +++ "b/AllProblems/LCR 083.\345\205\250\346\216\222\345\210\227.md" @@ -0,0 +1,51 @@ +--- +title: LCR 083.全排列 +date: 2023-10-10 14-43-10 +tags: [题解, LeetCode, 中等, 数组, 回溯] +--- + +# 【LetMeFly】LCR 083.全排列 + +力扣题目链接：[https://leetcode.cn/problems/VvJkup/](https://leetcode.cn/problems/VvJkup/) + +给定一个不含重复数字的整数数组 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] <= 10nums 中的所有整数 互不相同+ +
注意：本题与主站 46 题相同：https://leetcode-cn.com/problems/permutations/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 084.\345\205\250\346\216\222\345\210\227 II .md" "b/AllProblems/LCR 084.\345\205\250\346\216\222\345\210\227 II .md" new file mode 100644 index 00000000000..0e6792c48d4 --- /dev/null +++ "b/AllProblems/LCR 084.\345\205\250\346\216\222\345\210\227 II .md" @@ -0,0 +1,46 @@ +--- +title: LCR 084.全排列 II +date: 2023-10-10 14-43-10 +tags: [题解, LeetCode, 中等, 数组, 回溯] +--- + +# 【LetMeFly】LCR 084.全排列 II + +力扣题目链接：[https://leetcode.cn/problems/7p8L0Z/](https://leetcode.cn/problems/7p8L0Z/) + +给定一个可包含重复数字的整数集合 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+ +
注意：本题与主站 47 题相同： https://leetcode-cn.com/problems/permutations-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 085.\346\213\254\345\217\267\347\224\237\346\210\220.md" "b/AllProblems/LCR 085.\346\213\254\345\217\267\347\224\237\346\210\220.md" new file mode 100644 index 00000000000..47ecfce8f90 --- /dev/null +++ "b/AllProblems/LCR 085.\346\213\254\345\217\267\347\224\237\346\210\220.md" @@ -0,0 +1,42 @@ +--- +title: LCR 085.括号生成 +date: 2023-10-10 14-43-11 +tags: [题解, LeetCode, 中等, 字符串, 动态规划, 回溯] +--- + +# 【LetMeFly】LCR 085.括号生成 + +力扣题目链接：[https://leetcode.cn/problems/IDBivT/](https://leetcode.cn/problems/IDBivT/) + +正整数 n 代表生成括号的对数，请设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
+ +
示例 1：
+ ++输入：n = 3 +输出：["((()))","(()())","(())()","()(())","()()()"] ++ +
示例 2：
+ ++输入：n = 1 +输出：["()"] ++ +
+ +
提示：
+ +1 <= n <= 8+ +
注意：本题与主站 22 题相同： https://leetcode-cn.com/problems/generate-parentheses/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 086.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" "b/AllProblems/LCR 086.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" new file mode 100644 index 00000000000..2236fedbc12 --- /dev/null +++ "b/AllProblems/LCR 086.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" @@ -0,0 +1,51 @@ +--- +title: LCR 086.分割回文串 +date: 2023-10-10 14-43-11 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 图, 哈希表] +--- + +# 【LetMeFly】LCR 086.分割回文串 + +力扣题目链接：[https://leetcode.cn/problems/M99OJA/](https://leetcode.cn/problems/M99OJA/) + +给定一个字符串 s ，请将 s 分割成一些子串，使每个子串都是 回文串 ，返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
+ ++ +
示例 1：
+ ++输入：s = "google" +输出：[["g","o","o","g","l","e"],["g","oo","g","l","e"],["goog","l","e"]] ++ +
示例 2：
+ ++输入：s = "aab" +输出：[["a","a","b"],["aa","b"]] ++ +
示例 3：
+ ++输入：s = "a" +输出：[["a"]]+ +
+ +
提示：
+ +1 <= s.length <= 16s 仅由小写英文字母组成+ +
注意：本题与主站 131 题相同： https://leetcode-cn.com/problems/palindrome-partitioning/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 087.\345\244\215\345\216\237 IP \345\234\260\345\235\200.md" "b/AllProblems/LCR 087.\345\244\215\345\216\237 IP \345\234\260\345\235\200.md" new file mode 100644 index 00000000000..ecb3bb5029a --- /dev/null +++ "b/AllProblems/LCR 087.\345\244\215\345\216\237 IP \345\234\260\345\235\200.md" @@ -0,0 +1,68 @@ +--- +title: LCR 087.复原 IP 地址 +date: 2023-10-10 14-43-12 +tags: [题解, LeetCode, 中等, 字符串, 回溯] +--- + +# 【LetMeFly】LCR 087.复原 IP 地址 + +力扣题目链接：[https://leetcode.cn/problems/0on3uN/](https://leetcode.cn/problems/0on3uN/) + +给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。
+ ++ +
示例 1：
+ ++输入：s = "25525511135" +输出：["255.255.11.135","255.255.111.35"] ++ +
示例 2：
+ ++输入：s = "0000" +输出：["0.0.0.0"] ++ +
示例 3：
+ ++输入：s = "1111" +输出：["1.1.1.1"] ++ +
示例 4：
+ ++输入：s = "010010" +输出：["0.10.0.10","0.100.1.0"] ++ +
示例 5：
+ ++输入：s = "10203040" +输出：["10.20.30.40","102.0.30.40","10.203.0.40"] ++ +
+ +
提示：
+ +0 <= s.length <= 3000s 仅由数字组成+ +
注意：本题与主站 93 题相同：https://leetcode-cn.com/problems/restore-ip-addresses/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 088.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md" "b/AllProblems/LCR 088.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md" new file mode 100644 index 00000000000..625eaaf2d66 --- /dev/null +++ "b/AllProblems/LCR 088.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md" @@ -0,0 +1,49 @@ +--- +title: LCR 088.使用最小花费爬楼梯 +date: 2023-10-10 14-43-12 +tags: [题解, LeetCode, 简单, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 088.使用最小花费爬楼梯 + +力扣题目链接：[https://leetcode.cn/problems/GzCJIP/](https://leetcode.cn/problems/GzCJIP/) + +数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
每当爬上一个阶梯都要花费对应的体力值，一旦支付了相应的体力值，就可以选择向上爬一个阶梯或者爬两个阶梯。
+ +请找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。
+ ++ +
示例 1：
+ ++输入：cost = [10, 15, 20] +输出：15 +解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。 ++ +
示例 2：
+ ++输入：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] +输出：6 +解释：最低花费方式是从 cost[0] 开始，逐个经过那些 1 ，跳过 cost[3] ，一共花费 6 。 ++ +
+ +
提示：
+ +2 <= cost.length <= 10000 <= cost[i] <= 999+ +
注意：本题与主站 746 题相同： https://leetcode-cn.com/problems/min-cost-climbing-stairs/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 089.\346\211\223\345\256\266\345\212\253\350\210\215.md" "b/AllProblems/LCR 089.\346\211\223\345\256\266\345\212\253\350\210\215.md" new file mode 100644 index 00000000000..540dd3ad9a9 --- /dev/null +++ "b/AllProblems/LCR 089.\346\211\223\345\256\266\345\212\253\350\210\215.md" @@ -0,0 +1,48 @@ +--- +title: LCR 089.打家劫舍 +date: 2023-10-10 14-43-13 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 089.打家劫舍 + +力扣题目链接：[https://leetcode.cn/problems/Gu0c2T/](https://leetcode.cn/problems/Gu0c2T/) + +一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响小偷偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+ +给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
+ +
示例 1：
+ ++输入：nums = [1,2,3,1] +输出：4 +解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 + 偷窃到的最高金额 = 1 + 3 = 4 。+ +
示例 2：
+ ++输入：nums = [2,7,9,3,1] +输出：12 +解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 + 偷窃到的最高金额 = 2 + 9 + 1 = 12 。 ++ +
+ +
提示：
+ +1 <= nums.length <= 1000 <= nums[i] <= 400+ +
注意：本题与主站 198 题相同： https://leetcode-cn.com/problems/house-robber/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 090.\346\211\223\345\256\266\345\212\253\350\210\215 II.md" "b/AllProblems/LCR 090.\346\211\223\345\256\266\345\212\253\350\210\215 II.md" new file mode 100644 index 00000000000..615d15d04f7 --- /dev/null +++ "b/AllProblems/LCR 090.\346\211\223\345\256\266\345\212\253\350\210\215 II.md" @@ -0,0 +1,54 @@ +--- +title: LCR 090.打家劫舍 II +date: 2023-10-10 14-43-13 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 090.打家劫舍 II + +力扣题目链接：[https://leetcode.cn/problems/PzWKhm/](https://leetcode.cn/problems/PzWKhm/) + +一个专业的小偷，计划偷窃一个环形街道上沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
+ +给定一个代表每个房屋存放金额的非负整数数组 nums ，请计算 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
+ +
示例 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 = [0] +输出：0 ++ +
+ +
提示：
+ +1 <= nums.length <= 1000 <= nums[i] <= 1000+ +
注意：本题与主站 213 题相同： https://leetcode-cn.com/problems/house-robber-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 091.\347\262\211\345\210\267\346\210\277\345\255\220.md" "b/AllProblems/LCR 091.\347\262\211\345\210\267\346\210\277\345\255\220.md" new file mode 100644 index 00000000000..59cdeb1df2c --- /dev/null +++ "b/AllProblems/LCR 091.\347\262\211\345\210\267\346\210\277\345\255\220.md" @@ -0,0 +1,53 @@ +--- +title: LCR 091.粉刷房子 +date: 2023-10-10 14-43-13 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 091.粉刷房子 + +力扣题目链接：[https://leetcode.cn/problems/JEj789/](https://leetcode.cn/problems/JEj789/) + +假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。
当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的正整数矩阵 costs 来表示的。
例如，costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[1][2] 表示第 1 号房子粉刷成绿色的花费，以此类推。
请计算出粉刷完所有房子最少的花费成本。
+ ++ +
示例 1：
+ ++输入: costs = [[17,2,17],[16,16,5],[14,3,19]] +输出: 10 +解释: 将 0 号房子粉刷成蓝色，1 号房子粉刷成绿色，2 号房子粉刷成蓝色。 + 最少花费: 2 + 5 + 3 = 10。 ++ +
示例 2：
+ ++输入: costs = [[7,6,2]] +输出: 2 ++ +
+ +
提示:
+ +costs.length == ncosts[i].length == 31 <= n <= 1001 <= costs[i][j] <= 20+ +
注意：本题与主站 256 题相同：https://leetcode-cn.com/problems/paint-house/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 092.\345\260\206\345\255\227\347\254\246\344\270\262\347\277\273\350\275\254\345\210\260\345\215\225\350\260\203\351\200\222\345\242\236.md" "b/AllProblems/LCR 092.\345\260\206\345\255\227\347\254\246\344\270\262\347\277\273\350\275\254\345\210\260\345\215\225\350\260\203\351\200\222\345\242\236.md" new file mode 100644 index 00000000000..52af5bb72b4 --- /dev/null +++ "b/AllProblems/LCR 092.\345\260\206\345\255\227\347\254\246\344\270\262\347\277\273\350\275\254\345\210\260\345\215\225\350\260\203\351\200\222\345\242\236.md" @@ -0,0 +1,57 @@ +--- +title: LCR 092.将字符串翻转到单调递增 +date: 2023-10-10 14-43-14 +tags: [题解, LeetCode, 中等, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 092.将字符串翻转到单调递增 + +力扣题目链接：[https://leetcode.cn/problems/cyJERH/](https://leetcode.cn/problems/cyJERH/) + +如果一个由 '0' 和 '1' 组成的字符串，是以一些 '0'（可能没有 '0'）后面跟着一些 '1'（也可能没有 '1'）的形式组成的，那么该字符串是 单调递增 的。
我们给出一个由字符 '0' 和 '1' 组成的字符串 s，我们可以将任何 '0' 翻转为 '1' 或者将 '1' 翻转为 '0'。
返回使 s 单调递增 的最小翻转次数。
+ ++ +
示例 1：
+ ++输入：s = "00110" +输出：1 +解释：我们翻转最后一位得到 00111. ++ +
示例 2：
+ ++输入：s = "010110" +输出：2 +解释：我们翻转得到 011111，或者是 000111。 ++ +
示例 3：
+ ++输入：s = "00011000" +输出：2 +解释：我们翻转得到 00000000。 ++ +
+ +
提示：
+ +1 <= s.length <= 20000'0' 和 '1'+ +
注意：本题与主站 926 题相同： https://leetcode-cn.com/problems/flip-string-to-monotone-increasing/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 093.\346\234\200\351\225\277\347\232\204\346\226\220\346\263\242\351\202\243\345\245\221\345\255\220\345\272\217\345\210\227\347\232\204\351\225\277\345\272\246.md" "b/AllProblems/LCR 093.\346\234\200\351\225\277\347\232\204\346\226\220\346\263\242\351\202\243\345\245\221\345\255\220\345\272\217\345\210\227\347\232\204\351\225\277\345\272\246.md" new file mode 100644 index 00000000000..7544e2f8bac --- /dev/null +++ "b/AllProblems/LCR 093.\346\234\200\351\225\277\347\232\204\346\226\220\346\263\242\351\202\243\345\245\221\345\255\220\345\272\217\345\210\227\347\232\204\351\225\277\345\272\246.md" @@ -0,0 +1,59 @@ +--- +title: LCR 093.最长的斐波那契子序列的长度 +date: 2023-10-10 14-43-14 +tags: [题解, LeetCode, 中等, 数组, 哈希表, 动态规划] +--- + +# 【LetMeFly】LCR 093.最长的斐波那契子序列的长度 + +力扣题目链接：[https://leetcode.cn/problems/Q91FMA/](https://leetcode.cn/problems/Q91FMA/) + +如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：
n >= 3i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回 0 。
（回想一下，子序列是从原序列 arr 中派生出来的，它从 arr 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）
+ +
示例 1：
+ ++输入: arr = [1,2,3,4,5,6,7,8] +输出: 5 +解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。 ++ +
示例 2：
+ ++输入: arr = [1,3,7,11,12,14,18] +输出: 3 +解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。 ++ +
+ +
提示：
+ +3 <= arr.length <= 10001 <= arr[i] < arr[i + 1] <= 10^9
+ +
注意：本题与主站 873 题相同： https://leetcode-cn.com/problems/length-of-longest-fibonacci-subsequence/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 094.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II.md" "b/AllProblems/LCR 094.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II.md" new file mode 100644 index 00000000000..9b2d4edad56 --- /dev/null +++ "b/AllProblems/LCR 094.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262 II.md" @@ -0,0 +1,57 @@ +--- +title: LCR 094.分割回文串 II +date: 2023-10-10 14-43-15 +tags: [题解, LeetCode, 困难, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 094.分割回文串 II + +力扣题目链接：[https://leetcode.cn/problems/omKAoA/](https://leetcode.cn/problems/omKAoA/) + +给定一个字符串 s，请将 s 分割成一些子串，使每个子串都是回文串。
返回符合要求的 最少分割次数 。
+ ++ +
示例 1：
+ ++输入：s = "aab" +输出：1 +解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。 ++ +
示例 2：
+ ++输入：s = "a" +输出：0 ++ +
示例 3：
+ ++输入：s = "ab" +输出：1 ++ +
+ +
提示：
+ +1 <= s.length <= 2000s 仅由小写英文字母组成+ +
注意：本题与主站 132 题相同： https://leetcode-cn.com/problems/palindrome-partitioning-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 095.\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" "b/AllProblems/LCR 095.\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 00000000000..6fd3ad540f9 --- /dev/null +++ "b/AllProblems/LCR 095.\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,61 @@ +--- +title: LCR 095.最长公共子序列 +date: 2023-10-10 14-43-15 +tags: [题解, LeetCode, 中等, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 095.最长公共子序列 + +力扣题目链接：[https://leetcode.cn/problems/qJnOS7/](https://leetcode.cn/problems/qJnOS7/) + +给定两个字符串 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 <= 1000text1 和 text2 仅由小写英文字符组成。+ +
注意：本题与主站 1143 题相同： https://leetcode-cn.com/problems/longest-common-subsequence/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 096.\344\272\244\351\224\231\345\255\227\347\254\246\344\270\262.md" "b/AllProblems/LCR 096.\344\272\244\351\224\231\345\255\227\347\254\246\344\270\262.md" new file mode 100644 index 00000000000..a24838418a6 --- /dev/null +++ "b/AllProblems/LCR 096.\344\272\244\351\224\231\345\255\227\347\254\246\344\270\262.md" @@ -0,0 +1,64 @@ +--- +title: LCR 096.交错字符串 +date: 2023-10-10 14-43-16 +tags: [题解, LeetCode, 中等, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 096.交错字符串 + +力扣题目链接：[https://leetcode.cn/problems/IY6buf/](https://leetcode.cn/problems/IY6buf/) + +给定三个字符串 s1、s2、s3，请判断 s3 能不能由 s1 和 s2 交织（交错） 组成。
两个字符串 s 和 t 交织 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：
s = s1 + s2 + ... + snt = t1 + t2 + ... + tm|n - m| <= 1s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...提示：a + b 意味着字符串 a 和 b 连接。
+ +
示例 1：
+ +
+输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac" +输出：true ++ +
示例 2：
+ ++输入：s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc" +输出：false ++ +
示例 3：
+ ++输入：s1 = "", s2 = "", s3 = "" +输出：true ++ +
+ +
提示：
+ +0 <= s1.length, s2.length <= 1000 <= s3.length <= 200s1、s2、和 s3 都由小写英文字母组成+ +
注意：本题与主站 97 题相同： https://leetcode-cn.com/problems/interleaving-string/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 097.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" "b/AllProblems/LCR 097.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" new file mode 100644 index 00000000000..49bc8389149 --- /dev/null +++ "b/AllProblems/LCR 097.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" @@ -0,0 +1,58 @@ +--- +title: LCR 097.不同的子序列 +date: 2023-10-10 14-43-16 +tags: [题解, LeetCode, 困难, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 097.不同的子序列 + +力扣题目链接：[https://leetcode.cn/problems/21dk04/](https://leetcode.cn/problems/21dk04/) + +给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。
字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）
题目数据保证答案符合 32 位带符号整数范围。
+ ++ +
示例 1：
+ ++输入：s = "rabbbit", t = "rabbit"+ ++输出：3 +解释： +如下图所示, 有 3 种可以从 s 中得到"rabbit" 的方案。 +rabbbit+rabbbit+rabbbit
示例 2：
+ ++输入：s = "babgbag", t = "bag" ++ +输出：5 +解释： +如下图所示, 有 5 种可以从 s 中得到"bag" 的方案。 +babgbag+babgbag+babgbag+babgbag+babgbag+
+ +
提示：
+ +0 <= s.length, t.length <= 1000s 和 t 由英文字母组成+ +
注意：本题与主站 115 题相同： https://leetcode-cn.com/problems/distinct-subsequences/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 098.\344\270\215\345\220\214\350\267\257\345\276\204.md" "b/AllProblems/LCR 098.\344\270\215\345\220\214\350\267\257\345\276\204.md" new file mode 100644 index 00000000000..413bcfa62ae --- /dev/null +++ "b/AllProblems/LCR 098.\344\270\215\345\220\214\350\267\257\345\276\204.md" @@ -0,0 +1,66 @@ +--- +title: LCR 098.不同路径 +date: 2023-10-10 14-43-16 +tags: [题解, LeetCode, 中等, 数学, 动态规划, 组合数学] +--- + +# 【LetMeFly】LCR 098.不同路径 + +力扣题目链接：[https://leetcode.cn/problems/2AoeFn/](https://leetcode.cn/problems/2AoeFn/) + +一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
+ +问总共有多少条不同的路径？
+ ++ +
示例 1：
+ +
+输入：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 <= 1002 * 109+ +
注意：本题与主站 62 题相同： https://leetcode-cn.com/problems/unique-paths/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 099.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" "b/AllProblems/LCR 099.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" new file mode 100644 index 00000000000..50c105aa8e1 --- /dev/null +++ "b/AllProblems/LCR 099.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" @@ -0,0 +1,50 @@ +--- +title: LCR 099.最小路径和 +date: 2023-10-10 14-43-17 +tags: [题解, LeetCode, 中等, 数组, 动态规划, 矩阵] +--- + +# 【LetMeFly】LCR 099.最小路径和 + +力扣题目链接：[https://leetcode.cn/problems/0i0mDW/](https://leetcode.cn/problems/0i0mDW/) + +给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：一个机器人每次只能向下或者向右移动一步。
+ ++ +
示例 1：
+ +
+输入：grid = [[1,3,1],[1,5,1],[4,2,1]] +输出：7 +解释：因为路径 1→3→1→1→1 的总和最小。 ++ +
示例 2：
+ ++输入：grid = [[1,2,3],[4,5,6]] +输出：12 ++ +
+ +
提示：
+ +m == grid.lengthn == grid[i].length1 <= m, n <= 2000 <= grid[i][j] <= 100+ +
注意：本题与主站 64 题相同： https://leetcode-cn.com/problems/minimum-path-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 100.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" "b/AllProblems/LCR 100.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" new file mode 100644 index 00000000000..d10175d1285 --- /dev/null +++ "b/AllProblems/LCR 100.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.md" @@ -0,0 +1,61 @@ +--- +title: LCR 100.三角形最小路径和 +date: 2023-10-10 14-43-17 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 100.三角形最小路径和 + +力扣题目链接：[https://leetcode.cn/problems/IlPe0q/](https://leetcode.cn/problems/IlPe0q/) + +给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
+ +
示例 1：
+ ++输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]] +输出：11 +解释：如下面简图所示： + 2 + 3 4 + 6 5 7 +4 1 8 3 +自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。 ++ +
示例 2：
+ ++输入：triangle = [[-10]] +输出：-10 ++ +
+ +
提示：
+ +1 <= triangle.length <= 200triangle[0].length == 1triangle[i].length == triangle[i - 1].length + 1-104 <= triangle[i][j] <= 104+ +
进阶：
+ +O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？+ +
注意：本题与主站 120 题相同： https://leetcode-cn.com/problems/triangle/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 101.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/AllProblems/LCR 101.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" new file mode 100644 index 00000000000..64b42e88e43 --- /dev/null +++ "b/AllProblems/LCR 101.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" @@ -0,0 +1,46 @@ +--- +title: LCR 101.分割等和子集 +date: 2023-10-10 14-43-18 +tags: [题解, LeetCode, 简单, 数学, 字符串, 模拟] +--- + +# 【LetMeFly】LCR 101.分割等和子集 + +力扣题目链接：[https://leetcode.cn/problems/NUPfPr/](https://leetcode.cn/problems/NUPfPr/) + +给定一个非空的正整数数组 nums ，请判断能否将这些数字分成元素和相等的两部分。
+ +
示例 1：
+ ++输入：nums = [1,5,11,5] +输出：true +解释：nums 可以分割成 [1, 5, 5] 和 [11] 。+ +
示例 2：
+ ++输入：nums = [1,2,3,5] +输出：false +解释：nums 不可以分为和相等的两部分 ++ +
+ + + +
提示：
+ +1 <= nums.length <= 2001 <= nums[i] <= 100+ +
注意：本题与主站 416 题相同： https://leetcode-cn.com/problems/partition-equal-subset-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 102.\347\233\256\346\240\207\345\222\214.md" "b/AllProblems/LCR 102.\347\233\256\346\240\207\345\222\214.md" new file mode 100644 index 00000000000..21fd7e5b45b --- /dev/null +++ "b/AllProblems/LCR 102.\347\233\256\346\240\207\345\222\214.md" @@ -0,0 +1,59 @@ +--- +title: LCR 102.目标和 +date: 2023-10-10 14-43-18 +tags: [题解, LeetCode, 中等, 数组, 动态规划, 回溯] +--- + +# 【LetMeFly】LCR 102.目标和 + +力扣题目链接：[https://leetcode.cn/problems/YaVDxD/](https://leetcode.cn/problems/YaVDxD/) + +给定一个正整数数组 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 <= 200 <= nums[i] <= 10000 <= sum(nums[i]) <= 1000-1000 <= target <= 1000+ +
注意：本题与主站 494 题相同： https://leetcode-cn.com/problems/target-sum/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 103.\351\233\266\351\222\261\345\205\221\346\215\242.md" "b/AllProblems/LCR 103.\351\233\266\351\222\261\345\205\221\346\215\242.md" new file mode 100644 index 00000000000..41c34876dc2 --- /dev/null +++ "b/AllProblems/LCR 103.\351\233\266\351\222\261\345\205\221\346\215\242.md" @@ -0,0 +1,66 @@ +--- +title: LCR 103.零钱兑换 +date: 2023-10-10 14-43-19 +tags: [题解, LeetCode, 中等, 广度优先搜索, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 103.零钱兑换 + +力扣题目链接：[https://leetcode.cn/problems/gaM7Ch/](https://leetcode.cn/problems/gaM7Ch/) + +给定不同面额的硬币 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 ++ +
示例 4：
+ ++输入：coins = [1], amount = 1 +输出：1 ++ +
示例 5：
+ ++输入：coins = [1], amount = 2 +输出：2 ++ +
+ +
提示：
+ +1 <= coins.length <= 121 <= coins[i] <= 231 - 10 <= amount <= 104+ +
注意：本题与主站 322 题相同： https://leetcode-cn.com/problems/coin-change/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 104.\347\273\204\345\220\210\346\200\273\345\222\214 \342\205\243.md" "b/AllProblems/LCR 104.\347\273\204\345\220\210\346\200\273\345\222\214 \342\205\243.md" new file mode 100644 index 00000000000..627e9642845 --- /dev/null +++ "b/AllProblems/LCR 104.\347\273\204\345\220\210\346\200\273\345\222\214 \342\205\243.md" @@ -0,0 +1,61 @@ +--- +title: LCR 104.组合总和 Ⅳ +date: 2023-10-10 14-43-19 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 104.组合总和 Ⅳ + +力扣题目链接：[https://leetcode.cn/problems/D0F0SV/](https://leetcode.cn/problems/D0F0SV/) + +给定一个由 不同 正整数组成的数组 nums ，和一个目标整数 target 。请从 nums 中找出并返回总和为 target 的元素组合的个数。数组中的数字可以在一次排列中出现任意次，但是顺序不同的序列被视作不同的组合。
题目数据保证答案符合 32 位整数范围。
+ ++ +
示例 1：
+ ++输入：nums = [1,2,3], target = 4 +输出：7 +解释： +所有可能的组合为： +(1, 1, 1, 1) +(1, 1, 2) +(1, 2, 1) +(1, 3) +(2, 1, 1) +(2, 2) +(3, 1) +请注意，顺序不同的序列被视作不同的组合。 ++ +
示例 2：
+ ++输入：nums = [9], target = 3 +输出：0 ++ +
+ +
提示：
+ +1 <= nums.length <= 2001 <= nums[i] <= 1000nums 中的所有元素 互不相同1 <= target <= 1000+ +
进阶：如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？
+ ++ +
注意：本题与主站 377 题相同：https://leetcode-cn.com/problems/combination-sum-iv/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 105.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" "b/AllProblems/LCR 105.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" new file mode 100644 index 00000000000..921ec8ef3a0 --- /dev/null +++ "b/AllProblems/LCR 105.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" @@ -0,0 +1,50 @@ +--- +title: LCR 105.岛屿的最大面积 +date: 2023-10-10 14-43-20 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 数组, 矩阵] +--- + +# 【LetMeFly】LCR 105.岛屿的最大面积 + +力扣题目链接：[https://leetcode.cn/problems/ZL6zAn/](https://leetcode.cn/problems/ZL6zAn/) + +给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。
一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
+ +
示例 1:
+ +
+输入: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]] +输出: 6 +解释: 对于上面这个给定矩阵应返回+ +6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的1。
示例 2:
+ ++输入: grid = [[0,0,0,0,0,0,0,0]] +输出: 0+ +
+ +
提示：
+ +m == grid.lengthn == grid[i].length1 <= m, n <= 50grid[i][j] is either 0 or 1+ +
注意：本题与主站 695 题相同： https://leetcode-cn.com/problems/max-area-of-island/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 106.\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.md" "b/AllProblems/LCR 106.\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.md" new file mode 100644 index 00000000000..956648a8cc6 --- /dev/null +++ "b/AllProblems/LCR 106.\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.md" @@ -0,0 +1,65 @@ +--- +title: LCR 106.判断二分图 +date: 2023-10-10 14-43-20 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 图] +--- + +# 【LetMeFly】LCR 106.判断二分图 + +力扣题目链接：[https://leetcode.cn/problems/vEAB3K/](https://leetcode.cn/problems/vEAB3K/) + +存在一个 无向图 ，图中有 n 个节点。其中每个节点都有一个介于 0 到 n - 1 之间的唯一编号。
给定一个二维数组 graph ，表示图，其中 graph[u] 是一个节点数组，由节点 u 的邻接节点组成。形式上，对于 graph[u] 中的每个 v ，都存在一条位于节点 u 和节点 v 之间的无向边。该无向图同时具有以下属性：
graph[u] 不包含 u）。graph[u] 不包含重复值）。v 在 graph[u] 内，那么 u 也应该在 graph[v] 内（该图是无向图）u 和 v 之间可能不存在一条连通彼此的路径。二分图 定义：如果能将一个图的节点集合分割成两个独立的子集 A 和 B ，并使图中的每一条边的两个节点一个来自 A 集合，一个来自 B 集合，就将这个图称为 二分图 。
如果图是二分图，返回 true ；否则，返回 false 。
+ +
示例 1：
+ +
+输入：graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
+输出：false
+解释：不能将节点分割成两个独立的子集，以使每条边都连通一个子集中的一个节点与另一个子集中的一个节点。
+
+示例 2：
+ +
+输入：graph = [[1,3],[0,2],[1,3],[0,2]]
+输出：true
+解释：可以将节点分成两组: {0, 2} 和 {1, 3} 。
+
++ +
提示：
+ +graph.length == n1 <= n <= 1000 <= graph[u].length < n0 <= graph[u][i] <= n - 1graph[u] 不会包含 ugraph[u] 的所有值 互不相同graph[u] 包含 v，那么 graph[v] 也会包含 u+ +
注意：本题与主站 785 题相同： https://leetcode-cn.com/problems/is-graph-bipartite/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 107.01 \347\237\251\351\230\265.md" "b/AllProblems/LCR 107.01 \347\237\251\351\230\265.md" new file mode 100644 index 00000000000..51f0830b5fc --- /dev/null +++ "b/AllProblems/LCR 107.01 \347\237\251\351\230\265.md" @@ -0,0 +1,53 @@ +--- +title: LCR 107.01 矩阵 +date: 2023-10-10 14-43-21 +tags: [题解, LeetCode, 中等, 广度优先搜索, 数组, 动态规划, 矩阵] +--- + +# 【LetMeFly】LCR 107.01 矩阵 + +力扣题目链接：[https://leetcode.cn/problems/2bCMpM/](https://leetcode.cn/problems/2bCMpM/) + +给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。
两个相邻元素间的距离为 1 。
+ +
示例 1：
+ +
+输入：mat = [[0,0,0],[0,1,0],[0,0,0]] +输出：[[0,0,0],[0,1,0],[0,0,0]] ++ +
示例 2：
+ +
+输入：mat = [[0,0,0],[0,1,0],[1,1,1]] +输出：[[0,0,0],[0,1,0],[1,2,1]] ++ +
+ +
提示：
+ +m == mat.lengthn == mat[i].length1 <= m, n <= 1041 <= m * n <= 104mat[i][j] is either 0 or 1.mat 中至少有一个 0 + +
注意：本题与主站 542 题相同：https://leetcode-cn.com/problems/01-matrix/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 108.\345\215\225\350\257\215\346\216\245\351\276\231.md" "b/AllProblems/LCR 108.\345\215\225\350\257\215\346\216\245\351\276\231.md" new file mode 100644 index 00000000000..923d3f792c1 --- /dev/null +++ "b/AllProblems/LCR 108.\345\215\225\350\257\215\346\216\245\351\276\231.md" @@ -0,0 +1,58 @@ +--- +title: LCR 108.单词接龙 +date: 2023-10-10 14-43-21 +tags: [题解, LeetCode, 困难, 广度优先搜索, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 108.单词接龙 + +力扣题目链接：[https://leetcode.cn/problems/om3reC/](https://leetcode.cn/problems/om3reC/) + +在字典（单词列表） wordList 中，从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：
beginWord 。endWord 。wordList 中的单词。给定两个长度相同但内容不同的单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0。
+ +
示例 1：
+ ++输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"] +输出：5 +解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。 ++ +
示例 2：
+ ++输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"] +输出：0 +解释：endWord "cog" 不在字典中，所以无法进行转换。+ +
+ +
提示：
+ +1 <= beginWord.length <= 10endWord.length == beginWord.length1 <= wordList.length <= 5000wordList[i].length == beginWord.lengthbeginWord、endWord 和 wordList[i] 由小写英文字母组成beginWord != endWordwordList 中的所有字符串 互不相同+ +
注意：本题与主站 127 题相同： https://leetcode-cn.com/problems/word-ladder/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 109.\346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" "b/AllProblems/LCR 109.\346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" new file mode 100644 index 00000000000..b23a6b3683c --- /dev/null +++ "b/AllProblems/LCR 109.\346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" @@ -0,0 +1,73 @@ +--- +title: LCR 109.打开转盘锁 +date: 2023-10-10 14-43-22 +tags: [题解, LeetCode, 中等, 广度优先搜索, 数组, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 109.打开转盘锁 + +力扣题目链接：[https://leetcode.cn/problems/zlDJc7/](https://leetcode.cn/problems/zlDJc7/) + +一个密码锁由 4 个环形拨轮组成，每个拨轮都有 10 个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。
字符串 target 代表可以解锁的数字，请给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。
+ +
示例 1:
+ ++输入：deadends = ["0201","0101","0102","1212","2002"], target = "0202" +输出：6 +解释： +可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。 +注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的，因为当拨动到 "0102" 时这个锁就会被锁定。 ++ +
示例 2:
+ ++输入: deadends = ["8888"], target = "0009" +输出：1 +解释： +把最后一位反向旋转一次即可 "0000" -> "0009"。 ++ +
示例 3:
+ ++输入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888" +输出：-1 +解释： +无法旋转到目标数字且不被锁定。 ++ +
示例 4:
+ ++输入: deadends = ["0000"], target = "8888" +输出：-1 ++ +
+ +
提示：
+ +1 <= deadends.length <= 500deadends[i].length == 4target.length == 4target 不在 deadends 之中target 和 deadends[i] 仅由若干位数字组成+ +
注意：本题与主站 752 题相同： https://leetcode-cn.com/problems/open-the-lock/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 110.\346\211\200\346\234\211\345\217\257\350\203\275\347\232\204\350\267\257\345\276\204.md" "b/AllProblems/LCR 110.\346\211\200\346\234\211\345\217\257\350\203\275\347\232\204\350\267\257\345\276\204.md" new file mode 100644 index 00000000000..869f78a7ac4 --- /dev/null +++ "b/AllProblems/LCR 110.\346\211\200\346\234\211\345\217\257\350\203\275\347\232\204\350\267\257\345\276\204.md" @@ -0,0 +1,74 @@ +--- +title: LCR 110.所有可能的路径 +date: 2023-10-10 14-43-22 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 图, 回溯] +--- + +# 【LetMeFly】LCR 110.所有可能的路径 + +力扣题目链接：[https://leetcode.cn/problems/bP4bmD/](https://leetcode.cn/problems/bP4bmD/) + +给定一个有 n 个节点的有向无环图，用二维数组 graph 表示，请找到所有从 0 到 n-1 的路径并输出（不要求按顺序）。
graph 的第 i 个数组中的单元都表示有向图中 i 号节点所能到达的下一些结点（译者注：有向图是有方向的，即规定了 a→b 你就不能从 b→a ），若为空，就是没有下一个节点了。
+ +
示例 1：
+ +
+输入：graph = [[1,2],[3],[3],[]] +输出：[[0,1,3],[0,2,3]] +解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3 ++ +
示例 2：
+ +
+输入：graph = [[4,3,1],[3,2,4],[3],[4],[]] +输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]] ++ +
示例 3：
+ ++输入：graph = [[1],[]] +输出：[[0,1]] ++ +
示例 4：
+ ++输入：graph = [[1,2,3],[2],[3],[]] +输出：[[0,1,2,3],[0,2,3],[0,3]] ++ +
示例 5：
+ ++输入：graph = [[1,3],[2],[3],[]] +输出：[[0,1,2,3],[0,3]] ++ +
+ +
提示：
+ +n == graph.length2 <= n <= 150 <= graph[i][j] < ngraph[i][j] != i (GAD)+ +
注意：本题与主站 797 题相同：https://leetcode-cn.com/problems/all-paths-from-source-to-target/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 111.\351\231\244\346\263\225\346\261\202\345\200\274.md" "b/AllProblems/LCR 111.\351\231\244\346\263\225\346\261\202\345\200\274.md" new file mode 100644 index 00000000000..4c622eeed34 --- /dev/null +++ "b/AllProblems/LCR 111.\351\231\244\346\263\225\346\261\202\345\200\274.md" @@ -0,0 +1,67 @@ +--- +title: LCR 111.除法求值 +date: 2023-10-10 14-43-23 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 图, 数组, 最短路] +--- + +# 【LetMeFly】LCR 111.除法求值 + +力扣题目链接：[https://leetcode.cn/problems/vlzXQL/](https://leetcode.cn/problems/vlzXQL/) + +给定一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。
另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。
返回 所有问题的答案 。如果存在某个无法确定的答案，则用 -1.0 替代这个答案。如果问题中出现了给定的已知条件中没有出现的字符串，也需要用 -1.0 替代这个答案。
注意：输入总是有效的。可以假设除法运算中不会出现除数为 0 的情况，且不存在任何矛盾的结果。
+ ++ +
示例 1：
+ ++输入：equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]] +输出：[6.00000,0.50000,-1.00000,1.00000,-1.00000] +解释： +条件：a / b = 2.0, b / c = 3.0 +问题：a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? +结果：[6.0, 0.5, -1.0, 1.0, -1.0 ] ++ +
示例 2：
+ ++输入：equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]] +输出：[3.75000,0.40000,5.00000,0.20000] ++ +
示例 3：
+ ++输入：equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]] +输出：[0.50000,2.00000,-1.00000,-1.00000] ++ +
+ +
提示：
+ +1 <= equations.length <= 20equations[i].length == 21 <= Ai.length, Bi.length <= 5values.length == equations.length0.0 < values[i] <= 20.01 <= queries.length <= 20queries[i].length == 21 <= Cj.length, Dj.length <= 5Ai, Bi, Cj, Dj 由小写英文字母与数字组成+ +
注意：本题与主站 399 题相同： https://leetcode-cn.com/problems/evaluate-division/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 112.\347\237\251\351\230\265\344\270\255\347\232\204\346\234\200\351\225\277\351\200\222\345\242\236\350\267\257\345\276\204.md" "b/AllProblems/LCR 112.\347\237\251\351\230\265\344\270\255\347\232\204\346\234\200\351\225\277\351\200\222\345\242\236\350\267\257\345\276\204.md" new file mode 100644 index 00000000000..d2ddc73d190 --- /dev/null +++ "b/AllProblems/LCR 112.\347\237\251\351\230\265\344\270\255\347\232\204\346\234\200\351\225\277\351\200\222\345\242\236\350\267\257\345\276\204.md" @@ -0,0 +1,59 @@ +--- +title: LCR 112.矩阵中的最长递增路径 +date: 2023-10-10 14-43-23 +tags: [题解, LeetCode, 困难, 深度优先搜索, 广度优先搜索, 图, 拓扑排序, 记忆化搜索, 数组, 动态规划, 矩阵] +--- + +# 【LetMeFly】LCR 112.矩阵中的最长递增路径 + +力扣题目链接：[https://leetcode.cn/problems/fpTFWP/](https://leetcode.cn/problems/fpTFWP/) + +给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）。
+ ++ +
示例 1：
+ +
+输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
+输出：4
+解释：最长递增路径为 [1, 2, 6, 9]。
+
+示例 2：
+ +
+输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
+输出：4
+解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。
+
+
+示例 3：
+ ++输入：matrix = [[1]] +输出：1 ++ +
+ +
提示：
+ +m == matrix.lengthn == matrix[i].length1 <= m, n <= 2000 <= matrix[i][j] <= 231 - 1+ +
注意：本题与主站 329 题相同： https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 113.\350\257\276\347\250\213\350\241\250 II.md" "b/AllProblems/LCR 113.\350\257\276\347\250\213\350\241\250 II.md" new file mode 100644 index 00000000000..e81ce0b6151 --- /dev/null +++ "b/AllProblems/LCR 113.\350\257\276\347\250\213\350\241\250 II.md" @@ -0,0 +1,62 @@ +--- +title: LCR 113.课程表 II +date: 2023-10-10 14-43-24 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 图, 拓扑排序] +--- + +# 【LetMeFly】LCR 113.课程表 II + +力扣题目链接：[https://leetcode.cn/problems/QA2IGt/](https://leetcode.cn/problems/QA2IGt/) + +现在总共有 numCourses 门课需要选，记为 0 到 numCourses-1。
给定一个数组 prerequisites ，它的每一个元素 prerequisites[i] 表示两门课程之间的先修顺序。 例如 prerequisites[i] = [ai, bi] 表示想要学习课程 ai ，需要先完成课程 bi 。
请根据给出的总课程数 numCourses 和表示先修顺序的 prerequisites 得出一个可行的修课序列。
可能会有多个正确的顺序，只要任意返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
+ ++ +
示例 1:
+ ++输入: numCourses = 2, prerequisites = [[1,0]] +输出:+ +[0,1]+解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为[0,1] 。
示例 2:
+ ++输入: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]] +输出:+ +[0,1,2,3] or [0,2,1,3]+解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。 + 因此，一个正确的课程顺序是[0,1,2,3]。另一个正确的排序是[0,2,1,3]。 +
示例 3:
+ +
+输入: numCourses = 1, prerequisites = []
+输出: [0]
+解释: 总共 1 门课，直接修第一门课就可。
+
++ +
提示:
+ +1 <= numCourses <= 20000 <= prerequisites.length <= numCourses * (numCourses - 1)prerequisites[i].length == 20 <= ai, bi < numCoursesai != biprerequisites 中不存在重复元素+ +
注意：本题与主站 210 题相同：https://leetcode-cn.com/problems/course-schedule-ii/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 114.\347\201\253\346\230\237\350\257\215\345\205\270.md" "b/AllProblems/LCR 114.\347\201\253\346\230\237\350\257\215\345\205\270.md" new file mode 100644 index 00000000000..34e556ae90e --- /dev/null +++ "b/AllProblems/LCR 114.\347\201\253\346\230\237\350\257\215\345\205\270.md" @@ -0,0 +1,63 @@ +--- +title: LCR 114.火星词典 +date: 2023-10-10 14-43-24 +tags: [题解, LeetCode, 困难, 深度优先搜索, 广度优先搜索, 图, 拓扑排序, 数组, 字符串] +--- + +# 【LetMeFly】LCR 114.火星词典 + +力扣题目链接：[https://leetcode.cn/problems/Jf1JuT/](https://leetcode.cn/problems/Jf1JuT/) + +现有一种使用英语字母的外星文语言，这门语言的字母顺序与英语顺序不同。
+ +给定一个字符串列表 words ，作为这门语言的词典，words 中的字符串已经 按这门新语言的字母顺序进行了排序 。
请你根据该词典还原出此语言中已知的字母顺序，并 按字母递增顺序 排列。若不存在合法字母顺序，返回 "" 。若存在多种可能的合法字母顺序，返回其中 任意一种 顺序即可。
字符串 s 字典顺序小于 字符串 t 有两种情况：
s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前，那么 s 的字典顺序小于 t 。min(s.length, t.length) 字母都相同，那么 s.length < t.length 时，s 的字典顺序也小于 t 。+ +
示例 1：
+ ++输入：words = ["wrt","wrf","er","ett","rftt"] +输出："wertf" ++ +
示例 2：
+ ++输入：words = ["z","x"] +输出："zx" ++ +
示例 3：
+ +
+输入：words = ["z","x","z"]
+输出：""
+解释：不存在合法字母顺序，因此返回 "" 。
+
+
++ +
提示：
+ +1 <= words.length <= 1001 <= words[i].length <= 100words[i] 仅由小写英文字母组成+ +
注意：本题与主站 269 题相同： https://leetcode-cn.com/problems/alien-dictionary/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 115.\345\272\217\345\210\227\351\207\215\345\273\272.md" "b/AllProblems/LCR 115.\345\272\217\345\210\227\351\207\215\345\273\272.md" new file mode 100644 index 00000000000..ccc866fa85d --- /dev/null +++ "b/AllProblems/LCR 115.\345\272\217\345\210\227\351\207\215\345\273\272.md" @@ -0,0 +1,77 @@ +--- +title: LCR 115.序列重建 +date: 2023-10-10 14-43-24 +tags: [题解, LeetCode, 中等, 图, 拓扑排序, 数组] +--- + +# 【LetMeFly】LCR 115.序列重建 + +力扣题目链接：[https://leetcode.cn/problems/ur2n8P/](https://leetcode.cn/problems/ur2n8P/) + +给定一个长度为 n 的整数数组 nums ，其中 nums 是范围为 [1，n] 的整数的排列。还提供了一个 2D 整数数组 sequences ，其中 sequences[i] 是 nums 的子序列。
+检查 nums 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列，并且所有序列 sequences[i] 都是它的子序列。对于给定的数组 sequences ，可能存在多个有效的 超序列 。
sequences = [[1,2],[1,3]] ，有两个最短的 超序列 ，[1,2,3] 和 [1,3,2] 。sequences = [[1,2],[1,3],[1,2,3]] ，唯一可能的最短 超序列 是 [1,2,3] 。[1,2,3,4] 是可能的超序列，但不是最短的。如果 nums 是序列的唯一最短 超序列 ，则返回 true ，否则返回 false 。
+子序列 是一个可以通过从另一个序列中删除一些元素或不删除任何元素，而不改变其余元素的顺序的序列。
+ +
示例 1：
+ ++输入：nums = [1,2,3], sequences = [[1,2],[1,3]] +输出：false +解释：有两种可能的超序列：[1,2,3]和[1,3,2]。 +序列 [1,2] 是[1,2,3]和[1,3,2]的子序列。 +序列 [1,3] 是[1,2,3]和[1,3,2]的子序列。 +因为 nums 不是唯一最短的超序列，所以返回false。 ++ +
示例 2：
+ ++输入：nums = [1,2,3], sequences = [[1,2]] +输出：false +解释：最短可能的超序列为 [1,2]。 +序列 [1,2] 是它的子序列：[1,2]。 +因为 nums 不是最短的超序列，所以返回false。 ++ +
示例 3：
+ ++输入：nums = [1,2,3], sequences = [[1,2],[1,3],[2,3]] +输出：true +解释：最短可能的超序列为[1,2,3]。 +序列 [1,2] 是它的一个子序列：[1,2,3]。 +序列 [1,3] 是它的一个子序列：[1,2,3]。 +序列 [2,3] 是它的一个子序列：[1,2,3]。 +因为 nums 是唯一最短的超序列，所以返回true。+ +
+ +
提示：
+ +n == nums.length1 <= n <= 104nums 是 [1, n] 范围内所有整数的排列1 <= sequences.length <= 1041 <= sequences[i].length <= 1041 <= sum(sequences[i].length) <= 1051 <= sequences[i][j] <= nsequences 的所有数组都是 唯一 的sequences[i] 是 nums 的一个子序列+ +
注意：本题与主站 444 题相同：https://leetcode-cn.com/problems/sequence-reconstruction/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 116.\347\234\201\344\273\275\346\225\260\351\207\217.md" "b/AllProblems/LCR 116.\347\234\201\344\273\275\346\225\260\351\207\217.md" new file mode 100644 index 00000000000..422f6220a21 --- /dev/null +++ "b/AllProblems/LCR 116.\347\234\201\344\273\275\346\225\260\351\207\217.md" @@ -0,0 +1,55 @@ +--- +title: LCR 116.省份数量 +date: 2023-10-10 14-43-25 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 图] +--- + +# 【LetMeFly】LCR 116.省份数量 + +力扣题目链接：[https://leetcode.cn/problems/bLyHh0/](https://leetcode.cn/problems/bLyHh0/) + +有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。
省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
+ +给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。
返回矩阵中 省份 的数量。
+ ++ +
示例 1：
+
++输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]] +输出：2 ++ +
示例 2：
+
++输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]] +输出：3 ++ +
+ +
提示：
+ +1 <= n <= 200n == isConnected.lengthn == isConnected[i].lengthisConnected[i][j] 为 1 或 0isConnected[i][i] == 1isConnected[i][j] == isConnected[j][i]+ +
注意：本题与主站 547 题相同： https://leetcode-cn.com/problems/number-of-provinces/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 117.\347\233\270\344\274\274\345\255\227\347\254\246\344\270\262\347\273\204.md" "b/AllProblems/LCR 117.\347\233\270\344\274\274\345\255\227\347\254\246\344\270\262\347\273\204.md" new file mode 100644 index 00000000000..9c17d73a70a --- /dev/null +++ "b/AllProblems/LCR 117.\347\233\270\344\274\274\345\255\227\347\254\246\344\270\262\347\273\204.md" @@ -0,0 +1,53 @@ +--- +title: LCR 117.相似字符串组 +date: 2023-10-10 14-43-25 +tags: [题解, LeetCode, 困难, 深度优先搜索, 广度优先搜索, 并查集, 数组, 哈希表, 字符串] +--- + +# 【LetMeFly】LCR 117.相似字符串组 + +力扣题目链接：[https://leetcode.cn/problems/H6lPxb/](https://leetcode.cn/problems/H6lPxb/) + +如果交换字符串 X 中的两个不同位置的字母，使得它和字符串 Y 相等，那么称 X 和 Y 两个字符串相似。如果这两个字符串本身是相等的，那它们也是相似的。
例如，"tars" 和 "rats" 是相似的 (交换 0 与 2 的位置)； "rats" 和 "arts" 也是相似的，但是 "star" 不与 "tars"，"rats"，或 "arts" 相似。
总之，它们通过相似性形成了两个关联组：{"tars", "rats", "arts"} 和 {"star"}。注意，"tars" 和 "arts" 是在同一组中，即使它们并不相似。形式上，对每个组而言，要确定一个单词在组中，只需要这个词和该组中至少一个单词相似。
给定一个字符串列表 strs。列表中的每个字符串都是 strs 中其它所有字符串的一个 字母异位词 。请问 strs 中有多少个相似字符串组？
字母异位词（anagram），一种把某个字符串的字母的位置（顺序）加以改换所形成的新词。
+ ++ +
示例 1：
+ ++输入：strs = ["tars","rats","arts","star"] +输出：2 ++ +
示例 2：
+ ++输入：strs = ["omv","ovm"] +输出：1 ++ +
+ +
提示：
+ +1 <= strs.length <= 3001 <= strs[i].length <= 300strs[i] 只包含小写字母。strs 中的所有单词都具有相同的长度，且是彼此的字母异位词。+ +
注意：本题与主站 839 题相同：https://leetcode-cn.com/problems/similar-string-groups/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 118.\345\206\227\344\275\231\350\277\236\346\216\245.md" "b/AllProblems/LCR 118.\345\206\227\344\275\231\350\277\236\346\216\245.md" new file mode 100644 index 00000000000..9d57a065e78 --- /dev/null +++ "b/AllProblems/LCR 118.\345\206\227\344\275\231\350\277\236\346\216\245.md" @@ -0,0 +1,56 @@ +--- +title: LCR 118.冗余连接 +date: 2023-10-10 14-43-26 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 并查集, 图] +--- + +# 【LetMeFly】LCR 118.冗余连接 + +力扣题目链接：[https://leetcode.cn/problems/7LpjUW/](https://leetcode.cn/problems/7LpjUW/) + +树可以看成是一个连通且 无环 的 无向 图。
+ +给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。
请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的边。
+ +
示例 1：
+ +
+输入: edges = [[1,2],[1,3],[2,3]] +输出: [2,3] ++ +
示例 2：
+ +
+输入: edges = [[1,2],[2,3],[3,4],[1,4],[1,5]] +输出: [1,4] ++ +
+ +
提示:
+ +n == edges.length3 <= n <= 1000edges[i].length == 21 <= ai < bi <= edges.lengthai != biedges 中无重复元素+ +
注意：本题与主站 684 题相同： https://leetcode-cn.com/problems/redundant-connection/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 119.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" "b/AllProblems/LCR 119.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" new file mode 100644 index 00000000000..d3ceeabe1bc --- /dev/null +++ "b/AllProblems/LCR 119.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" @@ -0,0 +1,47 @@ +--- +title: LCR 119.最长连续序列 +date: 2023-10-10 14-43-26 +tags: [题解, LeetCode, 中等, 并查集, 数组, 哈希表] +--- + +# 【LetMeFly】LCR 119.最长连续序列 + +力扣题目链接：[https://leetcode.cn/problems/WhsWhI/](https://leetcode.cn/problems/WhsWhI/) + +给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
+ +
示例 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 <= 104-109 <= nums[i] <= 109+ +
进阶：可以设计并实现时间复杂度为 O(n) 的解决方案吗？
+ +
注意：本题与主站 128 题相同： https://leetcode-cn.com/problems/longest-consecutive-sequence/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 120.\345\257\273\346\211\276\346\226\207\344\273\266\345\211\257\346\234\254.md" "b/AllProblems/LCR 120.\345\257\273\346\211\276\346\226\207\344\273\266\345\211\257\346\234\254.md" new file mode 100644 index 00000000000..fa22d5cc7f1 --- /dev/null +++ "b/AllProblems/LCR 120.\345\257\273\346\211\276\346\226\207\344\273\266\345\211\257\346\234\254.md" @@ -0,0 +1,34 @@ +--- +title: LCR 120.寻找文件副本 +date: 2023-10-10 14-43-27 +tags: [题解, LeetCode, 简单, 数组, 哈希表, 排序] +--- + +# 【LetMeFly】LCR 120.寻找文件副本 + +力扣题目链接：[https://leetcode.cn/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/](https://leetcode.cn/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/) + +设备中存有 n 个文件，文件 id 记于数组 documents。若文件 id 相同，则定义为该文件存在副本。请返回任一存在副本的文件 id。
+ +
示例 1：
+ ++输入：documents = [2, 5, 3, 0, 5, 0] +输出：0 或 5 ++ +
+ +
提示：
+ +0 ≤ documents[i] ≤ n-12 <= n <= 100000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 121.\345\257\273\346\211\276\347\233\256\346\240\207\345\200\274 - \344\272\214\347\273\264\346\225\260\347\273\204.md" "b/AllProblems/LCR 121.\345\257\273\346\211\276\347\233\256\346\240\207\345\200\274 - \344\272\214\347\273\264\346\225\260\347\273\204.md" new file mode 100644 index 00000000000..474fab61072 --- /dev/null +++ "b/AllProblems/LCR 121.\345\257\273\346\211\276\347\233\256\346\240\207\345\200\274 - \344\272\214\347\273\264\346\225\260\347\273\204.md" @@ -0,0 +1,56 @@ +--- +title: LCR 121.寻找目标值 - 二维数组 +date: 2023-10-10 14-43-27 +tags: [题解, LeetCode, 中等, 数组, 二分查找, 分治, 矩阵] +--- + +# 【LetMeFly】LCR 121.寻找目标值 - 二维数组 + +力扣题目链接：[https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/](https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/) + +
m*n 的二维数组 plants 记录了园林景观的植物排布情况，具有以下特性：
+ +
请判断 plants 中是否存在目标高度值 target。
+ +
示例 1：
+ ++输入：plants = [[2,3,6,8],[4,5,8,9],[5,9,10,12]], target = 8 + +输出：true ++ +
+ +
示例 2：
+ ++输入：plants = [[1,3,5],[2,5,7]], target = 4 + +输出：false ++ +
+ +
提示：
+ +0 <= n <= 10000 <= m <= 1000注意：本题与主站 240 题相同：https://leetcode-cn.com/problems/search-a-2d-matrix-ii/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 122.\350\267\257\345\276\204\345\212\240\345\257\206.md" "b/AllProblems/LCR 122.\350\267\257\345\276\204\345\212\240\345\257\206.md" new file mode 100644 index 00000000000..f4e6c4fe555 --- /dev/null +++ "b/AllProblems/LCR 122.\350\267\257\345\276\204\345\212\240\345\257\206.md" @@ -0,0 +1,31 @@ +--- +title: LCR 122.路径加密 +date: 2023-10-10 14-43-28 +tags: [题解, LeetCode, 简单, 字符串] +--- + +# 【LetMeFly】LCR 122.路径加密 + +力扣题目链接：[https://leetcode.cn/problems/ti-huan-kong-ge-lcof/](https://leetcode.cn/problems/ti-huan-kong-ge-lcof/) + +
假定一段路径记作字符串 path，其中以 "." 作为分隔符。现需将路径加密，加密方法为将 path 中的分隔符替换为空格 " "，请返回加密后的字符串。
+ +
示例 1：
+ ++输入：path = "a.aef.qerf.bb" + +输出："a aef qerf bb" + ++ +
+ +
限制：
+ +0 <= path.length <= 10000
书店店员有一张链表形式的书单，每个节点代表一本书，节点中的值表示书的编号。为更方便整理书架，店员需要将书单倒过来排列，就可以从最后一本书开始整理，逐一将书放回到书架上。请倒序返回这个书单链表。
+ ++ +
示例 1：
+ ++输入：head = [3,6,4,1] + +输出：[1,4,6,3] ++ +
+ +
提示：
+ +0 <= 链表长度 <= 10000
某二叉树的先序遍历结果记录于整数数组 preorder，它的中序遍历结果记录于整数数组 inorder。请根据 preorder 和 inorder 的提示构造出这棵二叉树并返回其根节点。
+ +
注意：preorder 和 inorder 中均不含重复数字。
+ +
示例 1：
+ +
+输入: 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 <= 3000inorder.length == preorder.length-3000 <= preorder[i], inorder[i] <= 3000inorder 均出现在 preorderpreorder 保证 为二叉树的前序遍历序列inorder 保证 为二叉树的中序遍历序列+ +
注意：本题与主站 105 题重复：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 125.\345\233\276\344\271\246\346\225\264\347\220\206 II.md" "b/AllProblems/LCR 125.\345\233\276\344\271\246\346\225\264\347\220\206 II.md" new file mode 100644 index 00000000000..fc827d36b39 --- /dev/null +++ "b/AllProblems/LCR 125.\345\233\276\344\271\246\346\225\264\347\220\206 II.md" @@ -0,0 +1,49 @@ +--- +title: LCR 125.图书整理 II +date: 2023-10-10 14-43-29 +tags: [题解, LeetCode, 简单, 栈, 设计, 队列] +--- + +# 【LetMeFly】LCR 125.图书整理 II + +力扣题目链接：[https://leetcode.cn/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/](https://leetcode.cn/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof/) + +
读者来到图书馆排队借还书，图书管理员使用两个书车来完成整理借还书的任务。书车中的书从下往上叠加存放，图书管理员每次只能拿取书车顶部的书。排队的读者会有两种操作：
+ +push(bookID)：把借阅的书籍还到图书馆。pop()：从图书馆中借出书籍。为了保持图书的顺序，图书管理员每次取出供读者借阅的书籍是 最早 归还到图书馆的书籍。你需要返回 每次读者借出书的值 。
+ +如果没有归还的书可以取出，返回 -1 。
+ +
示例 1：
+ ++输入： +["BookQueue", "push", "push", "pop"] +[[], [1], [2], []] +输出：[null,null,null,1] +解释： +MyQueue myQueue = new MyQueue(); +myQueue.push(1); // queue is: [1] +myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue) +myQueue.pop(); // return 1, queue is [2]+ +
+ +
提示：
+ +1 <= bookID <= 10000push、pop 进行 10000 次调用+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 126.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" "b/AllProblems/LCR 126.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" new file mode 100644 index 00000000000..ace14b792e0 --- /dev/null +++ "b/AllProblems/LCR 126.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" @@ -0,0 +1,59 @@ +--- +title: LCR 126.斐波那契数 +date: 2023-10-10 14-43-30 +tags: [题解, LeetCode, 简单, 记忆化搜索, 数学, 动态规划] +--- + +# 【LetMeFly】LCR 126.斐波那契数 + +力扣题目链接：[https://leetcode.cn/problems/fei-bo-na-qi-shu-lie-lcof/](https://leetcode.cn/problems/fei-bo-na-qi-shu-lie-lcof/) + +
斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
+F(0) = 0，F(1) = 1 +F(n) = F(n - 1) + F(n - 2)，其中 n > 1 ++ +
给定 n ，请计算 F(n) 。
答案需要取模 1e9+7(1000000007) ，如计算初始结果为：1000000008，请返回 1。
+ ++ +
示例 1：
+ ++输入：n = 2 +输出：1 +解释：F(2) = F(1) + F(0) = 1 + 0 = 1 ++ +
示例 2：
+ ++输入：n = 3 +输出：2 +解释：F(3) = F(2) + F(1) = 1 + 1 = 2 ++ +
示例 3：
+ ++输入：n = 4 +输出：3 +解释：F(4) = F(3) + F(2) = 2 + 1 = 3 ++ +
+ +
提示：
+ +0 <= n <= 100+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 127.\350\267\263\350\267\203\350\256\255\347\273\203.md" "b/AllProblems/LCR 127.\350\267\263\350\267\203\350\256\255\347\273\203.md" new file mode 100644 index 00000000000..27eacb1b3ca --- /dev/null +++ "b/AllProblems/LCR 127.\350\267\263\350\267\203\350\256\255\347\273\203.md" @@ -0,0 +1,40 @@ +--- +title: LCR 127.跳跃训练 +date: 2023-10-10 14-43-30 +tags: [题解, LeetCode, 简单, 记忆化搜索, 数学, 动态规划] +--- + +# 【LetMeFly】LCR 127.跳跃训练 + +力扣题目链接：[https://leetcode.cn/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/](https://leetcode.cn/problems/qing-wa-tiao-tai-jie-wen-ti-lcof/) + +
今天的有氧运动训练内容是在一个长条形的平台上跳跃。平台有 num 个小格子，每次可以选择跳 一个格子 或者 两个格子。请返回在训练过程中，学员们共有多少种不同的跳跃方式。
结果可能过大，因此结果需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
+ +示例 1：
+ ++输入：n = 2 +输出：2 ++ +
示例 2：
+ ++输入：n = 5 +输出：8 ++ +
+ +
提示：
+ +0 <= n <= 100注意：本题与主站 70 题相同：https://leetcode-cn.com/problems/climbing-stairs/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 128.\345\272\223\345\255\230\347\256\241\347\220\206 I.md" "b/AllProblems/LCR 128.\345\272\223\345\255\230\347\256\241\347\220\206 I.md" new file mode 100644 index 00000000000..7c91e162607 --- /dev/null +++ "b/AllProblems/LCR 128.\345\272\223\345\255\230\347\256\241\347\220\206 I.md" @@ -0,0 +1,45 @@ +--- +title: LCR 128.库存管理 I +date: 2023-10-10 14-43-30 +tags: [题解, LeetCode, 简单, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 128.库存管理 I + +力扣题目链接：[https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/) + +仓库管理员以数组 stock 形式记录商品库存表。stock[i] 表示商品 id，可能存在重复。原库存表按商品 id 升序排列。现因突发情况需要进行商品紧急调拨，管理员将这批商品 id 提前依次整理至库存表最后。请你找到并返回库存表中编号的 最小的元素 以便及时记录本次调拨。
+ +
示例 1：
+ ++输入：stock = [4,5,8,3,4] +输出：3 ++ +
示例 2：
+ ++输入：stock = [5,7,9,1,2] +输出：1 ++ +
+ +
提示：
+ ++ +
注意：本题与主站 154 题相同：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 129.\345\255\227\346\257\215\350\277\267\345\256\253.md" "b/AllProblems/LCR 129.\345\255\227\346\257\215\350\277\267\345\256\253.md" new file mode 100644 index 00000000000..9447c36ce02 --- /dev/null +++ "b/AllProblems/LCR 129.\345\255\227\346\257\215\350\277\267\345\256\253.md" @@ -0,0 +1,62 @@ +--- +title: LCR 129.字母迷宫 +date: 2023-10-10 14-43-31 +tags: [题解, LeetCode, 中等, 数组, 回溯, 矩阵] +--- + +# 【LetMeFly】LCR 129.字母迷宫 + +力扣题目链接：[https://leetcode.cn/problems/ju-zhen-zhong-de-lu-jing-lcof/](https://leetcode.cn/problems/ju-zhen-zhong-de-lu-jing-lcof/) + +
字母迷宫游戏初始界面记作 m x n 二维字符串数组 grid，请判断玩家是否能在 grid 中找到目标单词 target。
+注意：寻找单词时 必须 按照字母顺序，通过水平或垂直方向相邻的单元格内的字母构成，同时，同一个单元格内的字母 不允许被重复使用 。
+ +
+ +
示例 1：
+ ++输入：grid = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], target = "ABCCED" +输出：true ++ +
示例 2：
+ ++输入：grid = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], target = "SEE" +输出：true ++ +
示例 3：
+ ++输入：grid = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], target = "ABCB" +输出：false ++ +
+ +
提示：
+ +m == grid.lengthn = grid[i].length1 <= m, n <= 61 <= target.length <= 15grid 和 target 仅由大小写英文字母组成+ +
注意：本题与主站 79 题相同：https://leetcode-cn.com/problems/word-search/
+ ++ +
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 130.\350\241\243\346\251\261\346\225\264\347\220\206.md" "b/AllProblems/LCR 130.\350\241\243\346\251\261\346\225\264\347\220\206.md" new file mode 100644 index 00000000000..bdf159d096f --- /dev/null +++ "b/AllProblems/LCR 130.\350\241\243\346\251\261\346\225\264\347\220\206.md" @@ -0,0 +1,38 @@ +--- +title: LCR 130.衣橱整理 +date: 2023-10-10 14-43-31 +tags: [题解, LeetCode, 中等, 深度优先搜索, 广度优先搜索, 动态规划] +--- + +# 【LetMeFly】LCR 130.衣橱整理 + +力扣题目链接：[https://leetcode.cn/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/](https://leetcode.cn/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/) + +
家居整理师将待整理衣橱划分为 m x n 的二维矩阵 grid，其中 grid[i][j] 代表一个需要整理的格子。整理师自 grid[0][0] 开始 逐行逐列 地整理每个格子。
整理规则为：在整理过程中，可以选择 向右移动一格 或 向下移动一格，但不能移动到衣柜之外。同时，不需要整理 digit(i) + digit(j) > cnt 的格子，其中 digit(x) 表示数字 x 的各数位之和。
请返回整理师 总共需要整理多少个格子。
+ ++ +
示例 1：
+ ++输入：m = 4, n = 7, cnt = 5 +输出：18 ++ +
+ +
提示：
+ +1 <= n, m <= 1000 <= cnt <= 20+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 131.\347\240\215\347\253\271\345\255\220 I.md" "b/AllProblems/LCR 131.\347\240\215\347\253\271\345\255\220 I.md" new file mode 100644 index 00000000000..c984895fec5 --- /dev/null +++ "b/AllProblems/LCR 131.\347\240\215\347\253\271\345\255\220 I.md" @@ -0,0 +1,30 @@ +--- +title: LCR 131.砍竹子 I +date: 2023-10-10 14-43-32 +tags: [题解, LeetCode, 中等, 数学, 动态规划] +--- + +# 【LetMeFly】LCR 131.砍竹子 I + +力扣题目链接：[https://leetcode.cn/problems/jian-sheng-zi-lcof/](https://leetcode.cn/problems/jian-sheng-zi-lcof/) + +
现需要将一根长为正整数 bamboo_len 的竹子砍为若干段，每段长度均为正整数。请返回每段竹子长度的最大乘积是多少。
+ +
示例 1：
+ ++输入: bamboo_len = 12 +输出: 81 ++提示： + +
2 <= bamboo_len <= 58注意：本题与主站 343 题相同：https://leetcode-cn.com/problems/integer-break/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 132.\347\240\215\347\253\271\345\255\220 II.md" "b/AllProblems/LCR 132.\347\240\215\347\253\271\345\255\220 II.md" new file mode 100644 index 00000000000..44bc8d2ab7f --- /dev/null +++ "b/AllProblems/LCR 132.\347\240\215\347\253\271\345\255\220 II.md" @@ -0,0 +1,37 @@ +--- +title: LCR 132.砍竹子 II +date: 2023-10-10 14-43-32 +tags: [题解, LeetCode, 中等, 数学, 动态规划] +--- + +# 【LetMeFly】LCR 132.砍竹子 II + +力扣题目链接：[https://leetcode.cn/problems/jian-sheng-zi-ii-lcof/](https://leetcode.cn/problems/jian-sheng-zi-ii-lcof/) + +现需要将一根长为正整数 bamboo_len 的竹子砍为若干段，每段长度均为 正整数。请返回每段竹子长度的 最大乘积 是多少。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
+ ++ +
示例 1：
+ ++输入：bamboo_len = 12 +输出：81 ++ +
+ +
提示：
+ +2 <= bamboo_len <= 1000注意：本题与主站 343 题相同：https://leetcode-cn.com/problems/integer-break/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 133.\344\275\215 1 \347\232\204\344\270\252\346\225\260.md" "b/AllProblems/LCR 133.\344\275\215 1 \347\232\204\344\270\252\346\225\260.md" new file mode 100644 index 00000000000..864a17e1051 --- /dev/null +++ "b/AllProblems/LCR 133.\344\275\215 1 \347\232\204\344\270\252\346\225\260.md" @@ -0,0 +1,62 @@ +--- +title: LCR 133.位 1 的个数 +date: 2023-10-10 14-43-33 +tags: [题解, LeetCode, 简单, 位运算] +--- + +# 【LetMeFly】LCR 133.位 1 的个数 + +力扣题目链接：[https://leetcode.cn/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/](https://leetcode.cn/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/) + +
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为 汉明重量).）。
+ ++ +
提示：
+ +-3。+ +
示例 1：
+ +
+输入：n = 11 (控制台输入 00000000000000000000000000001011)
+输出：3
+解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
+
+
+示例 2：
+ ++输入：n = 128 (控制台输入 00000000000000000000000010000000) +输出：1 +解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。 ++ +
示例 3：
+ ++输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3） +输出：31 +解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。+ +
+ +
提示：
+ +32 的 二进制串 。+ +
注意：本题与主站 191 题相同：https://leetcode-cn.com/problems/number-of-1-bits/
+ ++ + + \ No newline at end of file diff --git a/AllProblems/LCR 134.Pow(x, n).md b/AllProblems/LCR 134.Pow(x, n).md new file mode 100644 index 00000000000..f0367914752 --- /dev/null +++ b/AllProblems/LCR 134.Pow(x, n).md @@ -0,0 +1,52 @@ +--- +title: LCR 134.Pow(x, n) +date: 2023-10-10 14-43-33 +tags: [题解, LeetCode, 中等, 递归, 数学] +--- + +# 【LetMeFly】LCR 134.Pow(x, n) + +力扣题目链接：[https://leetcode.cn/problems/shu-zhi-de-zheng-shu-ci-fang-lcof/](https://leetcode.cn/problems/shu-zhi-de-zheng-shu-ci-fang-lcof/) + +
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
+ ++ +
示例 1：
+ ++输入：x = 2.00000, n = 10 +输出：1024.00000 ++ +
示例 2：
+ ++输入：x = 2.10000, n = 3 +输出：9.26100+ +
示例 3：
+ ++输入：x = 2.00000, n = -2 +输出：0.25000 +解释：2-2 = 1/22 = 1/4 = 0.25+ +
+ +
提示：
+ +-100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104+ +
注意：本题与主站 50 题相同：https://leetcode-cn.com/problems/powx-n/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 135.\346\212\245\346\225\260.md" "b/AllProblems/LCR 135.\346\212\245\346\225\260.md" new file mode 100644 index 00000000000..188d57d1676 --- /dev/null +++ "b/AllProblems/LCR 135.\346\212\245\346\225\260.md" @@ -0,0 +1,22 @@ +--- +title: LCR 135.报数 +date: 2023-10-10 14-43-33 +tags: [题解, LeetCode, 简单, 数组, 数学] +--- + +# 【LetMeFly】LCR 135.报数 + +力扣题目链接：[https://leetcode.cn/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/](https://leetcode.cn/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/) + +
实现一个十进制数字报数程序，请按照数字从小到大的顺序返回一个证书数列，该数列从数字 1 开始，到最大的正整数 cnt 位数字结束。
+ +
示例 1:
+ ++输入：cnt = 2 +输出：[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 136.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md" "b/AllProblems/LCR 136.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md" new file mode 100644 index 00000000000..fb26906bf1c --- /dev/null +++ "b/AllProblems/LCR 136.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md" @@ -0,0 +1,43 @@ +--- +title: LCR 136.删除链表的节点 +date: 2023-10-10 14-43-34 +tags: [题解, LeetCode, 简单, 链表] +--- + +# 【LetMeFly】LCR 136.删除链表的节点 + +力扣题目链接：[https://leetcode.cn/problems/shan-chu-lian-biao-de-jie-dian-lcof/](https://leetcode.cn/problems/shan-chu-lian-biao-de-jie-dian-lcof/) + +
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
+ +返回删除后的链表的头节点。
+ +示例 1:
+ ++输入: head = [4,5,1,9], val = 5 +输出: [4,1,9] +解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. ++ +
示例 2:
+ ++输入: head = [4,5,1,9], val = 1 +输出: [4,5,9] +解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9. ++ +
+ +
说明：
+ +free 或 delete 被删除的节点+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 137.\346\250\241\347\263\212\346\220\234\347\264\242\351\252\214\350\257\201.md" "b/AllProblems/LCR 137.\346\250\241\347\263\212\346\220\234\347\264\242\351\252\214\350\257\201.md" new file mode 100644 index 00000000000..b6c2365963f --- /dev/null +++ "b/AllProblems/LCR 137.\346\250\241\347\263\212\346\220\234\347\264\242\351\252\214\350\257\201.md" @@ -0,0 +1,67 @@ +--- +title: LCR 137.模糊搜索验证 +date: 2023-10-10 14-43-34 +tags: [题解, LeetCode, 困难, 递归, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 137.模糊搜索验证 + +力扣题目链接：[https://leetcode.cn/problems/zheng-ze-biao-da-shi-pi-pei-lcof/](https://leetcode.cn/problems/zheng-ze-biao-da-shi-pi-pei-lcof/) + +
请设计一个程序来支持用户在文本编辑器中的模糊搜索功能。用户输入内容中可能使用到如下两种通配符：
+ +'.' 匹配任意单个字符。'*' 匹配零个或多个前面的那一个元素。+ +
请返回用户输入内容 input 所有字符是否可以匹配原文字符串 article。
+ +
示例 1:
+ ++输入: input = "aa", article = "a" +输出: false +解释: "a" 无法匹配 "aa" 整个字符串。 ++ +
示例 2:
+ ++输入: input = "aa", article = "a*" +输出: true +解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。 ++ +
示例 3:
+ ++输入: input = "ab", article = ".*" +输出: true +解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。 ++ +
+ +
提示：
+ +1 <= article.length <= 201 <= input.length <= 20article 只包含从 a-z 的小写字母。input 只包含从 a-z 的小写字母，以及字符 . 和 * 。* 时，前面都匹配到有效的字符+ +
注意：本题与主站 10 题相同：https://leetcode-cn.com/problems/regular-expression-matching/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 138.\346\234\211\346\225\210\346\225\260\345\255\227.md" "b/AllProblems/LCR 138.\346\234\211\346\225\210\346\225\260\345\255\227.md" new file mode 100644 index 00000000000..15bb4ca1e5c --- /dev/null +++ "b/AllProblems/LCR 138.\346\234\211\346\225\210\346\225\260\345\255\227.md" @@ -0,0 +1,81 @@ +--- +title: LCR 138.有效数字 +date: 2023-10-10 14-43-35 +tags: [题解, LeetCode, 中等, 字符串] +--- + +# 【LetMeFly】LCR 138.有效数字 + +力扣题目链接：[https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/](https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/) + +
有效数字（按顺序）可以分成以下几个部分：
+ +'e' 或 'E' ，后面跟着一个 整数小数（按顺序）可以分成以下几个部分：
+ +'+' 或 '-'）'.''.' ，后面再跟着至少一位数字'.' ，后面跟着至少一位数字整数（按顺序）可以分成以下几个部分：
+ +'+' 或 '-'）部分有效数字列举如下：["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]
部分无效数字列举如下：["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]
给你一个字符串 s ，如果 s 是一个 有效数字 ，请返回 true 。
+ +
示例 1：
+ ++输入：s = "0" +输出：true ++ +
示例 2：
+ ++输入：s = "e" +输出：false ++ +
示例 3：
+ ++输入：s = "." +输出：false ++ +
+ +
提示：
+ +1 <= s.length <= 20s 仅含英文字母（大写和小写），数字（0-9），加号 '+' ，减号 '-' ，空格 ' ' 或者点 '.' 。+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 139.\350\256\255\347\273\203\350\256\241\345\210\222 I.md" "b/AllProblems/LCR 139.\350\256\255\347\273\203\350\256\241\345\210\222 I.md" new file mode 100644 index 00000000000..c3673b2b0f2 --- /dev/null +++ "b/AllProblems/LCR 139.\350\256\255\347\273\203\350\256\241\345\210\222 I.md" @@ -0,0 +1,34 @@ +--- +title: LCR 139.训练计划 I +date: 2023-10-10 14-43-35 +tags: [题解, LeetCode, 简单, 数组, 双指针, 排序] +--- + +# 【LetMeFly】LCR 139.训练计划 I + +力扣题目链接：[https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/](https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/) + +
教练使用整数数组 actions 记录一系列核心肌群训练项目编号。为增强训练趣味性，需要将所有奇数编号训练项目调整至偶数编号训练项目之前。请将调整后的训练项目编号以 数组 形式返回。
+ +
示例 1：
+ ++输入：actions = [1,2,3,4,5] +输出：[1,3,5,2,4] +解释：为正确答案之一+ +
+ +
提示：
+ +0 <= actions.length <= 500000 <= actions[i] <= 10000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 140.\350\256\255\347\273\203\350\256\241\345\210\222 II.md" "b/AllProblems/LCR 140.\350\256\255\347\273\203\350\256\241\345\210\222 II.md" new file mode 100644 index 00000000000..3d979408645 --- /dev/null +++ "b/AllProblems/LCR 140.\350\256\255\347\273\203\350\256\241\345\210\222 II.md" @@ -0,0 +1,34 @@ +--- +title: LCR 140.训练计划 II +date: 2023-10-10 14-43-35 +tags: [题解, LeetCode, 简单, 链表, 双指针] +--- + +# 【LetMeFly】LCR 140.训练计划 II + +力扣题目链接：[https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/](https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/) + +
给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号，请查找并返回倒数第 cnt 个训练项目编号。
+ +
示例 1：
+ ++输入：head = [2,4,7,8], cnt = 1 +输出：8+ +
+ +
提示：
+ +1 <= head.length <= 1000 <= head[i] <= 1001 <= cnt <= head.length+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 141.\350\256\255\347\273\203\350\256\241\345\210\222 III.md" "b/AllProblems/LCR 141.\350\256\255\347\273\203\350\256\241\345\210\222 III.md" new file mode 100644 index 00000000000..37a4f49ffad --- /dev/null +++ "b/AllProblems/LCR 141.\350\256\255\347\273\203\350\256\241\345\210\222 III.md" @@ -0,0 +1,56 @@ +--- +title: LCR 141.训练计划 III +date: 2023-10-10 14-43-36 +tags: [题解, LeetCode, 简单, 递归, 链表] +--- + +# 【LetMeFly】LCR 141.训练计划 III + +力扣题目链接：[https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/](https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/) + +
给定一个头节点为 head 的单链表用于记录一系列核心肌群训练编号，请将该系列训练编号 倒序 记录于链表并返回。
+ +
示例 1：
+ ++输入：head = [1,2,3,4,5] +输出：[5,4,3,2,1] ++ +
+ +
示例 2：
+ ++输入：head = [1,2] +输出：[2,1] ++ +
+ +
示例 3：
+ ++输入：head = [] +输出：[] ++ +
+ +
提示：
+ +[0, 5000]-5000 <= Node.val <= 5000+ +
注意：本题与主站 206 题相同：https://leetcode-cn.com/problems/reverse-linked-list/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 142.\350\256\255\347\273\203\350\256\241\345\210\222 IV.md" "b/AllProblems/LCR 142.\350\256\255\347\273\203\350\256\241\345\210\222 IV.md" new file mode 100644 index 00000000000..22671cc932c --- /dev/null +++ "b/AllProblems/LCR 142.\350\256\255\347\273\203\350\256\241\345\210\222 IV.md" @@ -0,0 +1,48 @@ +--- +title: LCR 142.训练计划 IV +date: 2023-10-10 14-43-36 +tags: [题解, LeetCode, 简单, 递归, 链表] +--- + +# 【LetMeFly】LCR 142.训练计划 IV + +力扣题目链接：[https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/](https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/) + +
给定两个以 有序链表 形式记录的训练计划 l1、l2，分别记录了两套核心肌群训练项目编号，请合并这两个训练计划，按训练项目编号 升序 记录于链表并返回。
注意：新链表是通过拼接给定的两个链表的所有节点组成的。
+ ++ +
示例 1：
+ ++输入：l1 = [1,2,4], l2 = [1,3,4] +输出：[1,1,2,3,4,4]+ +
示例 2：
+ ++输入：l1 = [], l2 = [] +输出：[]+ +
示例 3：
+ ++输入：l1 = [], l2 = [0] +输出：[0]+ +
+ +
提示：
+ +0 <= 链表长度 <= 1000
+ +
注意：本题与主站 21 题相同：https://leetcode-cn.com/problems/merge-two-sorted-lists/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 143.\345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" "b/AllProblems/LCR 143.\345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" new file mode 100644 index 00000000000..17766bcc95a --- /dev/null +++ "b/AllProblems/LCR 143.\345\255\220\347\273\223\346\236\204\345\210\244\346\226\255.md" @@ -0,0 +1,46 @@ +--- +title: LCR 143.子结构判断 +date: 2023-10-10 14-43-37 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 143.子结构判断 + +力扣题目链接：[https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/](https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/) + +
给定两棵二叉树 tree1 和 tree2，判断 tree2 是否以 tree1 的某个节点为根的子树具有 相同的结构和节点值 。
+注意，空树 不会是以 tree1 的某个节点为根的子树具有 相同的结构和节点值 。
+ +
示例 1：
+ ++ +
+ +
+输入：tree1 = [1,7,5], tree2 = [6,1] +输出：false +解释：tree2 与 tree1 的一个子树没有相同的结构和节点值。 ++ +
示例 2：
+ +
+输入：tree1 = [3,6,7,1,8], tree2 = [6,1] +输出：true +解释：tree2 与 tree1 的一个子树拥有相同的结构和节点值。即 6 - > 1。+ +
+ +
提示：
+ +0 <= 节点个数 <= 10000
给定一棵二叉树的根节点 root，请左右翻转这棵二叉树，并返回其根节点。
+ +
示例 1：
+ +
+输入：root = [5,7,9,8,3,2,4] +输出：[5,9,7,4,2,3,8] ++ +
+ +
提示：
+ +[0, 100] 内-100 <= Node.val <= 100+ +
注意：本题与主站 226 题相同：https://leetcode-cn.com/problems/invert-binary-tree/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 145.\345\210\244\346\226\255\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md" "b/AllProblems/LCR 145.\345\210\244\346\226\255\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md" new file mode 100644 index 00000000000..1b556fafae1 --- /dev/null +++ "b/AllProblems/LCR 145.\345\210\244\346\226\255\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md" @@ -0,0 +1,44 @@ +--- +title: LCR 145.判断对称二叉树 +date: 2023-10-10 14-43-38 +tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 145.判断对称二叉树 + +力扣题目链接：[https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/](https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/) + +
请设计一个函数判断一棵二叉树是否 轴对称 。
+ ++ +
示例 1：
+ +
+输入：root = [6,7,7,8,9,9,8] +输出：true +解释：从图中可看出树是轴对称的。+ +
示例 2：
+ +
+输入：root = [1,2,2,null,3,null,3] +输出：false +解释：从图中可看出最后一层的节点不对称。+ +
+ +
提示：
+ +0 <= 节点个数 <= 1000
注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 146.\350\236\272\346\227\213\351\201\215\345\216\206\344\272\214\347\273\264\346\225\260\347\273\204.md" "b/AllProblems/LCR 146.\350\236\272\346\227\213\351\201\215\345\216\206\344\272\214\347\273\264\346\225\260\347\273\204.md" new file mode 100644 index 00000000000..0c404277d9d --- /dev/null +++ "b/AllProblems/LCR 146.\350\236\272\346\227\213\351\201\215\345\216\206\344\272\214\347\273\264\346\225\260\347\273\204.md" @@ -0,0 +1,45 @@ +--- +title: LCR 146.螺旋遍历二维数组 +date: 2023-10-10 14-43-38 +tags: [题解, LeetCode, 简单, 数组, 矩阵, 模拟] +--- + +# 【LetMeFly】LCR 146.螺旋遍历二维数组 + +力扣题目链接：[https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/](https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/) + +
给定一个二维数组 array，请返回「螺旋遍历」该数组的结果。
螺旋遍历：从左上角开始，按照 向右、向下、向左、向上 的顺序 依次 提取元素，然后再进入内部一层重复相同的步骤，直到提取完所有元素。
+ ++ +
示例 1：
+ ++输入：array = [[1,2,3],[8,9,4],[7,6,5]] +输出：[1,2,3,4,5,6,7,8,9] ++ +
示例 2：
+ ++输入：array = [[1,2,3,4],[12,13,14,5],[11,16,15,6],[10,9,8,7]] +输出：[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] ++ +
+ +
限制：
+ +0 <= array.length <= 1000 <= array[i].length <= 100注意：本题与主站 54 题相同：https://leetcode-cn.com/problems/spiral-matrix/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 147.\346\234\200\345\260\217\346\240\210.md" "b/AllProblems/LCR 147.\346\234\200\345\260\217\346\240\210.md" new file mode 100644 index 00000000000..bae4683d97d --- /dev/null +++ "b/AllProblems/LCR 147.\346\234\200\345\260\217\346\240\210.md" @@ -0,0 +1,66 @@ +--- +title: LCR 147.最小栈 +date: 2023-10-10 14-43-38 +tags: [题解, LeetCode, 简单, 栈, 设计] +--- + +# 【LetMeFly】LCR 147.最小栈 + +力扣题目链接：[https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/](https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/) + +
请你设计一个 最小栈 。它提供 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],[2],[-3],[],[],[],[]] + +输出： +[null,null,null,null,-3,null,2,-2] + +解释： +MinStack minStack = new MinStack(); +minStack.push(-2); +minStack.push(2); +minStack.push(-3); +minStack.getMin(); --> 返回 -3. +minStack.pop(); +minStack.top(); --> 返回 2. +minStack.getMin(); --> 返回 -2. ++ +
+ +
+提示：
-231 <= val <= 231 - 1pop、top 和 getMin 操作总是在 非空栈 上调用push、pop、top 和 getMin 最多被调用 3 * 104 次+ +
注意：本题与主站 155 题相同：https://leetcode-cn.com/problems/min-stack/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 148.\351\252\214\350\257\201\345\233\276\344\271\246\345\217\226\345\207\272\351\241\272\345\272\217.md" "b/AllProblems/LCR 148.\351\252\214\350\257\201\345\233\276\344\271\246\345\217\226\345\207\272\351\241\272\345\272\217.md" new file mode 100644 index 00000000000..73d8fd0d27a --- /dev/null +++ "b/AllProblems/LCR 148.\351\252\214\350\257\201\345\233\276\344\271\246\345\217\226\345\207\272\351\241\272\345\272\217.md" @@ -0,0 +1,50 @@ +--- +title: LCR 148.验证图书取出顺序 +date: 2023-10-10 14-43-39 +tags: [题解, LeetCode, 中等, 栈, 数组, 模拟] +--- + +# 【LetMeFly】LCR 148.验证图书取出顺序 + +力扣题目链接：[https://leetcode.cn/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/](https://leetcode.cn/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/) + +
现在图书馆有一堆图书需要放入书架，并且图书馆的书架是一种特殊的数据结构，只能按照 一定 的顺序 放入 和 拿取 书籍。
+ +给定一个表示图书放入顺序的整数序列 putIn，请判断序列 takeOut 是否为按照正确的顺序拿取书籍的操作序列。你可以假设放入书架的所有书籍编号都不相同。
+ +
示例 1：
+ ++输入：putIn = [6,7,8,9,10,11], takeOut = [9,11,10,8,7,6] +输出：true +解释：我们可以按以下操作放入并拿取书籍： +push(6), push(7), push(8), push(9), pop() -> 9, +push(10), push(11),pop() -> 11,pop() -> 10, pop() -> 8, pop() -> 7, pop() -> 6 ++ +
示例 2：
+ ++输入：putIn = [6,7,8,9,10,11], takeOut = [11,9,8,10,6,7] +输出：false +解释：6 不能在 7 之前取出。 ++ +
+ +
提示：
+ +0 <= putIn.length == takeOut.length <= 10000 <= putIn[i], takeOut < 1000putIn 是 takeOut 的排列。注意：本题与主站 946 题相同：https://leetcode-cn.com/problems/validate-stack-sequences/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 149.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 I.md" "b/AllProblems/LCR 149.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 I.md" new file mode 100644 index 00000000000..7991f7ac27a --- /dev/null +++ "b/AllProblems/LCR 149.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 I.md" @@ -0,0 +1,35 @@ +--- +title: LCR 149.彩灯装饰记录 I +date: 2023-10-10 14-43-39 +tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 149.彩灯装饰记录 I + +力扣题目链接：[https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/) + +
一棵圣诞树记作根节点为 root 的二叉树，节点值为该位置装饰彩灯的颜色编号。请按照从 左 到 右 的顺序返回每一层彩灯编号。
+ +
示例 1：
+ +
+输入：root = [8,17,21,18,null,null,6] +输出：[8,17,21,18,6] ++ +
+ +
提示：
+ +节点总数 <= 1000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 150.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 II.md" "b/AllProblems/LCR 150.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 II.md" new file mode 100644 index 00000000000..d151a706758 --- /dev/null +++ "b/AllProblems/LCR 150.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 II.md" @@ -0,0 +1,35 @@ +--- +title: LCR 150.彩灯装饰记录 II +date: 2023-10-10 14-43-40 +tags: [题解, LeetCode, 简单, 树, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 150.彩灯装饰记录 II + +力扣题目链接：[https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/) + +
一棵圣诞树记作根节点为 root 的二叉树，节点值为该位置装饰彩灯的颜色编号。请按照从左到右的顺序返回每一层彩灯编号，每一层的结果记录于一行。
+ +
示例 1：
+ +
+输入：root = [8,17,21,18,null,null,6] +输出：[[8],[17,21],[18,6]] ++ +
提示：
+ +节点总数 <= 1000注意：本题与主站 102 题相同：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 151.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 III.md" "b/AllProblems/LCR 151.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 III.md" new file mode 100644 index 00000000000..886ffe6497c --- /dev/null +++ "b/AllProblems/LCR 151.\345\275\251\347\201\257\350\243\205\351\245\260\350\256\260\345\275\225 III.md" @@ -0,0 +1,40 @@ +--- +title: LCR 151.彩灯装饰记录 III +date: 2023-10-10 14-43-40 +tags: [题解, LeetCode, 中等, 树, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 151.彩灯装饰记录 III + +力扣题目链接：[https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/) + +
一棵圣诞树记作根节点为 root 的二叉树，节点值为该位置装饰彩灯的颜色编号。请按照如下规则记录彩灯装饰结果：
+ +
示例 1：
+ +
+输入：root = [8,17,21,18,null,null,6] +输出：[[8],[21,17],[18,6]] ++ +
+ +
提示：
+ +节点总数 <= 1000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 152.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227.md" "b/AllProblems/LCR 152.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227.md" new file mode 100644 index 00000000000..25dfe1a9c5c --- /dev/null +++ "b/AllProblems/LCR 152.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227.md" @@ -0,0 +1,47 @@ +--- +title: LCR 152.验证二叉搜索树的后序遍历序列 +date: 2023-10-10 14-43-40 +tags: [题解, LeetCode, 中等, 栈, 树, 二叉搜索树, 递归, 二叉树, 单调栈] +--- + +# 【LetMeFly】LCR 152.验证二叉搜索树的后序遍历序列 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/](https://leetcode.cn/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/) + +
请实现一个函数来判断整数数组 postorder 是否为二叉搜索树的后序遍历结果。
+ +
示例 1：
+ +
+输入: postorder = [4,9,6,9,8] +输出: false +解释：从上图可以看出这不是一颗二叉搜索树 ++ +
示例 2：
+ +
+输入: postorder = [4,6,5,9,8] +输出: true +解释：可构建的二叉搜索树如上图 ++ +
+ +
提示：
+ +数组长度 <= 1000postorder 中无重复数字+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 153.\344\272\214\345\217\211\346\240\221\344\270\255\345\222\214\344\270\272\347\233\256\346\240\207\345\200\274\347\232\204\350\267\257\345\276\204.md" "b/AllProblems/LCR 153.\344\272\214\345\217\211\346\240\221\344\270\255\345\222\214\344\270\272\347\233\256\346\240\207\345\200\274\347\232\204\350\267\257\345\276\204.md" new file mode 100644 index 00000000000..831d5a2cab7 --- /dev/null +++ "b/AllProblems/LCR 153.\344\272\214\345\217\211\346\240\221\344\270\255\345\222\214\344\270\272\347\233\256\346\240\207\345\200\274\347\232\204\350\267\257\345\276\204.md" @@ -0,0 +1,57 @@ +--- +title: LCR 153.二叉树中和为目标值的路径 +date: 2023-10-10 14-43-41 +tags: [题解, LeetCode, 中等, 树, 深度优先搜索, 回溯, 二叉树] +--- + +# 【LetMeFly】LCR 153.二叉树中和为目标值的路径 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/](https://leetcode.cn/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/) + +
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
+ ++ +
示例 1：
+ +
+输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22 +输出：[[5,4,11,2],[5,8,4,5]] ++ +
示例 2：
+ +
+输入：root = [1,2,3], targetSum = 5 +输出：[] ++ +
示例 3：
+ ++输入：root = [1,2], targetSum = 0 +输出：[] ++ +
+ +
提示：
+ +[0, 5000] 内-1000 <= Node.val <= 1000-1000 <= targetSum <= 1000注意：本题与主站 113 题相同：https://leetcode-cn.com/problems/path-sum-ii/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 154.\345\244\215\346\235\202\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" "b/AllProblems/LCR 154.\345\244\215\346\235\202\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" new file mode 100644 index 00000000000..f60d58f8b54 --- /dev/null +++ "b/AllProblems/LCR 154.\345\244\215\346\235\202\351\223\276\350\241\250\347\232\204\345\244\215\345\210\266.md" @@ -0,0 +1,63 @@ +--- +title: LCR 154.复杂链表的复制 +date: 2023-10-10 14-43-42 +tags: [题解, LeetCode, 中等, 哈希表, 链表] +--- + +# 【LetMeFly】LCR 154.复杂链表的复制 + +力扣题目链接：[https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/](https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/) + +
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
+ +
示例 1：
+ +
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]] +输出：[[7,null],[13,0],[11,4],[10,2],[1,0]] ++ +
示例 2：
+ +
输入：head = [[1,1],[2,1]] +输出：[[1,1],[2,1]] ++ +
示例 3：
+ +
输入：head = [[3,null],[3,0],[3,null]] +输出：[[3,null],[3,0],[3,null]] ++ +
示例 4：
+ +输入：head = [] +输出：[] +解释：给定的链表为空（空指针），因此返回 null。 ++ +
+ +
提示：
+ +-10000 <= Node.val <= 10000Node.random 为空（null）或指向链表中的节点。+ +
注意：本题与主站 138 题相同：https://leetcode-cn.com/problems/copy-list-with-random-pointer/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 155.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\214\226\344\270\272\346\216\222\345\272\217\347\232\204\345\217\214\345\220\221\351\223\276\350\241\250.md" "b/AllProblems/LCR 155.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\214\226\344\270\272\346\216\222\345\272\217\347\232\204\345\217\214\345\220\221\351\223\276\350\241\250.md" new file mode 100644 index 00000000000..d9fd15d2d92 --- /dev/null +++ "b/AllProblems/LCR 155.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\214\226\344\270\272\346\216\222\345\272\217\347\232\204\345\217\214\345\220\221\351\223\276\350\241\250.md" @@ -0,0 +1,67 @@ +--- +title: LCR 155.将二叉搜索树转化为排序的双向链表 +date: 2023-10-10 14-43-42 +tags: [题解, LeetCode, 中等, 栈, 树, 深度优先搜索, 二叉搜索树, 链表, 二叉树, 双向链表] +--- + +# 【LetMeFly】LCR 155.将二叉搜索树转化为排序的双向链表 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof/](https://leetcode.cn/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof/) + +
将一个 二叉搜索树 就地转化为一个 已排序的双向循环链表 。
+ +对于双向循环列表，你可以将左右孩子指针作为双向循环链表的前驱和后继指针，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。
+ +特别地，我们希望可以 就地 完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中最小元素的指针。
+ ++ +
示例 1：
+ ++输入：root = [4,2,5,1,3] + ++ ++输出：[1,2,3,4,5] + +解释：下图显示了转化后的二叉搜索树，实线表示后继关系，虚线表示前驱关系。 +
+
示例 2：
+ ++输入：root = [2,1,3] +输出：[1,2,3] ++ +
示例 3：
+ ++输入：root = [] +输出：[] +解释：输入是空树，所以输出也是空链表。 ++ +
示例 4：
+ ++输入：root = [1] +输出：[1] ++ +
+ +
提示：
+ +-1000 <= Node.val <= 1000Node.left.val < Node.val < Node.right.valNode.val 的所有值都是独一无二的0 <= Number of Nodes <= 2000注意：本题与主站 426 题相同：https://leetcode-cn.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 156.\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226\344\272\214\345\217\211\346\240\221.md" "b/AllProblems/LCR 156.\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226\344\272\214\345\217\211\346\240\221.md" new file mode 100644 index 00000000000..56882c43357 --- /dev/null +++ "b/AllProblems/LCR 156.\345\272\217\345\210\227\345\214\226\344\270\216\345\217\215\345\272\217\345\210\227\345\214\226\344\272\214\345\217\211\346\240\221.md" @@ -0,0 +1,63 @@ +--- +title: LCR 156.序列化与反序列化二叉树 +date: 2023-10-10 14-43-42 +tags: [题解, LeetCode, 困难, 树, 深度优先搜索, 广度优先搜索, 设计, 字符串, 二叉树] +--- + +# 【LetMeFly】LCR 156.序列化与反序列化二叉树 + +力扣题目链接：[https://leetcode.cn/problems/xu-lie-hua-er-cha-shu-lcof/](https://leetcode.cn/problems/xu-lie-hua-er-cha-shu-lcof/) + +序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。
+ +请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
+ +提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
+ ++ +
示例 1：
+
++输入：root = [1,2,3,null,null,4,5] +输出：[1,2,3,null,null,4,5] ++ +
示例 2：
+ ++输入：root = [] +输出：[] ++ +
示例 3：
+ ++输入：root = [1] +输出：[1] ++ +
示例 4：
+ ++输入：root = [1,2] +输出：[1,2] ++ +
+ +
提示：
+ +[0, 104] 内-1000 <= Node.val <= 1000注意：本题与主站 297 题相同：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/
+ ++ +
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 157.\345\245\227\351\244\220\345\206\205\345\225\206\345\223\201\347\232\204\346\216\222\345\210\227\351\241\272\345\272\217.md" "b/AllProblems/LCR 157.\345\245\227\351\244\220\345\206\205\345\225\206\345\223\201\347\232\204\346\216\222\345\210\227\351\241\272\345\272\217.md" new file mode 100644 index 00000000000..07de193ec27 --- /dev/null +++ "b/AllProblems/LCR 157.\345\245\227\351\244\220\345\206\205\345\225\206\345\223\201\347\232\204\346\216\222\345\210\227\351\241\272\345\272\217.md" @@ -0,0 +1,35 @@ +--- +title: LCR 157.套餐内商品的排列顺序 +date: 2023-10-10 14-43-43 +tags: [题解, LeetCode, 中等, 字符串, 回溯] +--- + +# 【LetMeFly】LCR 157.套餐内商品的排列顺序 + +力扣题目链接：[https://leetcode.cn/problems/zi-fu-chuan-de-pai-lie-lcof/](https://leetcode.cn/problems/zi-fu-chuan-de-pai-lie-lcof/) + +
某店铺将用于组成套餐的商品记作字符串 goods，其中 goods[i] 表示对应商品。请返回该套餐内所含商品的 全部排列方式 。
返回结果 无顺序要求，但不能含有重复的元素。
+ ++ +
示例 1:
+ ++输入：goods = "agew" +输出：["aegw","aewg","agew","agwe","aweg","awge","eagw","eawg","egaw","egwa","ewag","ewga","gaew","gawe","geaw","gewa","gwae","gwea","waeg","wage","weag","wega","wgae","wgea"] ++ +
+ +
提示：
+ +1 <= goods.length <= 8+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 158.\345\272\223\345\255\230\347\256\241\347\220\206 II.md" "b/AllProblems/LCR 158.\345\272\223\345\255\230\347\256\241\347\220\206 II.md" new file mode 100644 index 00000000000..a040269dab4 --- /dev/null +++ "b/AllProblems/LCR 158.\345\272\223\345\255\230\347\256\241\347\220\206 II.md" @@ -0,0 +1,35 @@ +--- +title: LCR 158.库存管理 II +date: 2023-10-10 14-43-43 +tags: [题解, LeetCode, 简单, 数组, 哈希表, 分治, 计数, 排序] +--- + +# 【LetMeFly】LCR 158.库存管理 II + +力扣题目链接：[https://leetcode.cn/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/](https://leetcode.cn/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/) + +
仓库管理员以数组 stock 形式记录商品库存表。stock[i] 表示商品 id，可能存在重复。请返回库存表中数量大于 stock.length / 2 的商品 id。
+ +
示例 1:
+ ++输入: stock = [6, 1, 3, 1, 1, 1] +输出: 1+ +
+ +
限制：
+ +1 <= stock.length <= 50000+ +
注意：本题与主站 169 题相同：https://leetcode-cn.com/problems/majority-element/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 159.\345\272\223\345\255\230\347\256\241\347\220\206 III.md" "b/AllProblems/LCR 159.\345\272\223\345\255\230\347\256\241\347\220\206 III.md" new file mode 100644 index 00000000000..6e4e0162fcd --- /dev/null +++ "b/AllProblems/LCR 159.\345\272\223\345\255\230\347\256\241\347\220\206 III.md" @@ -0,0 +1,40 @@ +--- +title: LCR 159.库存管理 III +date: 2023-10-10 14-43-44 +tags: [题解, LeetCode, 简单, 数组, 分治, 快速选择, 排序, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 159.库存管理 III + +力扣题目链接：[https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/](https://leetcode.cn/problems/zui-xiao-de-kge-shu-lcof/) + +仓库管理员以数组 stock 形式记录商品库存表，其中 stock[i] 表示对应商品库存余量。请返回库存余量最少的 cnt 个商品余量，返回 顺序不限。
+ +
示例 1：
+ ++输入：stock = [2,5,7,4], cnt = 1 +输出：[2] ++ +
示例 2：
+ ++输入：stock = [0,2,3,6], cnt = 2 +输出：[0,2] 或 [2,0]+ +
+ +
提示：
+ +0 <= cnt <= stock.length <= 10000
+ 0 <= stock[i] <= 10000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 160.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260.md" "b/AllProblems/LCR 160.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260.md" new file mode 100644 index 00000000000..2ae0924de05 --- /dev/null +++ "b/AllProblems/LCR 160.\346\225\260\346\215\256\346\265\201\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260.md" @@ -0,0 +1,53 @@ +--- +title: LCR 160.数据流中的中位数 +date: 2023-10-10 14-43-45 +tags: [题解, LeetCode, 困难, 设计, 双指针, 数据流, 排序, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 160.数据流中的中位数 + +力扣题目链接：[https://leetcode.cn/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/](https://leetcode.cn/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/) + +
中位数 是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。
+ +例如，
+[2,3,4] 的中位数是 3
+[2,3] 的中位数是 (2 + 3) / 2 = 2.5
+设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。double findMedian() - 返回目前所有元素的中位数。示例 1：
+ ++输入： +["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"] +[[],[1],[2],[],[3],[]] +输出：[null,null,null,1.50000,null,2.00000] ++ +
示例 2：
+ ++输入： +["MedianFinder","addNum","findMedian","addNum","findMedian"] +[[],[2],[],[3],[]] +输出：[null,null,2.00000,null,2.50000]+ +
+ +
提示：
+ +addNum、findMedian 进行 50000 次调用。注意：本题与主站 295 题相同：https://leetcode-cn.com/problems/find-median-from-data-stream/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 161.\350\277\236\347\273\255\345\244\251\346\225\260\347\232\204\346\234\200\351\253\230\351\224\200\345\224\256\351\242\235.md" "b/AllProblems/LCR 161.\350\277\236\347\273\255\345\244\251\346\225\260\347\232\204\346\234\200\351\253\230\351\224\200\345\224\256\351\242\235.md" new file mode 100644 index 00000000000..d2fd460fc60 --- /dev/null +++ "b/AllProblems/LCR 161.\350\277\236\347\273\255\345\244\251\346\225\260\347\232\204\346\234\200\351\253\230\351\224\200\345\224\256\351\242\235.md" @@ -0,0 +1,43 @@ +--- +title: LCR 161.连续天数的最高销售额 +date: 2023-10-10 14-43-45 +tags: [题解, LeetCode, 简单, 数组, 分治, 动态规划] +--- + +# 【LetMeFly】LCR 161.连续天数的最高销售额 + +力扣题目链接：[https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/](https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/) + +
某公司每日销售额记于整数数组 sales，请返回所有 连续 一或多天销售额总和的最大值。
要求实现时间复杂度为 O(n) 的算法。
+ +
示例 1:
+ ++输入：sales = [-2,1,-3,4,-1,2,1,-5,4] +输出：6 +解释：[4,-1,2,1] 此连续四天的销售总额最高，为 6。+ +
示例 2:
+ ++输入：sales = [5,4,-1,7,8] +输出：23 +解释：[5,4,-1,7,8] 此连续五天的销售总额最高，为 23。+ +
+ +
提示：
+ +1 <= arr.length <= 10^5-100 <= arr[i] <= 100注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 162.\346\225\260\345\255\227 1 \347\232\204\344\270\252\346\225\260.md" "b/AllProblems/LCR 162.\346\225\260\345\255\227 1 \347\232\204\344\270\252\346\225\260.md" new file mode 100644 index 00000000000..985eb060495 --- /dev/null +++ "b/AllProblems/LCR 162.\346\225\260\345\255\227 1 \347\232\204\344\270\252\346\225\260.md" @@ -0,0 +1,41 @@ +--- +title: LCR 162.数字 1 的个数 +date: 2023-10-10 14-43-45 +tags: [题解, LeetCode, 困难, 递归, 数学, 动态规划] +--- + +# 【LetMeFly】LCR 162.数字 1 的个数 + +力扣题目链接：[https://leetcode.cn/problems/1nzheng-shu-zhong-1chu-xian-de-ci-shu-lcof/](https://leetcode.cn/problems/1nzheng-shu-zhong-1chu-xian-de-ci-shu-lcof/) + +给定一个整数 num，计算所有小于等于 num 的非负整数中数字 1 出现的个数。
+ +
示例 1：
+ ++输入：num = 0 +输出：0 ++ +
示例 2：
+ ++输入：num = 13 +输出：6+ +
+ +
提示：
+ +1 <= n < 231注意：本题与主站 233 题相同：https://leetcode-cn.com/problems/number-of-digit-one/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 163.\346\211\276\345\210\260\347\254\254 k \344\275\215\346\225\260\345\255\227.md" "b/AllProblems/LCR 163.\346\211\276\345\210\260\347\254\254 k \344\275\215\346\225\260\345\255\227.md" new file mode 100644 index 00000000000..caaa26c7373 --- /dev/null +++ "b/AllProblems/LCR 163.\346\211\276\345\210\260\347\254\254 k \344\275\215\346\225\260\345\255\227.md" @@ -0,0 +1,42 @@ +--- +title: LCR 163.找到第 k 位数字 +date: 2023-10-10 14-43-46 +tags: [题解, LeetCode, 中等, 数学, 二分查找] +--- + +# 【LetMeFly】LCR 163.找到第 k 位数字 + +力扣题目链接：[https://leetcode.cn/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/](https://leetcode.cn/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/) + +
某班级学号记录系统发生错乱，原整数学号序列 [0,1,2,3,4,...] 分隔符丢失后变为 01234... 的字符序列。请实现一个函数返回该字符序列中的第 k 位数字。
+ +
示例 1：
+ ++输入：k = 5 +输出：5 ++ +
示例 2：
+ ++输入：k = 12 +输出：1 +解释：第 12 位数字在序列 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是 1 ，它是 11 的一部分。+ +
+ +
提示：
+ +0 <= k < 231注意：本题与主站 400 题相同：https://leetcode-cn.com/problems/nth-digit/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 164.\347\240\264\350\247\243\351\227\257\345\205\263\345\257\206\347\240\201.md" "b/AllProblems/LCR 164.\347\240\264\350\247\243\351\227\257\345\205\263\345\257\206\347\240\201.md" new file mode 100644 index 00000000000..f81bd61adf8 --- /dev/null +++ "b/AllProblems/LCR 164.\347\240\264\350\247\243\351\227\257\345\205\263\345\257\206\347\240\201.md" @@ -0,0 +1,52 @@ +--- +title: LCR 164.破解闯关密码 +date: 2023-10-10 14-43-46 +tags: [题解, LeetCode, 中等, 贪心, 字符串, 排序] +--- + +# 【LetMeFly】LCR 164.破解闯关密码 + +力扣题目链接：[https://leetcode.cn/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof/](https://leetcode.cn/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof/) + +
闯关游戏需要破解一组密码，闯关组给出的有关密码的线索是：
+ +passwordpassword 中所有元素拼接后得到的最小的一个数请编写一个程序返回这个密码。
+ ++ +
示例 1:
+ ++输入: password = [15, 8, 7] +输出: "1578"+ +
示例 2:
+ ++输入: password = [0, 3, 30, 34, 5, 9] +输出: "03033459"+ +
+ +
提示:
+ +0 < nums.length <= 100说明:
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 165.\350\247\243\345\257\206\346\225\260\345\255\227.md" "b/AllProblems/LCR 165.\350\247\243\345\257\206\346\225\260\345\255\227.md" new file mode 100644 index 00000000000..b5f4c26fb26 --- /dev/null +++ "b/AllProblems/LCR 165.\350\247\243\345\257\206\346\225\260\345\255\227.md" @@ -0,0 +1,42 @@ +--- +title: LCR 165.解密数字 +date: 2023-10-10 14-43-47 +tags: [题解, LeetCode, 中等, 字符串, 动态规划] +--- + +# 【LetMeFly】LCR 165.解密数字 + +力扣题目链接：[https://leetcode.cn/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof/](https://leetcode.cn/problems/ba-shu-zi-fan-yi-cheng-zi-fu-chuan-lcof/) + +
现有一串神秘的密文 ciphertext，经调查，密文的特点和规则如下：
请根据上述规则将密文 ciphertext 解密为字母，并返回共有多少种解密结果。
+ +
+ +
示例 1:
+ +
+输入: ciphertext = 216612
+输出: 6
+解释: 216612 解密后有 6 种不同的形式，分别是 "cbggbc"，"vggbc"，"vggm"，"cbggm"，"cqggbc" 和 "cqggm"
+
++ +
提示：
+ +0 <= ciphertext < 231+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 166.\347\217\240\345\256\235\347\232\204\346\234\200\351\253\230\344\273\267\345\200\274.md" "b/AllProblems/LCR 166.\347\217\240\345\256\235\347\232\204\346\234\200\351\253\230\344\273\267\345\200\274.md" new file mode 100644 index 00000000000..b4ff3cb205f --- /dev/null +++ "b/AllProblems/LCR 166.\347\217\240\345\256\235\347\232\204\346\234\200\351\253\230\344\273\267\345\200\274.md" @@ -0,0 +1,42 @@ +--- +title: LCR 166.珠宝的最高价值 +date: 2023-10-10 14-43-47 +tags: [题解, LeetCode, 中等, 数组, 动态规划, 矩阵] +--- + +# 【LetMeFly】LCR 166.珠宝的最高价值 + +力扣题目链接：[https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof/](https://leetcode.cn/problems/li-wu-de-zui-da-jie-zhi-lcof/) + +
现有一个记作二维矩阵 frame 的珠宝架，其中 frame[i][j] 为该位置珠宝的价值。拿取珠宝的规则为：
注意：珠宝的价值都是大于 0 的。除非这个架子上没有任何珠宝，比如 frame = [[0]]。
+ +
示例 1:
+ +
+输入: frame = [[1,3,1],[1,5,1],[4,2,1]]
+输出: 12
+解释: 路径 1→3→5→2→1 可以拿到最高价值的珠宝
+
++ +
提示：
+ +0 < frame.length <= 2000 < frame[0].length <= 200+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 167.\346\213\233\345\274\217\346\213\206\350\247\243 I.md" "b/AllProblems/LCR 167.\346\213\233\345\274\217\346\213\206\350\247\243 I.md" new file mode 100644 index 00000000000..a7d4e08e597 --- /dev/null +++ "b/AllProblems/LCR 167.\346\213\233\345\274\217\346\213\206\350\247\243 I.md" @@ -0,0 +1,56 @@ +--- +title: LCR 167.招式拆解 I +date: 2023-10-10 14-43-48 +tags: [题解, LeetCode, 中等, 哈希表, 字符串, 滑动窗口] +--- + +# 【LetMeFly】LCR 167.招式拆解 I + +力扣题目链接：[https://leetcode.cn/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/](https://leetcode.cn/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/) + +
某套连招动作记作序列 arr，其中 arr[i] 为第 i 个招式的名字。请返回 arr 中最多可以出连续不重复的多少个招式。
+ +
示例 1:
+ ++输入: arr = "dbascDdad" +输出: 6 +解释: 因为连续且最长的招式序列是 "dbascD" 或 "bascDd"，所以其长度为 6。 ++ +
示例 2:
+ +
+输入: arr = "KKK"
+输出: 1
+解释: 因为无重复字符的最长子串是 "K"，所以其长度为 1。
+
+
+示例 3:
+ ++输入: arr = "pwwkew" +输出: 3 +解释: 因为连续且最长的招式序列是 "wke"，所以其长度为 3。 +请注意区分 子串 与 子序列 的概念：你的答案必须是 连续招式 的长度，也就是 子串。而 "pwke" 是一个非连续的 子序列，不是 子串。 ++ +
+ +
提示：
+ +0 <= arr.length <= 40000arr 由英文字母、数字、符号和空格组成。+ +
注意：本题与主站 3 题相同：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 168.\344\270\221\346\225\260.md" "b/AllProblems/LCR 168.\344\270\221\346\225\260.md" new file mode 100644 index 00000000000..f0f7df06c9a --- /dev/null +++ "b/AllProblems/LCR 168.\344\270\221\346\225\260.md" @@ -0,0 +1,37 @@ +--- +title: LCR 168.丑数 +date: 2023-10-10 14-43-48 +tags: [题解, LeetCode, 中等, 哈希表, 数学, 动态规划, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 168.丑数 + +力扣题目链接：[https://leetcode.cn/problems/chou-shu-lcof/](https://leetcode.cn/problems/chou-shu-lcof/) + +
给你一个整数 n ，请你找出并返回第 n 个 丑数 。
说明：丑数是只包含质因数 2、3 和/或 5 的正整数；1 是丑数。
+ ++ +
示例 1：
+ +
+输入: n = 10
+输出: 12
+解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。
+
+提示：
+ +1 <= n <= 1690+ +
注意：本题与主站 264 题相同：https://leetcode-cn.com/problems/ugly-number-ii/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 169.\346\213\233\345\274\217\346\213\206\350\247\243 II.md" "b/AllProblems/LCR 169.\346\213\233\345\274\217\346\213\206\350\247\243 II.md" new file mode 100644 index 00000000000..ec8d5453cc5 --- /dev/null +++ "b/AllProblems/LCR 169.\346\213\233\345\274\217\346\213\206\350\247\243 II.md" @@ -0,0 +1,36 @@ +--- +title: LCR 169.招式拆解 II +date: 2023-10-10 14-43-48 +tags: [题解, LeetCode, 简单, 队列, 哈希表, 字符串, 计数] +--- + +# 【LetMeFly】LCR 169.招式拆解 II + +力扣题目链接：[https://leetcode.cn/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/](https://leetcode.cn/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/) + +
某套连招动作记作仅由小写字母组成的序列 arr，其中 arr[i] 第 i 个招式的名字。请返回第一个只出现一次的招式名称，如不存在请返回空格。
+ +
示例 1：
+ ++输入：arr = "abbccdeff" +输出：'a' ++ +
示例 2：
+ ++输入：arr = "ccdd" +输出：' ' ++ +
+ +
限制：
+ +0 <= arr.length <= 50000
在股票交易中，如果前一天的股价高于后一天的股价，则可以认为存在一个「交易逆序对」。请设计一个程序，输入一段时间内的股票交易记录 record，返回其中存在的「交易逆序对」总数。
+ +
示例 1:
+ ++输入：record = [9, 7, 5, 4, 6] +输出：8 +解释：交易中的逆序对为 (9, 7), (9, 5), (9, 4), (9, 6), (7, 5), (7, 4), (7, 6), (5, 4)。 ++ +
+ +
限制：
+ +0 <= record.length <= 50000
某教练同时带教两位学员，分别以链表 l1、l2 记录了两套核心肌群训练计划，节点值为训练项目编号。两套计划仅有前半部分热身项目不同，后续正式训练项目相同。请设计一个程序找出并返回第一个正式训练项目编号。如果两个链表不存在相交节点，返回 null 。
如下面的两个链表：
+ +
在节点 c1 开始相交。
输入说明：
+ +intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
l1 - 第一个训练计划链表
l2 - 第二个训练计划链表
skip1 - 在 l1 中（从头节点开始）跳到交叉节点的节点数
skip2 - 在 l2 中（从头节点开始）跳到交叉节点的节点数
程序将根据这些输入创建链式数据结构，并将两个头节点 head1 和 head2 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案 。
+ +
示例 1：
+ +
+输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 +输出：Reference of the node with value = 8 +解释：第一个正式训练项目编号为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 ++ +
+ +
示例 2：
+ +
+输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 +输出：Reference of the node with value = 2 +解释：第一个正式训练项目编号为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 ++ +
+ +
示例 3：
+ +
+输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 +输出：null +解释：两套计划完全不同，返回 null。从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 ++ +
+ +
注意：
+ +null.+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 172.\347\273\237\350\256\241\347\233\256\346\240\207\346\210\220\347\273\251\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md" "b/AllProblems/LCR 172.\347\273\237\350\256\241\347\233\256\346\240\207\346\210\220\347\273\251\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md" new file mode 100644 index 00000000000..6f7a9e8355b --- /dev/null +++ "b/AllProblems/LCR 172.\347\273\237\350\256\241\347\233\256\346\240\207\346\210\220\347\273\251\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md" @@ -0,0 +1,45 @@ +--- +title: LCR 172.统计目标成绩的出现次数 +date: 2023-10-10 14-43-50 +tags: [题解, LeetCode, 简单, 数组, 二分查找] +--- + +# 【LetMeFly】LCR 172.统计目标成绩的出现次数 + +力扣题目链接：[https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/](https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/) + +
某班级考试成绩按非严格递增顺序记录于整数数组 scores，请返回目标成绩 target 的出现次数。
+ +
示例 1：
+ ++输入: scores = [2, 2, 3, 4, 4, 4, 5, 6, 6, 8], target = 4 +输出: 3+ +
示例 2：
+ ++输入: scores = [1, 2, 3, 5, 7, 9], target = 6 +输出: 0+ +
+ +
提示：
+ +0 <= scores.length <= 105-109 <= scores[i] <= 109scores 是一个非递减数组-109 <= target <= 109+ +
注意：本题与主站 34 题相同（仅返回值不同）：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 173.\347\202\271\345\220\215.md" "b/AllProblems/LCR 173.\347\202\271\345\220\215.md" new file mode 100644 index 00000000000..fd9425ca10b --- /dev/null +++ "b/AllProblems/LCR 173.\347\202\271\345\220\215.md" @@ -0,0 +1,35 @@ +--- +title: LCR 173.点名 +date: 2023-10-10 14-43-50 +tags: [题解, LeetCode, 简单, 位运算, 数组, 哈希表, 数学, 二分查找] +--- + +# 【LetMeFly】LCR 173.点名 + +力扣题目链接：[https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/](https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/) + +
某班级 n 位同学的学号为 0 ~ n-1。点名结果记录于升序数组 records。假定仅有一位同学缺席，请返回他的学号。
+ +
示例 1:
+ ++输入: records = [0,1,2,3,5] +输出: 4 ++ +
示例 2:
+ ++输入: records = [0, 1, 2, 3, 4, 5, 6, 8] +输出: 7+ +
+ +
提示：
+ +1 <= records.length <= 10000
某公司组织架构以二叉搜索树形式记录，节点值为处于该职位的员工编号。请返回第 cnt 大的员工编号。
+ +
示例 1：
+ +
+输入：root = [7, 3, 9, 1, 5], cnt = 2 + 7 + / \ + 3 9 + / \ + 1 5 +输出：7 ++ +
示例 2：
+ +
+输入: root = [10, 5, 15, 2, 7, null, 20, 1, null, 6, 8], cnt = 4 + 10 + / \ + 5 15 + / \ \ + 2 7 20 + / / \ + 1 6 8 +输出: 8+ +
+ +
提示：
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 175.\350\256\241\347\256\227\344\272\214\345\217\211\346\240\221\347\232\204\346\267\261\345\272\246.md" "b/AllProblems/LCR 175.\350\256\241\347\256\227\344\272\214\345\217\211\346\240\221\347\232\204\346\267\261\345\272\246.md" new file mode 100644 index 00000000000..b9eec0609b1 --- /dev/null +++ "b/AllProblems/LCR 175.\350\256\241\347\256\227\344\272\214\345\217\211\346\240\221\347\232\204\346\267\261\345\272\246.md" @@ -0,0 +1,38 @@ +--- +title: LCR 175.计算二叉树的深度 +date: 2023-10-10 14-43-51 +tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 广度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 175.计算二叉树的深度 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-shu-de-shen-du-lcof/](https://leetcode.cn/problems/er-cha-shu-de-shen-du-lcof/) + +
某公司架构以二叉树形式记录，请返回该公司的层级数。
+ ++ +
示例 1：
+ +
+输入：root = [1, 2, 2, 3, null, null, 5, 4, null, null, 4] +输出: 4 +解释: 上面示例中的二叉树的最大深度是 4，沿着路径 1 -> 2 -> 3 -> 4 或 1 -> 2 -> 5 -> 4 到达叶节点的最长路径上有 4 个节点。 ++ +
+ +
提示：
+ +节点总数 <= 10000注意：本题与主站 104 题相同：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 176.\345\210\244\346\226\255\346\230\257\345\220\246\344\270\272\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md" "b/AllProblems/LCR 176.\345\210\244\346\226\255\346\230\257\345\220\246\344\270\272\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md" new file mode 100644 index 00000000000..5acbb5385d8 --- /dev/null +++ "b/AllProblems/LCR 176.\345\210\244\346\226\255\346\230\257\345\220\246\344\270\272\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md" @@ -0,0 +1,44 @@ +--- +title: LCR 176.判断是否为平衡二叉树 +date: 2023-10-10 14-43-52 +tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 176.判断是否为平衡二叉树 + +力扣题目链接：[https://leetcode.cn/problems/ping-heng-er-cha-shu-lcof/](https://leetcode.cn/problems/ping-heng-er-cha-shu-lcof/) + +
输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
+ ++ +
示例 1:
+ ++输入：root = [3,9,20,null,null,15,7] +输出：true +解释：如下图 ++ +
+
+示例 2:
+输入：root = [1,2,2,3,3,null,null,4,4] +输出：false +解释：如下图 ++
++ +
提示：
+ +0 <= 树的结点个数 <= 10000注意：本题与主站 110 题相同：https://leetcode-cn.com/problems/balanced-binary-tree/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 177.\346\222\236\350\211\262\346\220\255\351\205\215.md" "b/AllProblems/LCR 177.\346\222\236\350\211\262\346\220\255\351\205\215.md" new file mode 100644 index 00000000000..1d41256857e --- /dev/null +++ "b/AllProblems/LCR 177.\346\222\236\350\211\262\346\220\255\351\205\215.md" @@ -0,0 +1,37 @@ +--- +title: LCR 177.撞色搭配 +date: 2023-10-10 14-43-52 +tags: [题解, LeetCode, 中等, 位运算, 数组] +--- + +# 【LetMeFly】LCR 177.撞色搭配 + +力扣题目链接：[https://leetcode.cn/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/](https://leetcode.cn/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/) + +整数数组 sockets 记录了一个袜子礼盒的颜色分布情况，其中 sockets[i] 表示该袜子的颜色编号。礼盒中除了一款撞色搭配的袜子，每种颜色的袜子均有两只。请设计一个程序，在时间复杂度 O(n)，空间复杂度O(1) 内找到这双撞色搭配袜子的两个颜色编号。
+ +
示例 1：
+ ++输入：sockets = [4, 5, 2, 4, 6, 6] +输出：[2,5] 或 [5,2] ++ +
示例 2：
+ ++输入：sockets = [1, 2, 4, 1, 4, 3, 12, 3] +输出：[2,12] 或 [12,2]+ +
+ +
提示：
+ +2 <= sockets.length <= 10000教学过程中，教练示范一次，学员跟做三次。该过程被混乱剪辑后，记录于数组 actions，其中 actions[i] 表示做出该动作的人员编号。请返回教练的编号。
+ +
示例 1：
+ ++输入：actions = [5, 7, 5, 5] +输出：7 ++ +
示例 2：
+ ++输入：actions = [12, 1, 6, 12, 6, 12, 6] +输出：1 ++ +
+ +
提示：
+ +1 <= actions.length <= 100001 <= actions[i] < 2^31购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。
示例 1：
+ ++输入：price = [3, 9, 12, 15], target = 18 +输出：[3,15] 或者 [15,3] ++ +
示例 2：
+ ++输入：price = [8, 21, 27, 34, 52, 66], target = 61 +输出：[27,34] 或者 [34,27] ++ +
+ +
提示：
+ +1 <= price.length <= 10^51 <= price[i] <= 10^61 <= target <= 2*10^6待传输文件被切分成多个部分，按照原排列顺序，每部分文件编号均为一个 正整数（至少含有两个文件）。传输要求为：连续文件编号总和为接收方指定数字 target 的所有文件。请返回所有符合该要求的文件传输组合列表。
注意，返回时需遵循以下规则：
+ ++ +
示例 1：
+ ++输入：target = 12 +输出：[[3, 4, 5]] +解释：在上述示例中，存在一个连续正整数序列的和为 12，为 [3, 4, 5]。 ++ +
示例 2：
+ ++输入：target = 18 +输出：[[3,4,5,6],[5,6,7]] +解释：在上述示例中，存在两个连续正整数序列的和分别为 18，分别为 [3, 4, 5, 6] 和 [5, 6, 7]。 ++ +
+ +
提示：
+ +1 <= target <= 10^5+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 181.\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215\345\217\215\350\275\254.md" "b/AllProblems/LCR 181.\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215\345\217\215\350\275\254.md" new file mode 100644 index 00000000000..30855619d08 --- /dev/null +++ "b/AllProblems/LCR 181.\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215\345\217\215\350\275\254.md" @@ -0,0 +1,60 @@ +--- +title: LCR 181.字符串中的单词反转 +date: 2023-10-10 14-43-53 +tags: [题解, LeetCode, 简单, 双指针, 字符串] +--- + +# 【LetMeFly】LCR 181.字符串中的单词反转 + +力扣题目链接：[https://leetcode.cn/problems/fan-zhuan-dan-ci-shun-xu-lcof/](https://leetcode.cn/problems/fan-zhuan-dan-ci-shun-xu-lcof/) + +
你在与一位习惯从右往左阅读的朋友发消息，他发出的文字顺序都与正常相反但单词内容正确，为了和他顺利交流你决定写一个转换程序，把他所发的消息 message 转换为正常语序。
注意：输入字符串 message 中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
+ +
示例 1：
+ ++输入: message = "+ +the sky is blue" +输出: "blue is sky the" +
示例 2：
+ ++输入: message = " hello world! " +输出: "world! hello" +解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。 ++ +
示例 3：
+ ++输入: message = "a good example" +输出: "example good a" +解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。 ++ +
+ +
提示：
+ +1 <= message.length <= 10^4message 中包含英文大小写字母、空格和数字message 中至少有一个单词注意：
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 182.\345\212\250\346\200\201\345\217\243\344\273\244.md" "b/AllProblems/LCR 182.\345\212\250\346\200\201\345\217\243\344\273\244.md" new file mode 100644 index 00000000000..9f85add1d1f --- /dev/null +++ "b/AllProblems/LCR 182.\345\212\250\346\200\201\345\217\243\344\273\244.md" @@ -0,0 +1,47 @@ +--- +title: LCR 182.动态口令 +date: 2023-10-10 14-43-54 +tags: [题解, LeetCode, 简单, 数学, 双指针, 字符串] +--- + +# 【LetMeFly】LCR 182.动态口令 + +力扣题目链接：[https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/](https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/) + +
某公司门禁密码使用动态口令技术。初始密码为字符串 password，密码更新均遵循以下步骤：
targetpassword 前 target 个字符按原顺序移动至字符串末尾请返回更新后的密码字符串。
+ ++ +
示例 1：
+ ++输入: password = "s3cur1tyC0d3", target = 4 +输出: "r1tyC0d3s3cu" ++ +
示例 2：
+ ++输入: password = "lrloseumgh", target = 6 +输出: "umghlrlose" ++ +
+ +
提示：
+ +1 <= target < password.length <= 10000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 183.\346\234\233\350\277\234\351\225\234\344\270\255\346\234\200\351\253\230\347\232\204\346\265\267\346\213\224.md" "b/AllProblems/LCR 183.\346\234\233\350\277\234\351\225\234\344\270\255\346\234\200\351\253\230\347\232\204\346\265\267\346\213\224.md" new file mode 100644 index 00000000000..97fae2b5603 --- /dev/null +++ "b/AllProblems/LCR 183.\346\234\233\350\277\234\351\225\234\344\270\255\346\234\200\351\253\230\347\232\204\346\265\267\346\213\224.md" @@ -0,0 +1,43 @@ +--- +title: LCR 183.望远镜中最高的海拔 +date: 2023-10-10 14-43-54 +tags: [题解, LeetCode, 困难, 队列, 滑动窗口, 单调队列, 堆（优先队列）] +--- + +# 【LetMeFly】LCR 183.望远镜中最高的海拔 + +力扣题目链接：[https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/](https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/) + +
科技馆内有一台虚拟观景望远镜，它可以用来观测特定纬度地区的地形情况。该纬度的海拔数据记于数组 heights ，其中 heights[i] 表示对应位置的海拔高度。请找出并返回望远镜视野范围 limit 内，可以观测到的最高海拔值。
示例 1：
+ ++输入：heights = [14,2,27,-5,28,13,39], limit = 3 +输出：[27,27,28,28,39] +解释： + 滑动窗口的位置 最大值 +--------------- ----- +[14 2 27] -5 28 13 39 27 +14 [2 27 -5] 28 13 39 27 +14 2 [27 -5 28] 13 39 28 +14 2 27 [-5 28 13] 39 28 +14 2 27 -5 [28 13 39] 39+ +
+ +
提示：
+ +你可以假设输入总是有效的，在输入数组不为空的情况下：
+ +1 <= limit <= heights.length-10000 <= heights[i] <= 10000注意：本题与主站 239 题相同：https://leetcode-cn.com/problems/sliding-window-maximum/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 184.\350\256\276\350\256\241\350\207\252\345\212\251\347\273\223\347\256\227\347\263\273\347\273\237.md" "b/AllProblems/LCR 184.\350\256\276\350\256\241\350\207\252\345\212\251\347\273\223\347\256\227\347\263\273\347\273\237.md" new file mode 100644 index 00000000000..9e8c77e4ab2 --- /dev/null +++ "b/AllProblems/LCR 184.\350\256\276\350\256\241\350\207\252\345\212\251\347\273\223\347\256\227\347\263\273\347\273\237.md" @@ -0,0 +1,55 @@ +--- +title: LCR 184.设计自助结算系统 +date: 2023-10-10 14-43-55 +tags: [题解, LeetCode, 中等, 设计, 队列, 单调队列] +--- + +# 【LetMeFly】LCR 184.设计自助结算系统 + +力扣题目链接：[https://leetcode.cn/problems/dui-lie-de-zui-da-zhi-lcof/](https://leetcode.cn/problems/dui-lie-de-zui-da-zhi-lcof/) + +
请设计一个自助结账系统，该系统需要通过一个队列来模拟顾客通过购物车的结算过程，需要实现的功能有：
+ +get_max()：获取结算商品中的最高价格，如果队列为空，则返回 -1add(value)：将价格为 value 的商品加入待结算商品队列的尾部remove()：移除第一个待结算的商品价格，如果队列为空，则返回 -1注意，为保证该系统运转高效性，以上函数的均摊时间复杂度均为 O(1)
+ ++ +
示例 1：
+ ++输入: +["Checkout","add","add","get_max","remove","get_max"] +[[],[4],[7],[],[],[]] + +输出: [null,null,null,7,4,7] ++ +
示例 2：
+ ++输入: +["Checkout","remove","get_max"] +[[],[],[]] + +输出: [null,-1,-1] ++ +
+ +
提示：
+ +1 <= get_max, add, remove 的总操作数 <= 100001 <= value <= 10^5+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 185.\347\273\237\350\256\241\347\273\223\346\236\234\346\246\202\347\216\207.md" "b/AllProblems/LCR 185.\347\273\237\350\256\241\347\273\223\346\236\234\346\246\202\347\216\207.md" new file mode 100644 index 00000000000..c3a4e5e9375 --- /dev/null +++ "b/AllProblems/LCR 185.\347\273\237\350\256\241\347\273\223\346\236\234\346\246\202\347\216\207.md" @@ -0,0 +1,42 @@ +--- +title: LCR 185.统计结果概率 +date: 2023-10-10 14-43-55 +tags: [题解, LeetCode, 中等, 数学, 动态规划, 概率与统计] +--- + +# 【LetMeFly】LCR 185.统计结果概率 + +力扣题目链接：[https://leetcode.cn/problems/nge-tou-zi-de-dian-shu-lcof/](https://leetcode.cn/problems/nge-tou-zi-de-dian-shu-lcof/) + +
你选择掷出 num 个色子，请返回所有点数总和的概率。
你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 num 个骰子所能掷出的点数集合中第 i 小的那个的概率。
+ +
示例 1：
+ ++输入：num = 3 +输出：[0.00463,0.01389,0.02778,0.04630,0.06944,0.09722,0.11574,0.12500,0.12500,0.11574,0.09722,0.06944,0.04630,0.02778,0.01389,0.00463] ++ +
示例 2：
+ ++输入：num = 5 +输出:[0.00013,0.00064,0.00193,0.00450,0.00900,0.01620,0.02636,0.03922,0.05401,0.06944,0.08372,0.09452,0.10031,0.10031,0.09452,0.08372,0.06944,0.05401,0.03922,0.02636,0.01620,0.00900,0.00450,0.00193,0.00064,0.00013] ++ +
+ +
提示：
+ +1 <= num <= 11+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 186.\346\226\207\347\211\251\346\234\235\344\273\243\345\210\244\346\226\255.md" "b/AllProblems/LCR 186.\346\226\207\347\211\251\346\234\235\344\273\243\345\210\244\346\226\255.md" new file mode 100644 index 00000000000..ea3bcd53b9f --- /dev/null +++ "b/AllProblems/LCR 186.\346\226\207\347\211\251\346\234\235\344\273\243\345\210\244\346\226\255.md" @@ -0,0 +1,43 @@ +--- +title: LCR 186.文物朝代判断 +date: 2023-10-10 14-43-56 +tags: [题解, LeetCode, 简单, 数组, 排序] +--- + +# 【LetMeFly】LCR 186.文物朝代判断 + +力扣题目链接：[https://leetcode.cn/problems/bu-ke-pai-zhong-de-shun-zi-lcof/](https://leetcode.cn/problems/bu-ke-pai-zhong-de-shun-zi-lcof/) + +
展览馆展出来自 13 个朝代的文物，每排展柜展出 5 个文物。某排文物的摆放情况记录于数组 places，其中 places[i] 表示处于第 i 位文物的所属朝代编号。其中，编号为 0 的朝代表示未知朝代。请判断并返回这排文物的所属朝代编号是否连续（如遇未知朝代可算作连续情况）。
+ +
示例 1：
+ ++输入: places = [0, 6, 9, 0, 7] +输出: True ++ +
+ +
示例 2：
+ ++输入: places = [7, 8, 9, 10, 11] +输出: True ++ +
+ +
提示：
+ +places.length = 50 <= places[i] <= 13+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 187.\347\240\264\345\206\260\346\270\270\346\210\217.md" "b/AllProblems/LCR 187.\347\240\264\345\206\260\346\270\270\346\210\217.md" new file mode 100644 index 00000000000..b02e5a31361 --- /dev/null +++ "b/AllProblems/LCR 187.\347\240\264\345\206\260\346\270\270\346\210\217.md" @@ -0,0 +1,41 @@ +--- +title: LCR 187.破冰游戏 +date: 2023-10-10 14-43-56 +tags: [题解, LeetCode, 简单, 递归, 数学] +--- + +# 【LetMeFly】LCR 187.破冰游戏 + +力扣题目链接：[https://leetcode.cn/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/](https://leetcode.cn/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/) + +
社团共有 num 为成员参与破冰游戏，编号为 0 ~ num-1。成员们按照编号顺序围绕圆桌而坐。社长抽取一个数字 target，从 0 号成员起开始计数，排在第 target 位的成员离开圆桌，且成员离开后从下一个成员开始计数。请返回游戏结束时最后一位成员的编号。
+ +
示例 1：
+ ++输入：num = 7, target = 4 +输出：1 ++ +
示例 2：
+ ++输入：num = 12, target = 5 +输出：0 ++ +
+ +
提示：
+ +1 <= num <= 10^51 <= target <= 10^6+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 188.\344\271\260\345\215\226\350\212\257\347\211\207\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/AllProblems/LCR 188.\344\271\260\345\215\226\350\212\257\347\211\207\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" new file mode 100644 index 00000000000..b626a1d3907 --- /dev/null +++ "b/AllProblems/LCR 188.\344\271\260\345\215\226\350\212\257\347\211\207\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" @@ -0,0 +1,49 @@ +--- +title: LCR 188.买卖芯片的最佳时机 +date: 2023-10-10 14-43-57 +tags: [题解, LeetCode, 中等, 数组, 动态规划] +--- + +# 【LetMeFly】LCR 188.买卖芯片的最佳时机 + +力扣题目链接：[https://leetcode.cn/problems/gu-piao-de-zui-da-li-run-lcof/](https://leetcode.cn/problems/gu-piao-de-zui-da-li-run-lcof/) + +
数组 prices 记录了某芯片近期的交易价格，其中 prices[i] 表示的 i 天该芯片的价格。你只能选择 某一天 买入芯片，并选择在 未来的某一个不同的日子 卖出该芯片。请设计一个算法计算并返回你从这笔交易中能获取的最大利润。
如果你不能获取任何利润，返回 0。
+ ++ +
示例 1：
+ ++输入：prices = [3, 6, 2, 9, 8, 5] +输出：7 +解释：在第 3 天（芯片价格 = 2）买入，在第 4 天（芯片价格 = 9）卖出，最大利润 = 9 - 2 = 7。 ++ +
示例 2：
+ ++输入：prices = [8, 12, 15, 7, 3, 10] +输出：7 +解释：在第 5 天（芯片价格 = 3）买入，在第 6 天（芯片价格 = 10）卖出，最大利润 = 10 - 3 = 7。 ++ +
+ +
提示：
+ +0 <= prices.length <= 10^50 <= prices[i] <= 10^4+ +
注意：本题与主站 121 题相同：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 189.\350\256\276\350\256\241\346\234\272\346\242\260\347\264\257\345\212\240\345\231\250.md" "b/AllProblems/LCR 189.\350\256\276\350\256\241\346\234\272\346\242\260\347\264\257\345\212\240\345\231\250.md" new file mode 100644 index 00000000000..de16e909acd --- /dev/null +++ "b/AllProblems/LCR 189.\350\256\276\350\256\241\346\234\272\346\242\260\347\264\257\345\212\240\345\231\250.md" @@ -0,0 +1,40 @@ +--- +title: LCR 189.设计机械累加器 +date: 2023-10-10 14-43-57 +tags: [题解, LeetCode, 中等, 位运算, 递归, 脑筋急转弯] +--- + +# 【LetMeFly】LCR 189.设计机械累加器 + +力扣题目链接：[https://leetcode.cn/problems/qiu-12n-lcof/](https://leetcode.cn/problems/qiu-12n-lcof/) + +
请设计一个机械累加器，计算从 1、2... 一直累加到目标数值 target 的总和。注意这是一个只能进行加法操作的程序，不具备乘除、if-else、switch-case、for 循环、while 循环，及条件判断语句等高级功能。
+ +
示例 1：
+ ++输入: target = 5 +输出: 15 ++ +
示例 2：
+ ++输入: target = 7 +输出: 28 ++ +
+ +
提示：
+ +1 <= target <= 10000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 190.\345\212\240\345\257\206\350\277\220\347\256\227.md" "b/AllProblems/LCR 190.\345\212\240\345\257\206\350\277\220\347\256\227.md" new file mode 100644 index 00000000000..b98cb9c9c4c --- /dev/null +++ "b/AllProblems/LCR 190.\345\212\240\345\257\206\350\277\220\347\256\227.md" @@ -0,0 +1,42 @@ +--- +title: LCR 190.加密运算 +date: 2023-10-10 14-43-57 +tags: [题解, LeetCode, 简单, 位运算, 数学] +--- + +# 【LetMeFly】LCR 190.加密运算 + +力扣题目链接：[https://leetcode.cn/problems/bu-yong-jia-jian-cheng-chu-zuo-jia-fa-lcof/](https://leetcode.cn/problems/bu-yong-jia-jian-cheng-chu-zuo-jia-fa-lcof/) + +
计算机安全专家正在开发一款高度安全的加密通信软件，需要在进行数据传输时对数据进行加密和解密操作。假定 dataA 和 dataB 分别为随机抽样的两次通信的数据量：
请不使用四则运算符的情况下实现一个函数计算两次通信的数据量之和（三种情况均需被统计），以确保在数据传输过程中的高安全性和保密性。
+ ++ +
示例 1:
+ ++输入：dataA = 5, dataB = -1 +输出：4 ++ +
+ +
提示：
+ +dataA 和 dataB 均可能是负数或 0+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 191.\346\214\211\350\247\204\345\210\231\350\256\241\347\256\227\347\273\237\350\256\241\347\273\223\346\236\234.md" "b/AllProblems/LCR 191.\346\214\211\350\247\204\345\210\231\350\256\241\347\256\227\347\273\237\350\256\241\347\273\223\346\236\234.md" new file mode 100644 index 00000000000..e17d46e85ee --- /dev/null +++ "b/AllProblems/LCR 191.\346\214\211\350\247\204\345\210\231\350\256\241\347\256\227\347\273\237\350\256\241\347\273\223\346\236\234.md" @@ -0,0 +1,34 @@ +--- +title: LCR 191.按规则计算统计结果 +date: 2023-10-10 14-43-58 +tags: [题解, LeetCode, 中等, 数组, 前缀和] +--- + +# 【LetMeFly】LCR 191.按规则计算统计结果 + +力扣题目链接：[https://leetcode.cn/problems/gou-jian-cheng-ji-shu-zu-lcof/](https://leetcode.cn/problems/gou-jian-cheng-ji-shu-zu-lcof/) + +
为了深入了解这些生物群体的生态特征，你们进行了大量的实地观察和数据采集。数组 arrayA 记录了各个生物群体数量数据，其中 arrayA[i] 表示第 i 个生物群体的数量。请返回一个数组 arrayB，该数组为基于数组 arrayA 中的数据计算得出的结果，其中 arrayB[i] 表示将第 i 个生物群体的数量从总体中排除后的其他数量的乘积。
+ +
示例 1：
+ ++输入：arrayA = [2, 4, 6, 8, 10] +输出：[1920, 960, 640, 480, 384] ++ +
+ +
提示：
+ +arrayA.length <= 100000+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 192.\346\212\212\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\210\220\346\225\264\346\225\260 (atoi).md" "b/AllProblems/LCR 192.\346\212\212\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\210\220\346\225\264\346\225\260 (atoi).md" new file mode 100644 index 00000000000..f10ff00fdb1 --- /dev/null +++ "b/AllProblems/LCR 192.\346\212\212\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\210\220\346\225\264\346\225\260 (atoi).md" @@ -0,0 +1,96 @@ +--- +title: LCR 192.把字符串转换成整数 (atoi) +date: 2023-10-10 14-43-58 +tags: [题解, LeetCode, 中等, 字符串] +--- + +# 【LetMeFly】LCR 192.把字符串转换成整数 (atoi) + +力扣题目链接：[https://leetcode.cn/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof/](https://leetcode.cn/problems/ba-zi-fu-chuan-zhuan-huan-cheng-zheng-shu-lcof/) + +
请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。
函数 myAtoi(string s) 的算法如下：
0 。必要时更改符号（从步骤 2 开始）。[−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。注意：
+ +' ' 。+ +
示例 1：
+ ++输入：s = "42" +输出：42 +解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。 +第 1 步："42"（当前没有读入字符，因为没有前导空格） + ^ +第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'） + ^ +第 3 步："42"（读入 "42"） + ^ +解析得到整数 42 。 +由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。+ +
示例 2：
+ ++输入：s = " -42" +输出：-42 +解释： +第 1 步：" -42"（读入前导空格，但忽视掉） + ^ +第 2 步：" -42"（读入 '-' 字符，所以结果应该是负数） + ^ +第 3 步：" -42"（读入 "42"） + ^ +解析得到整数 -42 。 +由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。 ++ +
示例 3：
+ ++输入：s = "4193 with words" +输出：4193 +解释： +第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格） + ^ +第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'） + ^ +第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止） + ^ +解析得到整数 4193 。 +由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。 ++ +
+ +
提示：
+ +0 <= s.length <= 200s 由英文字母（大写和小写）、数字（0-9）、' '、'+'、'-' 和 '.' 组成+ +
注意：本题与主站 8 题相同：https://leetcode-cn.com/problems/string-to-integer-atoi/
+ ++ + + \ No newline at end of file diff --git "a/AllProblems/LCR 193.\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/AllProblems/LCR 193.\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 00000000000..650b32bb206 --- /dev/null +++ "b/AllProblems/LCR 193.\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,46 @@ +--- +title: LCR 193.二叉搜索树的最近公共祖先 +date: 2023-10-10 14-43-59 +tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 二叉搜索树, 二叉树] +--- + +# 【LetMeFly】LCR 193.二叉搜索树的最近公共祖先 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/](https://leetcode.cn/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/) + +
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
+ +百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
+ +例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
+ +
+ +
示例 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, 因为根据定义最近公共祖先节点可以为节点本身。
+ +
说明:
+ +注意：本题与主站 235 题相同：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
+ + + \ No newline at end of file diff --git "a/AllProblems/LCR 194.\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/AllProblems/LCR 194.\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 00000000000..f3633595c2f --- /dev/null +++ "b/AllProblems/LCR 194.\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,47 @@ +--- +title: LCR 194.二叉树的最近公共祖先 +date: 2023-10-10 14-43-59 +tags: [题解, LeetCode, 简单, 树, 深度优先搜索, 二叉树] +--- + +# 【LetMeFly】LCR 194.二叉树的最近公共祖先 + +力扣题目链接：[https://leetcode.cn/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/](https://leetcode.cn/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/) + +给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
+ +百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
+ +例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
+ +
+ +
示例 1:
+ +输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 +输出: 3 +解释: 节点+ +5和节点1的最近公共祖先是节点3。+
示例 2:
+ +输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 +输出: 5 +解释: 节点+ +5和节点4的最近公共祖先是节点5。因为根据定义最近公共祖先节点可以为节点本身。 +
+ +
说明:
+ +注意：本题与主站 236 题相同：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/
+ + + \ No newline at end of file