- 
+ 
## 介绍
@@ -20,7 +21,7 @@
## 站点
-https://leetcode.doocs.org
+
-
-
-
-> "_You help the developer community practice for interviews, and there is nothing better we could ask for._" -- [Alan Yessenbayev](https://opencollective.com/alan-yessenbayev)
-
## 版权
本项目著作权归 [GitHub 开源社区 Doocs](https://github.com/doocs) 所有，商业转载请联系 @yanglbme 获得授权，非商业转载请注明出处。
-## 联系我们
+## 联系我们 & 支持项目
欢迎各位小伙伴们添加 @yanglbme 的个人微信（微信号：YLB0109），备注 「**leetcode**」。后续我们会创建算法、技术相关的交流群，大家一起交流学习，分享经验，共同进步。
-| 
|
-| ------------------------------------------------------------------------------------------------------------------------------ |
+如果你觉得这个项目对你有帮助，也欢迎通过微信扫码赞赏我们 ☕️～
+
+| | 
|
+| -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
## 许可证
diff --git a/README_EN.md b/README_EN.md
index 002039e552df8..3b461059720a9 100644
--- a/README_EN.md
+++ b/README_EN.md
@@ -9,7 +9,8 @@
-
+
## Introduction
@@ -184,16 +185,7 @@ I'm looking for long-term contributors/partners to this repo! Send me [PRs](http
1. See [CONTRIBUTING](https://github.com/doocs/.github/blob/main/CONTRIBUTING.md) or [GitHub Help](https://help.github.com/en) for more details.
-
-
-
-> "_You help the developer community practice for interviews, and there is nothing better we could ask for._" -- [Alan Yessenbayev](https://opencollective.com/alan-yessenbayev)
-
## Copyright
The copyright of this project belongs to [Doocs](https://github.com/doocs) community. For commercial reprints, please contact [@yanglbme](mailto:contact@yanglibin.info) for authorization. For non-commercial reprints, please indicate the source.
+## Support Us
+
+If you find this project helpful, consider supporting us by buying us a coffee ☕️
+👉 [https://paypal.me/yanglbme](https://paypal.me/yanglbme)
+
## Contact Us
We welcome everyone to add @yanglbme's personal WeChat (WeChat ID: YLB0109), with the note "leetcode". In the future, we will create algorithm and technology related discussion groups, where we can learn and share experiences together, and make progress together.
diff --git a/images/pr-en.svg b/images/pr-en.svg
new file mode 100644
index 0000000000000..7465d268ffbf0
--- /dev/null
+++ b/images/pr-en.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/images/pr.svg b/images/pr.svg
new file mode 100644
index 0000000000000..22e333230e98e
--- /dev/null
+++ b/images/pr.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/images/starcharts.svg b/images/starcharts.svg
index c5dd73ce60b1b..fa40a02040215 100644
--- a/images/starcharts.svg
+++ b/images/starcharts.svg
@@ -1,4 +1,4 @@
-
+
\ No newline at end of file
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 946 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 947 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 948 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 16
+L 949 15
+L 949 15
+L 949 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15
+L 950 15" style="stroke-width:2;stroke:rgba(129,199,239,1.0);fill:none"/>
\ No newline at end of file
diff --git a/images/support1.jpg b/images/support1.jpg
new file mode 100644
index 0000000000000..5d476dd5a74c4
Binary files /dev/null and b/images/support1.jpg differ
diff --git a/requirements.txt b/requirements.txt
index a861898c020f6..b87c0a5b8c9e6 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
black==24.3.0
-Requests==2.32.0
\ No newline at end of file
+Requests==2.32.4
\ No newline at end of file
diff --git a/solution/0000-0099/0001.Two Sum/README.md b/solution/0000-0099/0001.Two Sum/README.md
index f9a38ce75e350..88c20df42f7fa 100644
--- a/solution/0000-0099/0001.Two Sum/README.md
+++ b/solution/0000-0099/0001.Two Sum/README.md
@@ -353,6 +353,55 @@ class Solution {
}
```
+#### C
+
+```c
+#include 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
-
@@ -555,6 +555,48 @@ class Solution { } ``` +#### C + +```c +char* d[] = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; + +char** letterCombinations(char* digits, int* returnSize) { + if (!*digits) { + *returnSize = 0; + return NULL; + } + + int size = 1; + char** ans = (char**) malloc(sizeof(char*)); + ans[0] = strdup(""); + + for (int x = 0; digits[x]; ++x) { + char* s = d[digits[x] - '2']; + int len = strlen(s); + char** t = (char**) malloc(sizeof(char*) * size * len); + int tSize = 0; + + for (int i = 0; i < size; ++i) { + for (int j = 0; j < len; ++j) { + int oldLen = strlen(ans[i]); + char* tmp = (char*) malloc(oldLen + 2); + strcpy(tmp, ans[i]); + tmp[oldLen] = s[j]; + tmp[oldLen + 1] = '\0'; + t[tSize++] = tmp; + } + free(ans[i]); + } + free(ans); + ans = t; + size = tSize; + } + + *returnSize = size; + return ans; +} +``` + diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/README_EN.md b/solution/0000-0099/0017.Letter Combinations of a Phone Number/README_EN.md index ffad07737163e..dba840d7bd8ee 100644 --- a/solution/0000-0099/0017.Letter Combinations of a Phone Number/README_EN.md +++ b/solution/0000-0099/0017.Letter Combinations of a Phone Number/README_EN.md @@ -551,6 +551,48 @@ class Solution { } ``` +#### C + +```c +char* d[] = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; + +char** letterCombinations(char* digits, int* returnSize) { + if (!*digits) { + *returnSize = 0; + return NULL; + } + + int size = 1; + char** ans = (char**) malloc(sizeof(char*)); + ans[0] = strdup(""); + + for (int x = 0; digits[x]; ++x) { + char* s = d[digits[x] - '2']; + int len = strlen(s); + char** t = (char**) malloc(sizeof(char*) * size * len); + int tSize = 0; + + for (int i = 0; i < size; ++i) { + for (int j = 0; j < len; ++j) { + int oldLen = strlen(ans[i]); + char* tmp = (char*) malloc(oldLen + 2); + strcpy(tmp, ans[i]); + tmp[oldLen] = s[j]; + tmp[oldLen + 1] = '\0'; + t[tSize++] = tmp; + } + free(ans[i]); + } + free(ans); + ans = t; + size = tSize; + } + + *returnSize = size; + return ans; +} +``` + diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.c b/solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.c new file mode 100644 index 0000000000000..e02c971a3a8c6 --- /dev/null +++ b/solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.c @@ -0,0 +1,37 @@ +char* d[] = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; + +char** letterCombinations(char* digits, int* returnSize) { + if (!*digits) { + *returnSize = 0; + return NULL; + } + + int size = 1; + char** ans = (char**) malloc(sizeof(char*)); + ans[0] = strdup(""); + + for (int x = 0; digits[x]; ++x) { + char* s = d[digits[x] - '2']; + int len = strlen(s); + char** t = (char**) malloc(sizeof(char*) * size * len); + int tSize = 0; + + for (int i = 0; i < size; ++i) { + for (int j = 0; j < len; ++j) { + int oldLen = strlen(ans[i]); + char* tmp = (char*) malloc(oldLen + 2); + strcpy(tmp, ans[i]); + tmp[oldLen] = s[j]; + tmp[oldLen + 1] = '\0'; + t[tSize++] = tmp; + } + free(ans[i]); + } + free(ans); + ans = t; + size = tSize; + } + + *returnSize = size; + return ans; +} diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1200px-telephone-keypad2svg.png b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1200px-telephone-keypad2svg.png new file mode 100644 index 0000000000000..cbf69ae96598d Binary files /dev/null and b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1200px-telephone-keypad2svg.png differ diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1752723054-mfIHZs-image.png b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1752723054-mfIHZs-image.png new file mode 100644 index 0000000000000..e4d9a76bfe05c Binary files /dev/null and b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/1752723054-mfIHZs-image.png differ diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/17_telephone_keypad.png b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/17_telephone_keypad.png deleted file mode 100644 index ef7a0bffee3e2..0000000000000 Binary files a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/17_telephone_keypad.png and /dev/null differ diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-Telephone-keypad2.svg.png b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-Telephone-keypad2.svg.png deleted file mode 100644 index 38764028d1835..0000000000000 Binary files a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-Telephone-keypad2.svg.png and /dev/null differ diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-telephone-keypad2svg.png b/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-telephone-keypad2svg.png deleted file mode 100644 index 38764028d1835..0000000000000 Binary files a/solution/0000-0099/0017.Letter Combinations of a Phone Number/images/200px-telephone-keypad2svg.png and /dev/null differ diff --git a/solution/0000-0099/0020.Valid Parentheses/README.md b/solution/0000-0099/0020.Valid Parentheses/README.md index e4c364fe798a6..d09f9eda8a015 100644 --- a/solution/0000-0099/0020.Valid Parentheses/README.md +++ b/solution/0000-0099/0020.Valid Parentheses/README.md @@ -61,6 +61,14 @@ tags:
输出：true
+示例 5：
+ +输入：s = "([)]"
+ +输出：false
+
提示：
diff --git a/solution/0000-0099/0020.Valid Parentheses/README_EN.md b/solution/0000-0099/0020.Valid Parentheses/README_EN.md index cf0fc8a16deba..24c94a545cabb 100644 --- a/solution/0000-0099/0020.Valid Parentheses/README_EN.md +++ b/solution/0000-0099/0020.Valid Parentheses/README_EN.md @@ -60,6 +60,14 @@ tags:Output: true
+Example 5:
+ +Input: s = "([)]"
+ +Output: false
+
Constraints:
diff --git a/solution/0000-0099/0023.Merge k Sorted Lists/README_EN.md b/solution/0000-0099/0023.Merge k Sorted Lists/README_EN.md index e7e07e00330c5..787342715e2e0 100644 --- a/solution/0000-0099/0023.Merge k Sorted Lists/README_EN.md +++ b/solution/0000-0099/0023.Merge k Sorted Lists/README_EN.md @@ -35,7 +35,7 @@ tags: 1->3->4, 2->6 ] -merging them into one sorted list: +merging them into one sorted linked list: 1->1->2->3->4->4->5->6 diff --git a/solution/0000-0099/0049.Group Anagrams/README.md b/solution/0000-0099/0049.Group Anagrams/README.md index 404f965482ca4..20255463c7d4d 100644 --- a/solution/0000-0099/0049.Group Anagrams/README.md +++ b/solution/0000-0099/0049.Group Anagrams/README.md @@ -19,30 +19,41 @@ tags: -给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
- -字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
+给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
示例 1:
-
-输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
-输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+ +输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+ +解释：
+ +"bat"。"nat" 和 "tan" 是字母异位词，因为它们可以重新排列以形成彼此。"ate" ，"eat" 和 "tea" 是字母异位词，因为它们可以重新排列以形成彼此。示例 2:
-
-输入: strs = [""]
-输出: [[""]]
-
+输入: strs = [""]
+ +输出: [[""]]
+示例 3:
-
-输入: strs = ["a"]
-输出: [["a"]]
+输入: strs = ["a"]
+ +输出: [["a"]]
+diff --git a/solution/0000-0099/0066.Plus One/README.md b/solution/0000-0099/0066.Plus One/README.md index 6c48f063bb6d3..a63a22c802037 100644 --- a/solution/0000-0099/0066.Plus One/README.md +++ b/solution/0000-0099/0066.Plus One/README.md @@ -17,11 +17,9 @@ tags: -
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
+给定一个表示 大整数 的整数数组 digits，其中 digits[i] 是整数的第 i 位数字。这些数字按从左到右，从最高位到最低位排列。这个大整数不包含任何前导 0。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
- -你可以假设除了整数 0 之外，这个整数不会以零开头。
+将大整数加 1，并返回结果的数字数组。
@@ -31,6 +29,8 @@ tags: 输入：digits = [1,2,3] 输出：[1,2,4] 解释：输入数组表示数字 123。 +加 1 后得到 123 + 1 = 124。 +因此，结果应该是 [1,2,4]。
示例 2：
@@ -39,6 +39,8 @@ tags: 输入：digits = [4,3,2,1] 输出：[4,3,2,2] 解释：输入数组表示数字 4321。 +加 1 后得到 4321 + 1 = 4322。 +因此，结果应该是 [4,3,2,2]。示例 3：
@@ -58,6 +60,7 @@ tags:1 <= digits.length <= 1000 <= digits[i] <= 9digits 不包含任何前导 0。有效 二叉搜索树定义如下：
A valid BST is defined as follows:
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。
测试用例保证结果在 32 位有符号整数范围内。
diff --git a/solution/0100-0199/0118.Pascal's Triangle/README.md b/solution/0100-0199/0118.Pascal's Triangle/README.md index fd03f8d453b2d..d15d69697e1bf 100644 --- a/solution/0100-0199/0118.Pascal's Triangle/README.md +++ b/solution/0100-0199/0118.Pascal's Triangle/README.md @@ -57,7 +57,7 @@ tags: 我们先创建一个答案数组 $f$，然后将 $f$ 的第一行元素设为 $[1]$。接下来，我们从第二行开始，每一行的开头和结尾元素都是 $1$，其它 $f[i][j] = f[i - 1][j - 1] + f[i - 1][j]$。 -时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是行数。 +时间复杂度 $O(n^2)$，其中 $n$ 为给定的行数。忽略答案的空间消耗，空间复杂度 $O(1)$。 @@ -83,8 +83,8 @@ class Solution { for (int i = 0; i < numRows - 1; ++i) { List
提示:
gas.length == ncost.length == nn == gas.length == cost.length1 <= n <= 1050 <= gas[i], cost[i] <= 104n == gas.length == cost.length1 <= n <= 1050 <= gas[i], cost[i] <= 1041 个糖果。请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
@@ -203,6 +203,35 @@ function candy(ratings: number[]): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn candy(ratings: Vec-
查询 Employee 表中第 n 高的工资。如果没有第 n 个最高工资，查询结果应该为 null 。
编写一个解决方案查询 Employee 表中第 n 高的 不同 工资。如果少于 n 个不同工资，查询结果应该为 null 。
查询结果格式如下所示。
diff --git a/solution/0100-0199/0177.Nth Highest Salary/README_EN.md b/solution/0100-0199/0177.Nth Highest Salary/README_EN.md index 37c056f9d75ef..3373a1cd68980 100644 --- a/solution/0100-0199/0177.Nth Highest Salary/README_EN.md +++ b/solution/0100-0199/0177.Nth Highest Salary/README_EN.md @@ -31,7 +31,7 @@ Each row of this table contains information about the salary of an employee.-
Write a solution to find the nth highest salary from the Employee table. If there is no nth highest salary, return null.
Write a solution to find the nth highest distinct salary from the Employee table. If there are less than n distinct salaries, return null.
The result format is in the following example.
diff --git a/solution/0100-0199/0190.Reverse Bits/README.md b/solution/0100-0199/0190.Reverse Bits/README.md index e151edf982a68..4538936385624 100644 --- a/solution/0100-0199/0190.Reverse Bits/README.md +++ b/solution/0100-0199/0190.Reverse Bits/README.md @@ -28,28 +28,67 @@ tags:-
示例 1：
- --输入：n = 00000010100101000001111010011100 -输出：964176192 (00111001011110000010100101000000) -解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596， - 因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。- -
示例 2：
- --输入：n = 11111111111111111111111111111101 -输出：3221225471 (10111111111111111111111111111111) -解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293， - 因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。+
示例 1：
+ +输入：n = 43261596
+ +输出：964176192
+ +解释：
+ +| 整数 | +二进制 | +
|---|---|
| 43261596 | +00000010100101000001111010011100 | +
| 964176192 | +00111001011110000010100101000000 | +
示例 2：
+ +输入：n = 2147483644
+ +输出：1073741822
+ +解释：
+ +| 整数 | +二进制 | +
|---|---|
| 2147483644 | +01111111111111111111111111111100 | +
| 1073741822 | +00111111111111111111111111111110 | +
提示：
32 的二进制字符串0 <= n <= 231 - 2n 为偶数diff --git a/solution/0100-0199/0190.Reverse Bits/README_EN.md b/solution/0100-0199/0190.Reverse Bits/README_EN.md index c9cb6f63778a4..3e84004956967 100644 --- a/solution/0100-0199/0190.Reverse Bits/README_EN.md +++ b/solution/0100-0199/0190.Reverse Bits/README_EN.md @@ -23,31 +23,70 @@ tags:
-3 and the output represents the signed integer -1073741825.-3 and the output represents the signed integer -1073741825.
Example 1:
--Input: n = 00000010100101000001111010011100 -Output: 964176192 (00111001011110000010100101000000) -Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000. -+
Input: n = 43261596
+ +Output: 964176192
+ +Explanation:
+ +| Integer | +Binary | +
|---|---|
| 43261596 | +00000010100101000001111010011100 | +
| 964176192 | +00111001011110000010100101000000 | +
Example 2:
--Input: n = 11111111111111111111111111111101 -Output: 3221225471 (10111111111111111111111111111111) -Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111. -+
Input: n = 2147483644
+ +Output: 1073741822
+ +Explanation:
+ +| Integer | +Binary | +
|---|---|
| 2147483644 | +01111111111111111111111111111100 | +
| 1073741822 | +00111111111111111111111111111110 | +
Constraints:
320 <= n <= 231 - 2n is even.diff --git a/solution/0100-0199/0195.Tenth Line/README_EN.md b/solution/0100-0199/0195.Tenth Line/README_EN.md index 7ca9f7187d210..69bdfb2395242 100644 --- a/solution/0100-0199/0195.Tenth Line/README_EN.md +++ b/solution/0100-0199/0195.Tenth Line/README_EN.md @@ -23,26 +23,41 @@ tags:
Assume that file.txt has the following content:
+ Line 1 + Line 2 + Line 3 + Line 4 + Line 5 + Line 6 + Line 7 + Line 8 + Line 9 + Line 10 +
Your script should output the tenth line, which is:
+ Line 10 +
给定一个 无重复元素 的 有序 整数数组 nums 。
返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。
区间 [a,b] 是从 a 到 b（包含）的所有整数的集合。
返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个区间但不属于 nums 的数字 x 。
列表中的每个区间范围 [a,b] 应该按如下格式输出：
给定一个二叉树，统计该二叉树数值相同的子树个数。
+给定一个二叉树，统计该二叉树数值相同的 子树 个数。
同值子树是指该子树的所有节点都拥有相同的数值。
-示例：
++
示例 1：
+
-输入: root = [5,1,5,5,5,null,5] +输入：root = [5,1,5,5,5,null,5] +输出：4 +- 5 - / \ - 1 5 - / \ \ - 5 5 5 +
示例 2：
-输出: 4 ++输入：root = [] +输出：0+
示例 3：
+ ++输入：root = [5,5,5,5,5,null,5] +输出：6 ++ +
+ +
提示：
+ +[0, 1000] 范围内-1000 <= Node.val <= 1000-
表：Users
-
取消率 的计算方式如下：(被司机或乘客取消的非禁止用户生成的订单数量) / (非禁止用户生成的订单总数)。
编写解决方案找出 "2013-10-01" 至 "2013-10-03" 期间有 至少 一次行程的非禁止用户（乘客和司机都必须未被禁止）的 取消率。非禁止用户即 banned 为 No 的用户，禁止用户即 banned 为 Yes 的用户。其中取消率 Cancellation Rate 需要四舍五入保留 两位小数 。
+
Table: Users
+
The cancellation rate is computed by dividing the number of canceled (by client or driver) requests with unbanned users by the total number of requests with unbanned users on that day.
@@ -59,7 +59,7 @@ banned is an ENUM (category) type of ('Yes', 'No').Return the result table in any order.
-The result format is in the following example.
+The result format is in the following example.
Example 1:
diff --git a/solution/0200-0299/0269.Alien Dictionary/README.md b/solution/0200-0299/0269.Alien Dictionary/README.md index b1185f65b06a0..308a96369b8e8 100644 --- a/solution/0200-0299/0269.Alien Dictionary/README.md +++ b/solution/0200-0299/0269.Alien Dictionary/README.md @@ -288,6 +288,87 @@ public: }; ``` +#### Go + +```go +func alienOrder(words []string) string { + g := [26][26]bool{} + s := [26]bool{} + cnt := 0 + n := len(words) + for i := 0; i < n-1; i++ { + for _, c := range words[i] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + m := len(words[i]) + for j := 0; j < m; j++ { + if j >= len(words[i+1]) { + return "" + } + c1, c2 := words[i][j]-'a', words[i+1][j]-'a' + if c1 == c2 { + continue + } + if g[c2][c1] { + return "" + } + g[c1][c2] = true + break + } + } + for _, c := range words[n-1] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + + inDegree := [26]int{} + for _, out := range g { + for i, v := range out { + if v { + inDegree[i]++ + } + } + } + q := []int{} + for i, in := range inDegree { + if in == 0 && s[i] { + q = append(q, i) + } + } + ans := "" + for len(q) > 0 { + t := q[0] + q = q[1:] + ans += string(t + 'a') + for i, v := range g[t] { + if v { + inDegree[i]-- + if inDegree[i] == 0 && s[i] { + q = append(q, i) + } + } + } + } + if len(ans) < cnt { + return "" + } + return ans +} +``` + diff --git a/solution/0200-0299/0269.Alien Dictionary/README_EN.md b/solution/0200-0299/0269.Alien Dictionary/README_EN.md index 9677cf9f30970..24d8925dfb9a6 100644 --- a/solution/0200-0299/0269.Alien Dictionary/README_EN.md +++ b/solution/0200-0299/0269.Alien Dictionary/README_EN.md @@ -269,6 +269,87 @@ public: }; ``` +#### Go + +```go +func alienOrder(words []string) string { + g := [26][26]bool{} + s := [26]bool{} + cnt := 0 + n := len(words) + for i := 0; i < n-1; i++ { + for _, c := range words[i] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + m := len(words[i]) + for j := 0; j < m; j++ { + if j >= len(words[i+1]) { + return "" + } + c1, c2 := words[i][j]-'a', words[i+1][j]-'a' + if c1 == c2 { + continue + } + if g[c2][c1] { + return "" + } + g[c1][c2] = true + break + } + } + for _, c := range words[n-1] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + + inDegree := [26]int{} + for _, out := range g { + for i, v := range out { + if v { + inDegree[i]++ + } + } + } + q := []int{} + for i, in := range inDegree { + if in == 0 && s[i] { + q = append(q, i) + } + } + ans := "" + for len(q) > 0 { + t := q[0] + q = q[1:] + ans += string(t + 'a') + for i, v := range g[t] { + if v { + inDegree[i]-- + if inDegree[i] == 0 && s[i] { + q = append(q, i) + } + } + } + } + if len(ans) < cnt { + return "" + } + return ans +} +``` + diff --git a/solution/0200-0299/0269.Alien Dictionary/Solution.go b/solution/0200-0299/0269.Alien Dictionary/Solution.go new file mode 100644 index 0000000000000..b49abee4bad20 --- /dev/null +++ b/solution/0200-0299/0269.Alien Dictionary/Solution.go @@ -0,0 +1,76 @@ +func alienOrder(words []string) string { + g := [26][26]bool{} + s := [26]bool{} + cnt := 0 + n := len(words) + for i := 0; i < n-1; i++ { + for _, c := range words[i] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + m := len(words[i]) + for j := 0; j < m; j++ { + if j >= len(words[i+1]) { + return "" + } + c1, c2 := words[i][j]-'a', words[i+1][j]-'a' + if c1 == c2 { + continue + } + if g[c2][c1] { + return "" + } + g[c1][c2] = true + break + } + } + for _, c := range words[n-1] { + if cnt == 26 { + break + } + c -= 'a' + if !s[c] { + cnt++ + s[c] = true + } + } + + inDegree := [26]int{} + for _, out := range g { + for i, v := range out { + if v { + inDegree[i]++ + } + } + } + q := []int{} + for i, in := range inDegree { + if in == 0 && s[i] { + q = append(q, i) + } + } + ans := "" + for len(q) > 0 { + t := q[0] + q = q[1:] + ans += string(t + 'a') + for i, v := range g[t] { + if v { + inDegree[i]-- + if inDegree[i] == 0 && s[i] { + q = append(q, i) + } + } + } + } + if len(ans) < cnt { + return "" + } + return ans +} diff --git a/solution/0200-0299/0275.H-Index II/README.md b/solution/0200-0299/0275.H-Index II/README.md index 546a3242358e5..47b3a5e04dfb9 100644 --- a/solution/0200-0299/0275.H-Index II/README.md +++ b/solution/0200-0299/0275.H-Index II/README.md @@ -17,7 +17,7 @@ tags: -给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数，citations 已经按照 升序排列 。计算并返回该研究者的 h 指数。
给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数，citations 已经按照 非降序排列 。计算并返回该研究者的 h 指数。
h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （n 篇论文中）至少 有 h 篇论文分别被引用了至少 h 次。
Given an array of integers citations where citations[i] is the number of citations a researcher received for their ith paper and citations is sorted in ascending order, return the researcher's h-index.
Given an array of integers citations where citations[i] is the number of citations a researcher received for their ith paper and citations is sorted in non-descending order, return the researcher's h-index.
According to the definition of h-index on Wikipedia: The h-index is defined as the maximum value of h such that the given researcher has published at least h papers that have each been cited at least h times.
给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回 所有 能够得到 target 的表达式。
给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回 所有 能够得到 target 的表达式。
注意，返回表达式中的操作数 不应该 包含前导零。
+注意，一个数字可以包含多个数位。
+
示例 1:
diff --git a/solution/0200-0299/0282.Expression Add Operators/README_EN.md b/solution/0200-0299/0282.Expression Add Operators/README_EN.md index 083949924e34b..7b0d14c5eba93 100644 --- a/solution/0200-0299/0282.Expression Add Operators/README_EN.md +++ b/solution/0200-0299/0282.Expression Add Operators/README_EN.md @@ -22,6 +22,8 @@ tags:Note that operands in the returned expressions should not contain leading zeros.
+Note that a number can contain multiple digits.
+
Example 1:
diff --git a/solution/0300-0399/0317.Shortest Distance from All Buildings/README.md b/solution/0300-0399/0317.Shortest Distance from All Buildings/README.md index a41c44f4a91dc..b533ce8d0056f 100644 --- a/solution/0300-0399/0317.Shortest Distance from All Buildings/README.md +++ b/solution/0300-0399/0317.Shortest Distance from All Buildings/README.md @@ -32,8 +32,6 @@ tags:总旅行距离 是朋友们家到聚会地点的距离之和。
-使用 曼哈顿距离 计算距离，其中距离 (p1, p2) = |p2.x - p1.x | + | p2.y - p1.y | 。
示例 1：
diff --git a/solution/0300-0399/0317.Shortest Distance from All Buildings/README_EN.md b/solution/0300-0399/0317.Shortest Distance from All Buildings/README_EN.md index 816bbabef6c3d..edd540c52e03d 100644 --- a/solution/0300-0399/0317.Shortest Distance from All Buildings/README_EN.md +++ b/solution/0300-0399/0317.Shortest Distance from All Buildings/README_EN.md @@ -32,8 +32,6 @@ tags:The total travel distance is the sum of the distances between the houses of the friends and the meeting point.
-The distance is calculated using Manhattan Distance, where distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|.
Example 1:
diff --git a/solution/0300-0399/0328.Odd Even Linked List/README.md b/solution/0300-0399/0328.Odd Even Linked List/README.md
index ecec1ac6f1cf8..c9165d73e2ebb 100644
--- a/solution/0300-0399/0328.Odd Even Linked List/README.md
+++ b/solution/0300-0399/0328.Odd Even Linked List/README.md
@@ -16,7 +16,7 @@ tags:
-给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别分组，保持它们原有的相对顺序，然后把偶数索引节点分组连接到奇数索引节点分组之后，返回重新排序的链表。
第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。
diff --git a/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md b/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md index c3bdea5faf274..a9b134fb52acd 100644 --- a/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md +++ b/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md @@ -20,7 +20,7 @@ tags: -请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。
+请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。
在这个井字棋游戏中，会有 2 名玩家，他们将轮流在棋盘上放置自己的棋子。
@@ -34,7 +34,8 @@ tags:示例:
-给定棋盘边长 n = 3, 玩家 1 的棋子符号是 "X"，玩家 2 的棋子符号是 "O"。 ++给定棋盘边长 n = 3, 玩家 1 的棋子符号是 "X"，玩家 2 的棋子符号是 "O"。 TicTacToe toe = new TicTacToe(3); @@ -76,7 +77,17 @@ toe.move(2, 1, 1); -> 函数返回 1 (此时，玩家 1 赢得了该场比赛-
进阶:
+提示：
+ +
2 <= n <= 1001 或 2。0 <= row, col < nmove 时 (row, col) 都是不同的。move n2 次。进阶:
您有没有可能将每一步的 move() 操作优化到比 O(n2) 更快吗?
给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：
给你一个整数 n ，返回一个字符串数组 answer（下标从 1 开始），其中：
answer[i] == "FizzBuzz" 如果 i 同时是 3 和 5 的倍数。示例 3：
-输入：sentence = ["I", "had", "apple", "pie"], rows = 4, cols = 5 +输入：sentence = ["i", "had", "apple", "pie"], rows = 4, cols = 5 输出：1 解释： -I-had +i-had apple -pie-I +pie-i had-- 字符 '-' 表示屏幕上的一个空白位置。diff --git a/solution/0400-0499/0427.Construct Quad Tree/README.md b/solution/0400-0499/0427.Construct Quad Tree/README.md index 561c58bac14f4..7afa044e1460a 100644 --- a/solution/0400-0499/0427.Construct Quad Tree/README.md +++ b/solution/0400-0499/0427.Construct Quad Tree/README.md @@ -50,7 +50,7 @@ class Node {
如果你想了解更多关于四叉树的内容，可以参考 wiki 。
+如果你想了解更多关于四叉树的内容，可以参考 百科 。
四叉树格式：
diff --git a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README.md b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README.md index 79d1666a074ef..04f5e0e21142b 100644 --- a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README.md +++ b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README.md @@ -49,7 +49,37 @@ tags: -### 方法一 +### 方法一：字典树计数 + 贪心构造 + +本题要求在区间 $[1, n]$ 中，按**字典序**排序后，找到第 $k$ 小的数字。由于 $n$ 的范围非常大（最多可达 $10^9$），我们无法直接枚举所有数字后排序。因此我们采用**贪心 + 字典树模拟**的策略。 + +我们将 $[1, n]$ 看作一棵 **十叉字典树（Trie）**： + +- 每个节点是一个前缀，根节点为空串； +- 节点的子节点是当前前缀拼接上 $0 \sim 9$； +- 例如前缀 $1$ 会有子节点 $10, 11, \ldots, 19$，而 $10$ 会有 $100, 101, \ldots, 109$； +- 这种结构天然符合字典序遍历。 + +``` +根 +├── 1 +│ ├── 10 +│ ├── 11 +│ ├── ... +├── 2 +├── ... +``` + +我们使用变量 $\textit{curr}$ 表示当前前缀，初始为 $1$。每次我们尝试向下扩展前缀，直到找到第 $k$ 小的数字。 + +每次我们计算当前前缀下有多少个合法数字（即以 $\textit{curr}$ 为前缀、且不超过 $n$ 的整数个数），记作 $\textit{count}(\text{curr})$： + +- 如果 $k \ge \text{count}(\text{curr})$：说明目标不在这棵子树中，跳过整棵子树，前缀右移：$\textit{curr} \leftarrow \text{curr} + 1$，并更新 $k \leftarrow k - \text{count}(\text{curr})$； +- 否则：说明目标在当前前缀的子树中，进入下一层：$\textit{curr} \leftarrow \text{curr} \times 10$，并消耗一个前缀：$k \leftarrow k - 1$。 + +每一层我们将当前区间扩大 $10$ 倍，向下延伸到更长的前缀，直到超出 $n$。 + +时间复杂度 $O(\log^2 n)$，空间复杂度 $O(1)$。 @@ -181,6 +211,75 @@ func findKthNumber(n int, k int) int { } ``` +#### TypeScript + +```ts +function findKthNumber(n: number, k: number): number { + function count(curr: number): number { + let next = curr + 1; + let cnt = 0; + while (curr <= n) { + cnt += Math.min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + return cnt; + } + + let curr = 1; + k--; + + while (k > 0) { + const cnt = count(curr); + if (k >= cnt) { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + return curr; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn find_kth_number(n: i32, k: i32) -> i32 { + fn count(mut curr: i64, n: i32) -> i32 { + let mut next = curr + 1; + let mut total = 0; + let n = n as i64; + while curr <= n { + total += std::cmp::min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + total as i32 + } + + let mut curr = 1; + let mut k = k - 1; + + while k > 0 { + let cnt = count(curr as i64, n); + if k >= cnt { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + curr + } +} +``` + diff --git a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README_EN.md b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README_EN.md index f8c7bc38a68b3..abdae7d0cad00 100644 --- a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README_EN.md +++ b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/README_EN.md @@ -47,7 +47,46 @@ tags: -### Solution 1 +### Solution 1: Trie-Based Counting + Greedy Construction + +The problem asks for the \$k\$-th smallest number in the range $[1, n]$ when all numbers are sorted in **lexicographical order**. Since $n$ can be as large as $10^9$, we cannot afford to generate and sort all the numbers explicitly. Instead, we adopt a strategy based on **greedy traversal over a conceptual Trie**. + +We treat the range $[1, n]$ as a **10-ary prefix tree (Trie)**: + +- Each node represents a numeric prefix, starting from an empty root; +- Each node has 10 children, corresponding to appending digits $0 \sim 9$; +- For example, prefix $1$ has children $10, 11, \ldots, 19$, and node $10$ has children $100, 101, \ldots, 109$; +- This tree naturally reflects lexicographical order traversal. + +``` +root +├── 1 +│ ├── 10 +│ ├── 11 +│ ├── ... +├── 2 +├── ... +``` + +We use a variable $\textit{curr}$ to denote the current prefix, initialized as $1$. At each step, we try to expand or skip prefixes until we find the \$k\$-th smallest number. + +At each step, we calculate how many valid numbers (i.e., numbers $\le n$ with prefix $\textit{curr}$) exist under this prefix subtree. Let this count be $\textit{count}(\text{curr})$: + +- If $k \ge \text{count}(\text{curr})$: the target number is not in this subtree. We skip the entire subtree by moving to the next sibling: + + $$ + \textit{curr} \leftarrow \textit{curr} + 1,\quad k \leftarrow k - \text{count}(\text{curr}) + $$ + +- Otherwise: the target is within this subtree. We go one level deeper: + + $$ + \textit{curr} \leftarrow \textit{curr} \times 10,\quad k \leftarrow k - 1 + $$ + +At each level, we enlarge the current range by multiplying by 10 and continue descending until we exceed $n$. + +The time complexity is $O(\log^2 n)$, as we perform logarithmic operations for counting and traversing the Trie structure. The space complexity is $O(1)$ since we only use a few variables to track the current prefix and count. @@ -179,6 +218,75 @@ func findKthNumber(n int, k int) int { } ``` +#### TypeScript + +```ts +function findKthNumber(n: number, k: number): number { + function count(curr: number): number { + let next = curr + 1; + let cnt = 0; + while (curr <= n) { + cnt += Math.min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + return cnt; + } + + let curr = 1; + k--; + + while (k > 0) { + const cnt = count(curr); + if (k >= cnt) { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + return curr; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn find_kth_number(n: i32, k: i32) -> i32 { + fn count(mut curr: i64, n: i32) -> i32 { + let mut next = curr + 1; + let mut total = 0; + let n = n as i64; + while curr <= n { + total += std::cmp::min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + total as i32 + } + + let mut curr = 1; + let mut k = k - 1; + + while k > 0 { + let cnt = count(curr as i64, n); + if k >= cnt { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + curr + } +} +``` + diff --git a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.rs b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.rs new file mode 100644 index 0000000000000..52351a5f8ff07 --- /dev/null +++ b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.rs @@ -0,0 +1,31 @@ +impl Solution { + pub fn find_kth_number(n: i32, k: i32) -> i32 { + fn count(mut curr: i64, n: i32) -> i32 { + let mut next = curr + 1; + let mut total = 0; + let n = n as i64; + while curr <= n { + total += std::cmp::min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + total as i32 + } + + let mut curr = 1; + let mut k = k - 1; + + while k > 0 { + let cnt = count(curr as i64, n); + if k >= cnt { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + curr + } +} diff --git a/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.ts b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.ts new file mode 100644 index 0000000000000..7e54456e1b47a --- /dev/null +++ b/solution/0400-0499/0440.K-th Smallest in Lexicographical Order/Solution.ts @@ -0,0 +1,28 @@ +function findKthNumber(n: number, k: number): number { + function count(curr: number): number { + let next = curr + 1; + let cnt = 0; + while (curr <= n) { + cnt += Math.min(n - curr + 1, next - curr); + curr *= 10; + next *= 10; + } + return cnt; + } + + let curr = 1; + k--; + + while (k > 0) { + const cnt = count(curr); + if (k >= cnt) { + k -= cnt; + curr += 1; + } else { + k -= 1; + curr *= 10; + } + } + + return curr; +} diff --git a/solution/0400-0499/0472.Concatenated Words/README.md b/solution/0400-0499/0472.Concatenated Words/README.md index c487d2cb51c56..31954b9e6721f 100644 --- a/solution/0400-0499/0472.Concatenated Words/README.md +++ b/solution/0400-0499/0472.Concatenated Words/README.md @@ -8,6 +8,7 @@ tags: - 数组 - 字符串 - 动态规划 + - 排序 --- diff --git a/solution/0400-0499/0472.Concatenated Words/README_EN.md b/solution/0400-0499/0472.Concatenated Words/README_EN.md index 64039ca4901b3..5635be4155bb9 100644 --- a/solution/0400-0499/0472.Concatenated Words/README_EN.md +++ b/solution/0400-0499/0472.Concatenated Words/README_EN.md @@ -8,6 +8,7 @@ tags: - Array - String - Dynamic Programming + - Sorting --- diff --git a/solution/0400-0499/0499.The Maze III/README_EN.md b/solution/0400-0499/0499.The Maze III/README_EN.md index b1f7423cdc14e..44d79709ee175 100644 --- a/solution/0400-0499/0499.The Maze III/README_EN.md +++ b/solution/0400-0499/0499.The Maze III/README_EN.md @@ -23,7 +23,7 @@ tags: -There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction. There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.
There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction (must be different from last chosen direction). There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.
Given the m x n maze, the ball's position ball and the hole's position hole, where ball = [ballrow, ballcol] and hole = [holerow, holecol], return a string instructions of all the instructions that the ball should follow to drop in the hole with the shortest distance possible. If there are multiple valid instructions, return the lexicographically minimum one. If the ball can't drop in the hole, return "impossible".
"USA" 。"leetcode" 。"Google" 。"leetcode" 。"Google" 。给你一个字符串 word 。如果大写用法正确，返回 true ；否则，返回 false 。
- -
编写解决方案，报告在首次登录的第二天再次登录的玩家的 比率，四舍五入到小数点后两位。换句话说，你需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。
+编写解决方案，报告在首次登录的第二天再次登录的玩家的 比率，四舍五入到小数点后两位。换句话说，你需要计算从首次登录后的第二天登录的玩家数量，并将其除以总玩家数。
结果格式如下所示：
diff --git a/solution/0500-0599/0550.Game Play Analysis IV/README_EN.md b/solution/0500-0599/0550.Game Play Analysis IV/README_EN.md index 75774152565b6..3612f647d84ed 100644 --- a/solution/0500-0599/0550.Game Play Analysis IV/README_EN.md +++ b/solution/0500-0599/0550.Game Play Analysis IV/README_EN.md @@ -32,11 +32,11 @@ This table shows the activity of players of some games. Each row is a record of a player who logged in and played a number of games (possibly 0) before logging out on someday using some device. -+
-
Write a solution to report the fraction of players that logged in again on the day after the day they first logged in, rounded to 2 decimal places. In other words, you need to count the number of players that logged in for at least two consecutive days starting from their first login date, then divide that number by the total number of players.
+Write a solution to report the fraction of players that logged in again on the day after the day they first logged in, rounded to 2 decimal places. In other words, you need to determine the number of players who logged in on the day immediately following their initial login, and divide it by the number of total players.
-The result format is in the following example.
+The result format is in the following example.
Example 1:
diff --git a/solution/0500-0599/0581.Shortest Unsorted Continuous Subarray/README.md b/solution/0500-0599/0581.Shortest Unsorted Continuous Subarray/README.md index 6d3765e61f6cb..2cf6f98195019 100644 --- a/solution/0500-0599/0581.Shortest Unsorted Continuous Subarray/README.md +++ b/solution/0500-0599/0581.Shortest Unsorted Continuous Subarray/README.md @@ -173,32 +173,20 @@ function findUnsortedSubarray(nums: number[]): number { ```rust impl Solution { pub fn find_unsorted_subarray(nums: Vec找出那些 没有被 id = 2 的客户 推荐 的客户的姓名。
找出以下客户的姓名：
+ +id != 2 的用户推荐。以 任意顺序 返回结果表。
diff --git a/solution/0500-0599/0584.Find Customer Referee/README_EN.md b/solution/0500-0599/0584.Find Customer Referee/README_EN.md index d6810684bb34e..0bd8a5c948aff 100644 --- a/solution/0500-0599/0584.Find Customer Referee/README_EN.md +++ b/solution/0500-0599/0584.Find Customer Referee/README_EN.md @@ -32,7 +32,12 @@ Each row of this table indicates the id of a customer, their name, and the id of-
Find the names of the customer that are not referred by the customer with id = 2.
Find the names of the customer that are either:
+ +id != 2.Return the result table in any order.
diff --git a/solution/0500-0599/0594.Longest Harmonious Subsequence/README.md b/solution/0500-0599/0594.Longest Harmonious Subsequence/README.md index 06b75b6a92e88..faf66f120bb69 100644 --- a/solution/0500-0599/0594.Longest Harmonious Subsequence/README.md +++ b/solution/0500-0599/0594.Longest Harmonious Subsequence/README.md @@ -174,6 +174,28 @@ function findLHS(nums: number[]): number { } ``` +#### Rust + +```rust +use std::collections::HashMap; + +impl Solution { + pub fn find_lhs(nums: Vec假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。
+给定两个字符串数组 list1 和 list2，找到 索引和最小的公共字符串。
你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个，则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。
+公共字符串 是同时出现在 list1 和 list2 中的字符串。
具有 最小索引和的公共字符串 是指，如果它在 list1[i] 和 list2[j] 中出现，那么 i + j 应该是所有其他 公共字符串 中的最小值。
返回所有 具有最小索引和的公共字符串。以 任何顺序 返回答案。
@@ -29,7 +33,7 @@ tags:
输入: list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"]，list2 = ["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"] 输出: ["Shogun"] -解释: 他们唯一共同喜爱的餐厅是“Shogun”。 +解释: 唯一的公共字符串是 “Shogun”。
示例 2:
@@ -37,9 +41,20 @@ tags:输入:list1 = ["Shogun", "Tapioca Express", "Burger King", "KFC"]，list2 = ["KFC", "Shogun", "Burger King"] 输出: ["Shogun"] -解释: 他们共同喜爱且具有最小索引和的餐厅是“Shogun”，它有最小的索引和1(0+1)。 +解释: 具有最小索引和的公共字符串是 “Shogun”，它有最小的索引和 = (0 + 1) = 1。+
示例 3：
+ ++输入：list1 = ["happy","sad","good"], list2 = ["sad","happy","good"] +输出：["sad","happy"] +解释：有三个公共字符串： +"happy" 索引和 = (0 + 1) = 1. +"sad" 索引和 = (1 + 0) = 1. +"good" 索引和 = (2 + 2) = 4. +最小索引和的字符串是 "sad" 和 "happy"。+
提示:
diff --git a/solution/0600-0699/0630.Course Schedule III/README.md b/solution/0600-0699/0630.Course Schedule III/README.md index 6375a17781381..0892c7c3ea024 100644 --- a/solution/0600-0699/0630.Course Schedule III/README.md +++ b/solution/0600-0699/0630.Course Schedule III/README.md @@ -179,13 +179,13 @@ func (h *hp) pop() int { return heap.Pop(h).(int) } ```ts function scheduleCourse(courses: number[][]): number { courses.sort((a, b) => a[1] - b[1]); - const pq = new MaxPriorityQueue(); + const pq = new MaxPriorityQueue1 <= n <= 1001 <= logs.length <= 5002 <= logs.length <= 5000 <= function_id < n0 <= timestamp <= 1091 <= n <= 1001 <= logs.length <= 5002 <= logs.length <= 5000 <= function_id < n0 <= timestamp <= 109树可以看成是一个连通且 无环 的 无向 图。
-给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。
给定一个图，该图从一棵 n 个节点 (节点值 1～n) 的树中添加一条边后获得。添加的边的两个不同顶点编号在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。
请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的那个。
示例 2：
diff --git a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md index 4f842e5001bae..3d1fb0e0c7da3 100644 --- a/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md +++ b/solution/0600-0699/0689.Maximum Sum of 3 Non-Overlapping Subarrays/README_EN.md @@ -5,6 +5,8 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0600-0699/0689.Ma tags: - Array - Dynamic Programming + - Prefix Sum + - Sliding Window --- @@ -28,7 +30,7 @@ tags: Input: nums = [1,2,1,2,6,7,5,1], k = 2 Output: [0,3,5] Explanation: Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5]. -We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically smaller. +We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger.Example 2:
diff --git a/solution/0700-0799/0704.Binary Search/README.md b/solution/0700-0799/0704.Binary Search/README.md index 293c01438e03b..e58c3aed1d10e 100644 --- a/solution/0700-0799/0704.Binary Search/README.md +++ b/solution/0700-0799/0704.Binary Search/README.md @@ -17,19 +17,23 @@ tags: -给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果 target 存在返回下标，否则返回 -1。
+
你必须编写一个具有 O(log n) 时间复杂度的算法。
示例 1:
输入:nums= [-1,0,3,5,9,12],target= 9 ++输入:nums= [-1,0,3,5,9,12],target= 9 输出: 4 解释: 9 出现在nums中并且下标为 4示例 2:
-输入:diff --git a/solution/0700-0799/0790.Domino and Tromino Tiling/README.md b/solution/0700-0799/0790.Domino and Tromino Tiling/README.md index da30ee9b60a10..9311772e724de 100644 --- a/solution/0700-0799/0790.Domino and Tromino Tiling/README.md +++ b/solution/0700-0799/0790.Domino and Tromino Tiling/README.md @@ -86,7 +86,7 @@ tags: 注意，过程中的状态数值可能会很大，因此需要对 $10^9+7$ 取模。 -时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为面板的列数。 +时间复杂度 $O(n)$，其中 $n$ 为面板的列数。空间复杂度 $O(1)$。 @@ -132,12 +132,11 @@ class Solution { ```cpp class Solution { public: - const int mod = 1e9 + 7; - int numTilings(int n) { - long f[4] = {1, 0, 0, 0}; + const int mod = 1e9 + 7; + long long f[4] = {1, 0, 0, 0}; for (int i = 1; i <= n; ++i) { - long g[4] = {0, 0, 0, 0}; + long long g[4]; g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; g[1] = (f[2] + f[3]) % mod; g[2] = (f[1] + f[3]) % mod; @@ -168,6 +167,46 @@ func numTilings(n int) int { } ``` +#### TypeScript + +```ts +function numTilings(n: number): number { + const mod = 1_000_000_007; + let f: number[] = [1, 0, 0, 0]; + + for (let i = 1; i <= n; ++i) { + const g: number[] = Array(4); + g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; + g[1] = (f[2] + f[3]) % mod; + g[2] = (f[1] + f[3]) % mod; + g[3] = f[0] % mod; + f = g; + } + + return f[0]; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn num_tilings(n: i32) -> i32 { + const MOD: i64 = 1_000_000_007; + let mut f: [i64; 4] = [1, 0, 0, 0]; + for _ in 1..=n { + let mut g = [0i64; 4]; + g[0] = (f[0] + f[1] + f[2] + f[3]) % MOD; + g[1] = (f[2] + f[3]) % MOD; + g[2] = (f[1] + f[3]) % MOD; + g[3] = f[0] % MOD; + f = g; + } + f[0] as i32 + } +} +``` + diff --git a/solution/0700-0799/0790.Domino and Tromino Tiling/README_EN.md b/solution/0700-0799/0790.Domino and Tromino Tiling/README_EN.md index 04f89b3e86cd6..9d5dc63b7ff65 100644 --- a/solution/0700-0799/0790.Domino and Tromino Tiling/README_EN.md +++ b/solution/0700-0799/0790.Domino and Tromino Tiling/README_EN.md @@ -28,7 +28,7 @@ tags:nums= [-1,0,3,5,9,12],target= 2 ++输入:diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/README.md b/solution/0700-0799/0720.Longest Word in Dictionary/README.md index bf15fcb915ab3..3a80e81888f9e 100644 --- a/solution/0700-0799/0720.Longest Word in Dictionary/README.md +++ b/solution/0700-0799/0720.Longest Word in Dictionary/README.md @@ -20,7 +20,7 @@ tags: -nums= [-1,0,3,5,9,12],target= 2 输出: -1 解释: 2 不存在nums中因此返回 -1给出一个字符串数组
+words组成的一本英语词典。返回words中最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。给出一个字符串数组
words组成的一本英语词典。返回能够通过words中其它单词逐步添加一个字母来构造得到的words中最长的单词。若其中有多个可行的答案，则返回答案中字典序最小的单词。若无答案，则返回空字符串。
diff --git a/solution/0700-0799/0759.Employee Free Time/README.md b/solution/0700-0799/0759.Employee Free Time/README.md index cf8212b6bb7f5..e422bbd125252 100644 --- a/solution/0700-0799/0759.Employee Free Time/README.md +++ b/solution/0700-0799/0759.Employee Free Time/README.md @@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0700-0799/0759.Em tags: - 数组 - 排序 + - 扫描线 - 堆（优先队列） --- diff --git a/solution/0700-0799/0759.Employee Free Time/README_EN.md b/solution/0700-0799/0759.Employee Free Time/README_EN.md index 9543d4e2e9379..7c0a64ed0b949 100644 --- a/solution/0700-0799/0759.Employee Free Time/README_EN.md +++ b/solution/0700-0799/0759.Employee Free Time/README_EN.md @@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0700-0799/0759.Em tags: - Array - Sorting + - Line Sweep - Heap (Priority Queue) --- diff --git a/solution/0700-0799/0778.Swim in Rising Water/README_EN.md b/solution/0700-0799/0778.Swim in Rising Water/README_EN.md index 8212558afeb12..6f71d19110991 100644 --- a/solution/0700-0799/0778.Swim in Rising Water/README_EN.md +++ b/solution/0700-0799/0778.Swim in Rising Water/README_EN.md @@ -24,9 +24,11 @@ tags:You are given an
-n x ninteger matrixgridwhere each valuegrid[i][j]represents the elevation at that point(i, j).The rain starts to fall. At time
+t, the depth of the water everywhere ist. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at mostt. You can swim infinite distances in zero time. Of course, you must stay within the boundaries of the grid during your swim.It starts raining, and water gradually rises over time. At time
-t, the water level ist, meaning any cell with elevation less than equal totis submerged or reachable.Return the least time until you can reach the bottom right square
+(n - 1, n - 1)if you start at the top left square(0, 0).You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most
+ +t. You can swim infinite distances in zero time. Of course, you must stay within the boundaries of the grid during your swim.Return the minimum time until you can reach the bottom right square
(n - 1, n - 1)if you start at the top left square(0, 0).
Example 1:
diff --git a/solution/0700-0799/0781.Rabbits in Forest/README.md b/solution/0700-0799/0781.Rabbits in Forest/README.md index ba4b1c52bf77e..e0deffabd8ff3 100644 --- a/solution/0700-0799/0781.Rabbits in Forest/README.md +++ b/solution/0700-0799/0781.Rabbits in Forest/README.md @@ -31,10 +31,10 @@ tags: 输入：answers = [1,1,2] 输出：5 解释： -两只回答了 "1" 的兔子可能有相同的颜色，设为红色。 +两只回答了 "1" 的兔子可能有相同的颜色，设为红色。 之后回答了 "2" 的兔子不会是红色，否则他们的回答会相互矛盾。 -设回答了 "2" 的兔子为蓝色。 -此外，森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。 +设回答了 "2" 的兔子为蓝色。 +此外，森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。 因此森林中兔子的最少数量是 5 只：3 只回答的和 2 只没有回答的。Input: n = 3 Output: 5 -Explanation: The five different ways are show above. +Explanation: The five different ways are shown above.Example 2:
@@ -126,12 +126,11 @@ class Solution { ```cpp class Solution { public: - const int mod = 1e9 + 7; - int numTilings(int n) { - long f[4] = {1, 0, 0, 0}; + const int mod = 1e9 + 7; + long long f[4] = {1, 0, 0, 0}; for (int i = 1; i <= n; ++i) { - long g[4] = {0, 0, 0, 0}; + long long g[4]; g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; g[1] = (f[2] + f[3]) % mod; g[2] = (f[1] + f[3]) % mod; @@ -162,6 +161,46 @@ func numTilings(n int) int { } ``` +#### TypeScript + +```ts +function numTilings(n: number): number { + const mod = 1_000_000_007; + let f: number[] = [1, 0, 0, 0]; + + for (let i = 1; i <= n; ++i) { + const g: number[] = Array(4); + g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; + g[1] = (f[2] + f[3]) % mod; + g[2] = (f[1] + f[3]) % mod; + g[3] = f[0] % mod; + f = g; + } + + return f[0]; +} +``` + +#### Rust + +```rust +impl Solution { + pub fn num_tilings(n: i32) -> i32 { + const MOD: i64 = 1_000_000_007; + let mut f: [i64; 4] = [1, 0, 0, 0]; + for _ in 1..=n { + let mut g = [0i64; 4]; + g[0] = (f[0] + f[1] + f[2] + f[3]) % MOD; + g[1] = (f[2] + f[3]) % MOD; + g[2] = (f[1] + f[3]) % MOD; + g[3] = f[0] % MOD; + f = g; + } + f[0] as i32 + } +} +``` + diff --git a/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.cpp b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.cpp index 7dee343d57916..835d82ee5f184 100644 --- a/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.cpp +++ b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.cpp @@ -1,11 +1,10 @@ class Solution { public: - const int mod = 1e9 + 7; - int numTilings(int n) { - long f[4] = {1, 0, 0, 0}; + const int mod = 1e9 + 7; + long long f[4] = {1, 0, 0, 0}; for (int i = 1; i <= n; ++i) { - long g[4] = {0, 0, 0, 0}; + long long g[4]; g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; g[1] = (f[2] + f[3]) % mod; g[2] = (f[1] + f[3]) % mod; diff --git a/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.rs b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.rs new file mode 100644 index 0000000000000..fa193c65eb056 --- /dev/null +++ b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.rs @@ -0,0 +1,15 @@ +impl Solution { + pub fn num_tilings(n: i32) -> i32 { + const MOD: i64 = 1_000_000_007; + let mut f: [i64; 4] = [1, 0, 0, 0]; + for _ in 1..=n { + let mut g = [0i64; 4]; + g[0] = (f[0] + f[1] + f[2] + f[3]) % MOD; + g[1] = (f[2] + f[3]) % MOD; + g[2] = (f[1] + f[3]) % MOD; + g[3] = f[0] % MOD; + f = g; + } + f[0] as i32 + } +} diff --git a/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.ts b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.ts new file mode 100644 index 0000000000000..1550567f5375c --- /dev/null +++ b/solution/0700-0799/0790.Domino and Tromino Tiling/Solution.ts @@ -0,0 +1,15 @@ +function numTilings(n: number): number { + const mod = 1_000_000_007; + let f: number[] = [1, 0, 0, 0]; + + for (let i = 1; i <= n; ++i) { + const g: number[] = Array(4); + g[0] = (f[0] + f[1] + f[2] + f[3]) % mod; + g[1] = (f[2] + f[3]) % mod; + g[2] = (f[1] + f[3]) % mod; + g[3] = f[0] % mod; + f = g; + } + + return f[0]; +} diff --git a/solution/0700-0799/0797.All Paths From Source to Target/README.md b/solution/0700-0799/0797.All Paths From Source to Target/README.md index 4deb1aa603807..1d36139c345de 100644 --- a/solution/0700-0799/0797.All Paths From Source to Target/README.md +++ b/solution/0700-0799/0797.All Paths From Source to Target/README.md @@ -19,7 +19,7 @@ tags: -给你一个有
+n个节点的 有向无环图（DAG），请你找出所有从节点0到节点n-1的路径并输出（不要求按特定顺序）给你一个有
n个节点的 有向无环图（DAG），请你找出从节点0到节点n-1的所有路径并输出（不要求按特定顺序）diff --git a/solution/0700-0799/0799.Champagne Tower/README_EN.md b/solution/0700-0799/0799.Champagne Tower/README_EN.md index 7c1df1e554754..c04fa21334900 100644 --- a/solution/0700-0799/0799.Champagne Tower/README_EN.md +++ b/solution/0700-0799/0799.Champagne Tower/README_EN.md @@ -27,35 +27,51 @@ tags:
graph[i]是一个从节点i可以访问的所有节点的列表（即从节点i到节点graph[i][j]存在一条有向边）。Now after pouring some non-negative integer cups of champagne, return how full the
jthglass in theithrow is (bothiandjare 0-indexed.)+
Example 1:
+ Input: poured = 1, query_row = 1, query_glass = 1 + Output: 0.00000 + Explanation: We poured 1 cup of champange to the top glass of the tower (which is indexed as (0, 0)). There will be no excess liquid so all the glasses under the top glass will remain empty. +Example 2:
+ Input: poured = 2, query_row = 1, query_glass = 1 + Output: 0.50000 + Explanation: We poured 2 cups of champange to the top glass of the tower (which is indexed as (0, 0)). There is one cup of excess liquid. The glass indexed as (1, 0) and the glass indexed as (1, 1) will share the excess liquid equally, and each will get half cup of champange. +Example 3:
+ Input: poured = 100000009, query_row = 33, query_glass = 17 + Output: 1.00000 ++
Constraints:
0 <= poured <= 1090 <= query_glass <= query_row < 1000 <= poured <= 1090 <= query_glass <= query_row < 100有一个有 n 个节点的有向图，节点按 0 到 n - 1 编号。图由一个 索引从 0 开始 的 2D 整数数组 graph表示， graph[i]是与节点 i 相邻的节点的整数数组，这意味着从节点 i 到 graph[i]中的每个节点都有一条边。
如果一个节点没有连出的有向边，则该节点是 终端节点 。如果从该节点开始的所有可能路径都通向 终端节点 ，则该节点为 安全节点 。
+如果一个节点没有连出的有向边，则该节点是 终端节点 。如果从该节点开始的所有可能路径都通向 终端节点（或另一个安全节点），则该节点为 安全节点。
返回一个由图中所有 安全节点 组成的数组作为答案。答案数组中的元素应当按 升序 排列。
diff --git a/solution/0800-0899/0808.Soup Servings/README.md b/solution/0800-0899/0808.Soup Servings/README.md index d6a4fb0c35681..f294befb103e1 100644 --- a/solution/0800-0899/0808.Soup Servings/README.md +++ b/solution/0800-0899/0808.Soup Servings/README.md @@ -157,7 +157,7 @@ class Solution { public: double soupServings(int n) { double f[200][200] = {0.0}; - functionparagraph 中的单词 不区分大小写 ，答案应以 小写 形式返回。
注意 单词不包含标点符号。
+
示例 1：
diff --git a/solution/0800-0899/0819.Most Common Word/README_EN.md b/solution/0800-0899/0819.Most Common Word/README_EN.md index ebcacda3c5c8e..2aae27ab03f78 100644 --- a/solution/0800-0899/0819.Most Common Word/README_EN.md +++ b/solution/0800-0899/0819.Most Common Word/README_EN.md @@ -23,6 +23,8 @@ tags:The words in paragraph are case-insensitive and the answer should be returned in lowercase.
Note that words can not contain punctuation symbols.
+
Example 1:
diff --git a/solution/0800-0899/0838.Push Dominoes/README.md b/solution/0800-0899/0838.Push Dominoes/README.md index e6f79c7abba0b..d37d4feea673e 100644 --- a/solution/0800-0899/0838.Push Dominoes/README.md +++ b/solution/0800-0899/0838.Push Dominoes/README.md @@ -68,7 +68,30 @@ tags: -### 方法一 +### 方法一：多源 BFS + +把所有初始受到推力的骨牌（`L` 或 `R`）视作 **源点**，它们会同时向外扩散各自的力。用队列按时间层级（0, 1, 2 …）进行 BFS： + +我们定义 $\text{time[i]}$ 记录第 *i* 张骨牌第一次受力的时刻，`-1` 表示尚未受力，定义 $\text{force[i]}$ 是一个长度可变的列表，存放该骨牌在同一时刻收到的方向（`'L'`、`'R'`）。初始时把所有 `L/R` 的下标压入队列，并将它们的时间置 0。 + +当弹出下标 *i* 时，若 $\text{force[i]}$ 只有一个方向，骨牌就会倒向该方向 $f$。设下一张骨牌下标为 + +$$ +j = +\begin{cases} +i - 1, & f = L,\\ +i + 1, & f = R. +\end{cases} +$$ + +若 $0 \leq j < n$： + +- 若 $\text{time[j]}=-1$，说明 *j* 从未受力，记录 $\text{time[j]}=\text{time[i]}+1$ 并入队，同时把 $f$ 写入 $\text{force[j]}$。 +- 若 $\text{time[j]}=\text{time[i]}+1$，说明它在同一“下一刻”已受过另一股力，此时只把 $f$ 追加到 $\text{force[j]}$，形成对冲；后续因 `len(force[j])==2`，它将保持竖直。 + +队列清空后，所有 $\text{force[i]}$ 长度为 1 的位置倒向对应方向；长度为 2 的位置保持 `.`。最终将字符数组拼接为答案。 + +时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是骨牌的数量。 @@ -242,44 +265,40 @@ func pushDominoes(dominoes string) string { ```ts function pushDominoes(dominoes: string): string { const n = dominoes.length; - const map = { - L: -1, - R: 1, - '.': 0, - }; - let ans = new Array(n).fill(0); - let visited = new Array(n).fill(0); - let queue = []; - let depth = 1; + const q: number[] = []; + const time: number[] = Array(n).fill(-1); + const force: string[][] = Array.from({ length: n }, () => []); + for (let i = 0; i < n; i++) { - let cur = map[dominoes.charAt(i)]; - if (cur) { - queue.push(i); - visited[i] = depth; - ans[i] = cur; + const f = dominoes[i]; + if (f !== '.') { + q.push(i); + time[i] = 0; + force[i].push(f); } } - while (queue.length) { - depth++; - let nextLevel = []; - for (let i of queue) { - const dx = ans[i]; - let x = i + dx; - if (x >= 0 && x < n && [0, depth].includes(visited[x])) { - ans[x] += dx; - visited[x] = depth; - nextLevel.push(x); + + const ans: string[] = Array(n).fill('.'); + let head = 0; + while (head < q.length) { + const i = q[head++]; + if (force[i].length === 1) { + const f = force[i][0]; + ans[i] = f; + const j = f === 'L' ? i - 1 : i + 1; + if (j >= 0 && j < n) { + const t = time[i]; + if (time[j] === -1) { + q.push(j); + time[j] = t + 1; + force[j].push(f); + } else if (time[j] === t + 1) { + force[j].push(f); + } } } - queue = nextLevel; } - return ans - .map(d => { - if (!d) return '.'; - else if (d < 0) return 'L'; - else return 'R'; - }) - .join(''); + return ans.join(''); } ``` diff --git a/solution/0800-0899/0838.Push Dominoes/README_EN.md b/solution/0800-0899/0838.Push Dominoes/README_EN.md index ce232677d18a7..ec5ef4c80d36c 100644 --- a/solution/0800-0899/0838.Push Dominoes/README_EN.md +++ b/solution/0800-0899/0838.Push Dominoes/README_EN.md @@ -67,7 +67,30 @@ tags: -### Solution 1 +### Solution 1: Multi-Source BFS + +Treat all initially pushed dominoes (`L` or `R`) as **sources**, which simultaneously propagate their forces outward. Use a queue to perform BFS layer by layer (0, 1, 2, ...): + +We define $\text{time[i]}$ to record the first moment when the _i_-th domino is affected by a force, with `-1` indicating it has not been affected yet. We also define $\text{force[i]}$ as a variable-length list that stores the directions (`'L'`, `'R'`) of forces acting on the domino at the same moment. Initially, push all indices of `L/R` dominoes into the queue and set their `time` to 0. + +When dequeuing index _i_, if $\text{force[i]}$ contains only one direction, the domino will fall in that direction $f$. Let the index of the next domino be: + +$$ +j = +\begin{cases} +i - 1, & f = L,\\ +i + 1, & f = R. +\end{cases} +$$ + +If $0 \leq j < n$: + +- If $\text{time[j]} = -1$, it means _j_ has not been affected yet. Record $\text{time[j]} = \text{time[i]} + 1$, enqueue it, and append $f$ to $\text{force[j]}$. +- If $\text{time[j]} = \text{time[i]} + 1$, it means _j_ has already been affected by another force at the same "next moment." In this case, append $f$ to $\text{force[j]}$, causing a standoff. Subsequently, since $\text{len(force[j])} = 2$, it will remain upright. + +After the queue is emptied, all positions where $\text{force[i]}$ has a length of 1 will fall in the corresponding direction, while positions with a length of 2 will remain as `.`. Finally, concatenate the character array to form the answer. + +The complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of dominoes. @@ -241,44 +264,40 @@ func pushDominoes(dominoes string) string { ```ts function pushDominoes(dominoes: string): string { const n = dominoes.length; - const map = { - L: -1, - R: 1, - '.': 0, - }; - let ans = new Array(n).fill(0); - let visited = new Array(n).fill(0); - let queue = []; - let depth = 1; + const q: number[] = []; + const time: number[] = Array(n).fill(-1); + const force: string[][] = Array.from({ length: n }, () => []); + for (let i = 0; i < n; i++) { - let cur = map[dominoes.charAt(i)]; - if (cur) { - queue.push(i); - visited[i] = depth; - ans[i] = cur; + const f = dominoes[i]; + if (f !== '.') { + q.push(i); + time[i] = 0; + force[i].push(f); } } - while (queue.length) { - depth++; - let nextLevel = []; - for (let i of queue) { - const dx = ans[i]; - let x = i + dx; - if (x >= 0 && x < n && [0, depth].includes(visited[x])) { - ans[x] += dx; - visited[x] = depth; - nextLevel.push(x); + + const ans: string[] = Array(n).fill('.'); + let head = 0; + while (head < q.length) { + const i = q[head++]; + if (force[i].length === 1) { + const f = force[i][0]; + ans[i] = f; + const j = f === 'L' ? i - 1 : i + 1; + if (j >= 0 && j < n) { + const t = time[i]; + if (time[j] === -1) { + q.push(j); + time[j] = t + 1; + force[j].push(f); + } else if (time[j] === t + 1) { + force[j].push(f); + } } } - queue = nextLevel; } - return ans - .map(d => { - if (!d) return '.'; - else if (d < 0) return 'L'; - else return 'R'; - }) - .join(''); + return ans.join(''); } ``` diff --git a/solution/0800-0899/0838.Push Dominoes/Solution.ts b/solution/0800-0899/0838.Push Dominoes/Solution.ts index d9e8412c5d062..0b912d31ca203 100644 --- a/solution/0800-0899/0838.Push Dominoes/Solution.ts +++ b/solution/0800-0899/0838.Push Dominoes/Solution.ts @@ -1,41 +1,37 @@ function pushDominoes(dominoes: string): string { const n = dominoes.length; - const map = { - L: -1, - R: 1, - '.': 0, - }; - let ans = new Array(n).fill(0); - let visited = new Array(n).fill(0); - let queue = []; - let depth = 1; + const q: number[] = []; + const time: number[] = Array(n).fill(-1); + const force: string[][] = Array.from({ length: n }, () => []); + for (let i = 0; i < n; i++) { - let cur = map[dominoes.charAt(i)]; - if (cur) { - queue.push(i); - visited[i] = depth; - ans[i] = cur; + const f = dominoes[i]; + if (f !== '.') { + q.push(i); + time[i] = 0; + force[i].push(f); } } - while (queue.length) { - depth++; - let nextLevel = []; - for (let i of queue) { - const dx = ans[i]; - let x = i + dx; - if (x >= 0 && x < n && [0, depth].includes(visited[x])) { - ans[x] += dx; - visited[x] = depth; - nextLevel.push(x); + + const ans: string[] = Array(n).fill('.'); + let head = 0; + while (head < q.length) { + const i = q[head++]; + if (force[i].length === 1) { + const f = force[i][0]; + ans[i] = f; + const j = f === 'L' ? i - 1 : i + 1; + if (j >= 0 && j < n) { + const t = time[i]; + if (time[j] === -1) { + q.push(j); + time[j] = t + 1; + force[j].push(f); + } else if (time[j] === t + 1) { + force[j].push(f); + } } } - queue = nextLevel; } - return ans - .map(d => { - if (!d) return '.'; - else if (d < 0) return 'L'; - else return 'R'; - }) - .join(''); + return ans.join(''); } diff --git a/solution/0800-0899/0853.Car Fleet/README.md b/solution/0800-0899/0853.Car Fleet/README.md index fadb1d60e4f77..c8bb9502b2c1e 100644 --- a/solution/0800-0899/0853.Car Fleet/README.md +++ b/solution/0800-0899/0853.Car Fleet/README.md @@ -125,9 +125,7 @@ class Solution { public int carFleet(int target, int[] position, int[] speed) { int n = position.length; Integer[] idx = new Integer[n]; - for (int i = 0; i < n; ++i) { - idx[i] = i; - } + Arrays.setAll(idx, i -> i); Arrays.sort(idx, (i, j) -> position[j] - position[i]); int ans = 0; double pre = 0; diff --git a/solution/0800-0899/0853.Car Fleet/README_EN.md b/solution/0800-0899/0853.Car Fleet/README_EN.md index baba8b025d9bf..ea080f66ff7db 100644 --- a/solution/0800-0899/0853.Car Fleet/README_EN.md +++ b/solution/0800-0899/0853.Car Fleet/README_EN.md @@ -21,7 +21,7 @@ tags:There are n cars at given miles away from the starting mile 0, traveling to reach the mile target.
You are given two integer array position and speed, both of length n, where position[i] is the starting mile of the ith car and speed[i] is the speed of the ith car in miles per hour.
You are given two integer arrays position and speed, both of length n, where position[i] is the starting mile of the ith car and speed[i] is the speed of the ith car in miles per hour.
A car cannot pass another car, but it can catch up and then travel next to it at the speed of the slower car.
@@ -117,9 +117,7 @@ class Solution { public int carFleet(int target, int[] position, int[] speed) { int n = position.length; Integer[] idx = new Integer[n]; - for (int i = 0; i < n; ++i) { - idx[i] = i; - } + Arrays.setAll(idx, i -> i); Arrays.sort(idx, (i, j) -> position[j] - position[i]); int ans = 0; double pre = 0; diff --git a/solution/0800-0899/0853.Car Fleet/Solution.java b/solution/0800-0899/0853.Car Fleet/Solution.java index c346687da335c..593a14db56bc7 100644 --- a/solution/0800-0899/0853.Car Fleet/Solution.java +++ b/solution/0800-0899/0853.Car Fleet/Solution.java @@ -2,9 +2,7 @@ class Solution { public int carFleet(int target, int[] position, int[] speed) { int n = position.length; Integer[] idx = new Integer[n]; - for (int i = 0; i < n; ++i) { - idx[i] = i; - } + Arrays.setAll(idx, i -> i); Arrays.sort(idx, (i, j) -> position[j] - position[i]); int ans = 0; double pre = 0; diff --git a/solution/0800-0899/0854.K-Similar Strings/README.md b/solution/0800-0899/0854.K-Similar Strings/README.md index 901f3eddf2b6e..8c3b0849eb9e6 100644 --- a/solution/0800-0899/0854.K-Similar Strings/README.md +++ b/solution/0800-0899/0854.K-Similar Strings/README.md @@ -4,6 +4,7 @@ difficulty: 困难 edit_url: https://github.com/doocs/leetcode/edit/main/solution/0800-0899/0854.K-Similar%20Strings/README.md tags: - 广度优先搜索 + - 哈希表 - 字符串 --- diff --git a/solution/0800-0899/0854.K-Similar Strings/README_EN.md b/solution/0800-0899/0854.K-Similar Strings/README_EN.md index 793ae5c5199ba..e900f8a5eccd5 100644 --- a/solution/0800-0899/0854.K-Similar Strings/README_EN.md +++ b/solution/0800-0899/0854.K-Similar Strings/README_EN.md @@ -4,6 +4,7 @@ difficulty: Hard edit_url: https://github.com/doocs/leetcode/edit/main/solution/0800-0899/0854.K-Similar%20Strings/README_EN.md tags: - Breadth-First Search + - Hash Table - String --- diff --git a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md index 43c01e207b7c6..e1e44eb2e0170 100644 --- a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md +++ b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md @@ -206,14 +206,14 @@ func (h *hp) Pop() any { ```ts function minRefuelStops(target: number, startFuel: number, stations: number[][]): number { - const pq = new MaxPriorityQueue(); + const pq = new MaxPriorityQueue如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：
如果序列 x1, x2, ..., x2 满足下列条件，就说它是 斐波那契式 的：
n >= 3i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}n >= 3i + 2 <= n，都有 xi + xi+1 == xi+2给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回 0 。
+给定一个 严格递增 的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果不存在，返回 0 。
（回想一下，子序列是从原序列 arr 中派生出来的，它从 arr 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）
子序列 是通过从另一个序列 arr 中删除任意数量的元素（包括删除 0 个元素）得到的，同时不改变剩余元素顺序。例如，[3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的子序列。
+
示例 2：
+示例 2：
输入: arr = [1,3,7,11,12,14,18] @@ -50,14 +50,14 @@ tags: 解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。-
+
提示：
3 <= arr.length <= 10003 <= arr.length <= 10001 <= arr[i] < arr[i + 1] <= 10^9
1 <= arr[i] < arr[i + 1] <= 109
在 n x n 的网格 grid 中，我们放置了一些与 x，y，z 三轴对齐的 1 x 1 x 1 立方体。
每个值 v = grid[i][j] 表示 v 个正方体叠放在单元格 (i, j) 上。
每个值 v = grid[i][j] 表示有一列 v 个正方体叠放在格子 (i, j) 上。
现在，我们查看这些立方体在 xy 、yz 和 zx 平面上的投影。
输入：nums = [5,2,3,1] 输出：[1,2,3,5] +解释：数组排序后，某些数字的位置没有改变（例如，2 和 3），而其他数字的位置发生了改变（例如，1 和 5）。
示例 2：
@@ -44,6 +45,7 @@ tags:输入：nums = [5,1,1,2,0,0] 输出：[0,0,1,1,2,5] +解释：请注意，nums 的值不一定唯一。
diff --git a/solution/0900-0999/0912.Sort an Array/README_EN.md b/solution/0900-0999/0912.Sort an Array/README_EN.md index 4459f121075b6..fe0d0ef1d3c87 100644 --- a/solution/0900-0999/0912.Sort an Array/README_EN.md +++ b/solution/0900-0999/0912.Sort an Array/README_EN.md @@ -41,7 +41,7 @@ tags:
Input: nums = [5,1,1,2,0,0] Output: [0,0,1,1,2,5] -Explanation: Note that the values of nums are not necessairly unique. +Explanation: Note that the values of nums are not necessarily unique.
diff --git a/solution/0900-0999/0923.3Sum With Multiplicity/README.md b/solution/0900-0999/0923.3Sum With Multiplicity/README.md index 8304f7ca2d34d..88ec551f961a0 100644 --- a/solution/0900-0999/0923.3Sum With Multiplicity/README.md +++ b/solution/0900-0999/0923.3Sum With Multiplicity/README.md @@ -12,7 +12,7 @@ tags: -# [923. 三数之和的多种可能](https://leetcode.cn/problems/3sum-with-multiplicity) +# [923. 多重三数之和](https://leetcode.cn/problems/3sum-with-multiplicity) [English Version](/solution/0900-0999/0923.3Sum%20With%20Multiplicity/README_EN.md) diff --git a/solution/0900-0999/0939.Minimum Area Rectangle/README.md b/solution/0900-0999/0939.Minimum Area Rectangle/README.md index 7a98ebe927790..7925013d4fd67 100644 --- a/solution/0900-0999/0939.Minimum Area Rectangle/README.md +++ b/solution/0900-0999/0939.Minimum Area Rectangle/README.md @@ -20,34 +20,36 @@ tags: -
给定在 xy 平面上的一组点，确定由这些点组成的矩形的最小面积，其中矩形的边平行于 x 轴和 y 轴。
+给你一个 X-Y 平面上的点数组 points，其中 points[i] = [xi, yi]。
如果没有任何矩形，就返回 0。
+返回由这些点形成的矩形的最小面积，矩形的边与 X 轴和 Y 轴平行。如果不存在这样的矩形，则返回 0。
-
示例 1：
- -输入：[[1,1],[1,3],[3,1],[3,3],[2,2]] -输出：4 +示例 1：
++
+输入： points = [[1,1],[1,3],[3,1],[3,3],[2,2]] +输出： 4-示例 2：
- -输入：[[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]] -输出：2 +示例 2：
++
+输入： points = [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]] +输出： 2
提示：
-+
+
- -
1 <= points.length <= 500- -
0 <= points[i][0] <= 40000- -
0 <= points[i][1] <= 40000- 所有的点都是不同的。
-
points[i].length == 20 <= xi, yi <= 4 * 104只要经过一定次数的翻转操作后，能使 X 等于 Y，我们就称二叉树 X 翻转 等价 于二叉树 Y。
-这些树由根节点 root1 和 root2 给出。如果两个二叉树是否是翻转 等价 的函数，则返回 true ，否则返回 false 。
这些树由根节点 root1 和 root2 给出。如果两个二叉树是否是翻转 等价 的树，则返回 true ，否则返回 false 。
diff --git a/solution/0900-0999/0963.Minimum Area Rectangle II/README.md b/solution/0900-0999/0963.Minimum Area Rectangle II/README.md index 4f23117a1fb07..95985de7da993 100644 --- a/solution/0900-0999/0963.Minimum Area Rectangle II/README.md +++ b/solution/0900-0999/0963.Minimum Area Rectangle II/README.md @@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0900-0999/0963.Mi tags: - 几何 - 数组 + - 哈希表 - 数学 --- @@ -18,58 +19,48 @@ tags: -
给定在 xy 平面上的一组点，确定由这些点组成的任何矩形的最小面积，其中矩形的边不一定平行于 x 轴和 y 轴。
+给你一个 X-Y 平面上的点数组 points，其中 points[i] = [xi, yi]。
如果没有任何矩形，就返回 0。
+返回由这些点形成的任意矩形的最小面积，矩形的边 不一定 平行于 X 轴和 Y 轴。如果不存在这样的矩形，则返回 0。
- -
示例 1：
- -
输入：[[1,2],[2,1],[1,0],[0,1]] -输出：2.00000 -解释：最小面积的矩形出现在 [1,2],[2,1],[1,0],[0,1] 处，面积为 2。- -
示例 2：
+答案只需在10-5 的误差范围内即可被视作正确答案。
-
输入：[[0,1],[2,1],[1,1],[1,0],[2,0]] -输出：1.00000 -解释：最小面积的矩形出现在 [1,0],[1,1],[2,1],[2,0] 处，面积为 1。 +示例 1：
++输入： points = [[1,2],[2,1],[1,0],[0,1]] +输出： 2.00000 +解释： 最小面积矩形由 [1,2]、[2,1]、[1,0]、[0,1] 组成，其面积为 2。-示例 3：
- -- -
输入：[[0,3],[1,2],[3,1],[1,3],[2,1]] -输出：0 -解释：没法从这些点中组成任何矩形。 +示例 2：
++输入： points = [[0,1],[2,1],[1,1],[1,0],[2,0]] +输出： 1.00000 +解释： 最小面积矩形由 [1,0]、[1,1]、[2,1]、[2,0] 组成，其面积为 1。-示例 4：
- -- -
输入：[[3,1],[1,1],[0,1],[2,1],[3,3],[3,2],[0,2],[2,3]] -输出：2.00000 -解释：最小面积的矩形出现在 [2,1],[2,3],[3,3],[3,1] 处，面积为 2。 +示例 3：
++
+输入： points = [[0,3],[1,2],[3,1],[1,3],[2,1]] +输出： 0 +解释： 无法由这些点组成任何矩形。
提示：
-+
+
- -
1 <= points.length <= 50- -
0 <= points[i][0] <= 40000- -
0 <= points[i][1] <= 40000- 所有的点都是不同的。
-- 与真实值误差不超过
-10^-5的答案将视为正确结果。
points[i].length == 20 <= xi, yi <= 4 * 104输入：s1 = "parker", s2 = "morris", baseStr = "parser" 输出："makkek" -解释：根据A和B 中的等价信息，我们可以将这些字符分为[m,p],[a,o],[k,r,s],[e,i] 共 4 组。每组中的字符都是等价的，并按字典序排列。所以答案是"makkek"。 +解释：根据A和B中的等价信息，我们可以将这些字符分为[m,p],[a,o],[k,r,s],[e,i]共 4 组。每组中的字符都是等价的，并按字典序排列。所以答案是"makkek"。
示例 2：
@@ -52,7 +52,7 @@ tags:输入：s1 = "hello", s2 = "world", baseStr = "hold" 输出："hdld" -解释：根据A和B 中的等价信息，我们可以将这些字符分为[h,w],[d,e,o],[l,r] 共 3 组。所以只有 S 中的第二个字符'o'变成'd'，最后答案为"hdld"。 +解释：根据A和B中的等价信息，我们可以将这些字符分为[h,w],[d,e,o],[l,r]共 3 组。所以只有 S 中的第二个字符'o'变成'd'，最后答案为"hdld"。
示例 3：
@@ -60,7 +60,7 @@ tags:输入：s1 = "leetcode", s2 = "programs", baseStr = "sourcecode" 输出："aauaaaaada" -解释：我们可以把 A 和 B 中的等价字符分为[a,o,e,r,s,c],[l,p],[g,t]和[d,m] 共 4 组，因此S中除了'u'和'd'之外的所有字母都转化成了'a'，最后答案为"aauaaaaada"。 +解释：我们可以把A和B中的等价字符分为[a,o,e,r,s,c],[l,p],[g,t]和[d,m]共 4 组，因此S中除了'u'和'd'之外的所有字母都转化成了'a'，最后答案为"aauaaaaada"。
@@ -79,7 +79,11 @@ tags: -### 方法一 +### 方法一：并查集 + +我们可以使用并查集来处理等价字符的关系。每个字符可以看作一个节点，等价关系可以看作是连接这些节点的边。通过并查集，我们可以将所有等价的字符归为一类，并且在查询时能够快速找到每个字符的代表元素。我们在进行合并操作时，始终将代表元素设置为字典序最小的字符，这样可以确保最终得到的字符串是按字典序排列的最小等价字符串。 + +时间复杂度 $O((n + m) \times \log |\Sigma|)$，空间复杂度 $O(|\Sigma|)$。其中 $n$ 是字符串 $s1$ 和 $s2$ 的长度，而 $m$ 是字符串 $baseStr$ 的长度，而 $|\Sigma|$ 是字符集的大小，本题中 $|\Sigma| = 26$。 @@ -88,54 +92,47 @@ tags: ```python class Solution: def smallestEquivalentString(self, s1: str, s2: str, baseStr: str) -> str: - p = list(range(26)) - - def find(x): + def find(x: int) -> int: if p[x] != x: p[x] = find(p[x]) return p[x] - for i in range(len(s1)): - a, b = ord(s1[i]) - ord('a'), ord(s2[i]) - ord('a') - pa, pb = find(a), find(b) - if pa < pb: - p[pb] = pa + p = list(range(26)) + for a, b in zip(s1, s2): + x, y = ord(a) - ord("a"), ord(b) - ord("a") + px, py = find(x), find(y) + if px < py: + p[py] = px else: - p[pa] = pb - - res = [] - for a in baseStr: - a = ord(a) - ord('a') - res.append(chr(find(a) + ord('a'))) - return ''.join(res) + p[px] = py + return "".join(chr(find(ord(c) - ord("a")) + ord("a")) for c in baseStr) ``` #### Java ```java class Solution { - private int[] p; + private final int[] p = new int[26]; public String smallestEquivalentString(String s1, String s2, String baseStr) { - p = new int[26]; - for (int i = 0; i < 26; ++i) { + for (int i = 0; i < p.length; ++i) { p[i] = i; } for (int i = 0; i < s1.length(); ++i) { - int a = s1.charAt(i) - 'a', b = s2.charAt(i) - 'a'; - int pa = find(a), pb = find(b); - if (pa < pb) { - p[pb] = pa; + int x = s1.charAt(i) - 'a'; + int y = s2.charAt(i) - 'a'; + int px = find(x), py = find(y); + if (px < py) { + p[py] = px; } else { - p[pa] = pb; + p[px] = py; } } - StringBuilder sb = new StringBuilder(); - for (char a : baseStr.toCharArray()) { - char b = (char) (find(a - 'a') + 'a'); - sb.append(b); + char[] s = baseStr.toCharArray(); + for (int i = 0; i < s.length; ++i) { + s[i] = (char) ('a' + find(s[i] - 'a')); } - return sb.toString(); + return String.valueOf(s); } private int find(int x) { @@ -152,32 +149,30 @@ class Solution { ```cpp class Solution { public: - vector
给出 字符串 text 和 字符串列表 words, 返回所有的索引对 [i, j] 使得在索引对范围内的子字符串 text[i]...text[j]（包括 i 和 j）属于字符串列表 words。
给出 字符串 text 和 字符串列表 words, 返回所有的索引对 [i, j] 使得子字符串 text[i]...text[j]（包括 i 和 j）属于字符串列表 words。
按顺序返回索引对 [i, j]（即，按它们的第一个坐标进行排序，如果相同，则按它们的第二个坐标对它们进行排序）。
示例 1:
-输入: text = "thestoryofleetcodeandme", words = ["story","fleet","leetcode"] ++输入: text = "thestoryofleetcodeandme", words = ["story","fleet","leetcode"] 输出: [[3,7],[9,13],[10,17]]示例 2:
-输入: text = "ababa", words = ["aba","ab"] ++输入: text = "ababa", words = ["aba","ab"] 输出: [[0,1],[0,2],[2,3],[2,4]] 解释: -注意，返回的配对可以有交叉，比如，"aba" 既在 [0,2] 中也在 [2,4] 中 +注意，返回的配对可以有交叉，比如，"aba" 既在 [0,2] 中也在 [2,4] 中
提示:
--
+- 所有字符串都只包含小写字母。
-- 保证
+words中的字符串无重复。
1 <= text.length <= 1001 <= words.length <= 20- -
1 <= words[i].length <= 50- 按序返回索引对
-[i,j]（即，按照索引对的第一个索引进行排序，当第一个索引对相同时按照第二个索引对排序）。
text 和 words[i] 都只包含小写字母。words 中的字符串无重复。- -
产品表 Product：
-+--------------+---------+ -| Column Name | Type | -+--------------+---------+ -| product_id | int | -| product_name | varchar | -+--------------+---------+ -product_id 是这张表的主键（具有唯一值的列）。 -这张表的每一行都标识：每个产品的 id 和 产品名称。+
编写解决方案，选出每个售出过的产品 第一年 销售的 产品 id、年份、数量 和 价格。
-+
product_id，找到其在Sales表中首次出现的最早年份。编写解决方案，选出每个售出过的产品 第一年 销售的 产品 id、年份、数量 和 价格。
+返回一张有这些列的表：product_id，first_year，quantity 和 price。
结果表中的条目可以按 任意顺序 排列。
-结果格式如下例所示：
-
示例 1：
@@ -70,14 +60,6 @@ Sales 表： | 2 | 100 | 2009 | 12 | 5000 | | 7 | 200 | 2011 | 15 | 9000 | +---------+------------+------+----------+-------+ -Product 表： -+------------+--------------+ -| product_id | product_name | -+------------+--------------+ -| 100 | Nokia | -| 200 | Apple | -| 300 | Samsung | -+------------+--------------+ 输出： +------------+------------+----------+-------+ | product_id | first_year | quantity | price | diff --git a/solution/1000-1099/1070.Product Sales Analysis III/README_EN.md b/solution/1000-1099/1070.Product Sales Analysis III/README_EN.md index 03c8643cae525..c948fe652735b 100644 --- a/solution/1000-1099/1070.Product Sales Analysis III/README_EN.md +++ b/solution/1000-1099/1070.Product Sales Analysis III/README_EN.md @@ -30,32 +30,25 @@ tags: +-------------+-------+ (sale_id, year) is the primary key (combination of columns with unique values) of this table. product_id is a foreign key (reference column) toProduct table.
-Each row of this table shows a sale on the product product_id in a certain year.
-Note that the price is per unit.
-
-
-- -
Table: Product
-+--------------+---------+ -| Column Name | Type | -+--------------+---------+ -| product_id | int | -| product_name | varchar | -+--------------+---------+ -product_id is the primary key (column with unique values) of this table. -Each row of this table indicates the product name of each product.-
- -
Write a solution to select the product id, year, quantity, and price for the first year of every product sold.
+Write a solution to find all sales that occurred in the first year each product was sold.
-Return the resulting table in any order.
+For each product_id, identify the earliest year it appears in the Sales table.
Return all sales entries for that product in that year.
+The result format is in the following example.
+Return a table with the following columns: product_id, first_year, quantity, and price.
+Return the result in any order.
Example 1:
@@ -70,14 +63,7 @@ Sales table: | 2 | 100 | 2009 | 12 | 5000 | | 7 | 200 | 2011 | 15 | 9000 | +---------+------------+------+----------+-------+ -Product table: -+------------+--------------+ -| product_id | product_name | -+------------+--------------+ -| 100 | Nokia | -| 200 | Apple | -| 300 | Samsung | -+------------+--------------+ + Output: +------------+------------+----------+-------+ | product_id | first_year | quantity | price | diff --git a/solution/1100-1199/1108.Defanging an IP Address/README_EN.md b/solution/1100-1199/1108.Defanging an IP Address/README_EN.md index d141c92ba6e45..537e7be2aa54c 100644 --- a/solution/1100-1199/1108.Defanging an IP Address/README_EN.md +++ b/solution/1100-1199/1108.Defanging an IP Address/README_EN.md @@ -23,18 +23,29 @@ tags:A defanged IP address replaces every period "." with "[.]".
+
Example 1:
+Input: address = "1.1.1.1" + Output: "1[.]1[.]1[.]1" +
Example 2:
+Input: address = "255.100.50.0" + Output: "255[.]100[.]50[.]0" ++
+
Constraints:
address is a valid IPv4 address.address is a valid IPv4 address.A string is a valid parentheses string (denoted VPS) if and only if it consists of "(" and ")" characters only, and:
AB (A concatenated with B), where A and B are VPS's, or(A), where A is a VPS.AB (A concatenated with B), where A and B are VPS's, or(A), where A is a VPS.We can similarly define the nesting depth depth(S) of any VPS S as follows:
depth("") = 0depth(A + B) = max(depth(A), depth(B)), where A and B are VPS'sdepth("(" + A + ")") = 1 + depth(A), where A is a VPS.depth("") = 0depth(A + B) = max(depth(A), depth(B)), where A and B are VPS'sdepth("(" + A + ")") = 1 + depth(A), where A is a VPS.For example, "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2), and ")(" and "(()" are not VPS's.
We may make the following moves:
'U' moves our position up one row, if the position exists on the board;'D' moves our position down one row, if the position exists on the board;'L' moves our position left one column, if the position exists on the board;'R' moves our position right one column, if the position exists on the board;'!' adds the character board[r][c] at our current position (r, c) to the answer.'U' moves our position up one row, if the position exists on the board;'D' moves our position down one row, if the position exists on the board;'L' moves our position left one column, if the position exists on the board;'R' moves our position right one column, if the position exists on the board;'!' adds the character board[r][c] at our current position (r, c) to the answer.(Here, the only positions that exist on the board are positions with letters on them.)
@@ -40,19 +46,31 @@ tags:Return a sequence of moves that makes our answer equal to target in the minimum number of moves. You may return any path that does so.
+
Example 1:
+Input: target = "leet" + Output: "DDR!UURRR!!DDD!" +
Example 2:
+Input: target = "code" + Output: "RR!DDRR!UUL!R!" ++
+
Constraints:
1 <= target.length <= 100target consists only of English lowercase letters.1 <= target.length <= 100target consists only of English lowercase letters.Given a 2D grid of 0s and 1s, return the number of elements in the largest square subgrid that has all 1s on its border, or 0 if such a subgrid doesn't exist in the grid.
+
Example 1:
+ Input: grid = [[1,1,1],[1,0,1],[1,1,1]] + Output: 9 +
Example 2:
+ Input: grid = [[1,1,0,0]] + Output: 1 +
+
Constraints:
1 <= grid.length <= 1001 <= grid[0].length <= 100grid[i][j] is 0 or 11 <= grid.length <= 1001 <= grid[0].length <= 100grid[i][j] is 0 or 1-
请查询出所有浏览过自己文章的作者
+请查询出所有浏览过自己文章的作者。
-结果按照 id 升序排列。
结果按照作者的 id 升序排列。
查询结果的格式如下所示：
diff --git a/solution/1100-1199/1152.Analyze User Website Visit Pattern/README.md b/solution/1100-1199/1152.Analyze User Website Visit Pattern/README.md index 5b959a1bb55b8..96da4eb86409c 100644 --- a/solution/1100-1199/1152.Analyze User Website Visit Pattern/README.md +++ b/solution/1100-1199/1152.Analyze User Website Visit Pattern/README.md @@ -7,6 +7,7 @@ source: 第 6 场双周赛 Q3 tags: - 数组 - 哈希表 + - 字符串 - 排序 --- diff --git a/solution/1100-1199/1152.Analyze User Website Visit Pattern/README_EN.md b/solution/1100-1199/1152.Analyze User Website Visit Pattern/README_EN.md index 068e467a7a42c..11b798982680a 100644 --- a/solution/1100-1199/1152.Analyze User Website Visit Pattern/README_EN.md +++ b/solution/1100-1199/1152.Analyze User Website Visit Pattern/README_EN.md @@ -7,6 +7,7 @@ source: Biweekly Contest 6 Q3 tags: - Array - Hash Table + - String - Sorting --- diff --git a/solution/1100-1199/1153.String Transforms Into Another String/README.md b/solution/1100-1199/1153.String Transforms Into Another String/README.md index f2dfb0706cad4..1871225bf341a 100644 --- a/solution/1100-1199/1153.String Transforms Into Another String/README.md +++ b/solution/1100-1199/1153.String Transforms Into Another String/README.md @@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1100-1199/1153.St rating: 1949 source: 第 6 场双周赛 Q4 tags: + - 图 - 哈希表 - 字符串 --- diff --git a/solution/1100-1199/1153.String Transforms Into Another String/README_EN.md b/solution/1100-1199/1153.String Transforms Into Another String/README_EN.md index 01c129fb6f316..d60d629f841a2 100644 --- a/solution/1100-1199/1153.String Transforms Into Another String/README_EN.md +++ b/solution/1100-1199/1153.String Transforms Into Another String/README_EN.md @@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1100-1199/1153.St rating: 1949 source: Biweekly Contest 6 Q4 tags: + - Graph - Hash Table - String --- diff --git a/solution/1100-1199/1160.Find Words That Can Be Formed by Characters/README.md b/solution/1100-1199/1160.Find Words That Can Be Formed by Characters/README.md index 6b9897e53caa4..d39c633d50950 100644 --- a/solution/1100-1199/1160.Find Words That Can Be Formed by Characters/README.md +++ b/solution/1100-1199/1160.Find Words That Can Be Formed by Characters/README.md @@ -21,13 +21,11 @@ tags: -给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
给定一个字符串数组 words 和一个字符串 chars。
假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
如果字符串可以由 chars 中的字符组成（每个字符在 每个 words 中只能使用一次），则认为它是好的。
注意：每次拼写（指拼写词汇表中的一个单词）时，chars 中的每个字母都只能用一次。
返回词汇表 words 中你掌握的所有单词的 长度之和。
返回 words 中所有好的字符串的长度之和。
@@ -56,7 +54,7 @@ tags:
1 <= words.length <= 10001 <= words[i].length, chars.length <= 100words[i] 和 chars 中都仅包含小写英文字母You are given an array of strings words and a string chars.
A string is good if it can be formed by characters from chars (each character can only be used once).
A string is good if it can be formed by characters from chars (each character can only be used once for each word in words).
Return the sum of lengths of all good strings in words.
diff --git a/solution/1100-1199/1164.Product Price at a Given Date/README.md b/solution/1100-1199/1164.Product Price at a Given Date/README.md index 7f0478aa0b08d..9506824a43bed 100644 --- a/solution/1100-1199/1164.Product Price at a Given Date/README.md +++ b/solution/1100-1199/1164.Product Price at a Given Date/README.md @@ -29,9 +29,9 @@ tags: (product_id, change_date) 是此表的主键（具有唯一值的列组合）。 这张表的每一行分别记录了 某产品 在某个日期 更改后 的新价格。 -+
一开始，所有产品价格都为 10。
-编写一个解决方案，找出在 2019-08-16 时全部产品的价格，假设所有产品在修改前的价格都是 10 。
编写一个解决方案，找出在 2019-08-16 所有产品的价格。
以 任意顺序 返回结果表。
diff --git a/solution/1100-1199/1164.Product Price at a Given Date/README_EN.md b/solution/1100-1199/1164.Product Price at a Given Date/README_EN.md index 9e6ffa8caf273..0f8436fcb8040 100644 --- a/solution/1100-1199/1164.Product Price at a Given Date/README_EN.md +++ b/solution/1100-1199/1164.Product Price at a Given Date/README_EN.md @@ -29,13 +29,13 @@ tags: (product_id, change_date) is the primary key (combination of columns with unique values) of this table. Each row of this table indicates that the price of some product was changed to a new price at some date. -+
Initially, all products have price 10.
-Write a solution to find the prices of all products on 2019-08-16. Assume the price of all products before any change is 10.
Write a solution to find the prices of all products on the date 2019-08-16.
Return the result table in any order.
-The result format is in the following example.
+The result format is in the following example.
Example 1:
diff --git a/solution/1100-1199/1184.Distance Between Bus Stops/README_EN.md b/solution/1100-1199/1184.Distance Between Bus Stops/README_EN.md index d947861120f5a..b4e5e94f2f0f6 100644 --- a/solution/1100-1199/1184.Distance Between Bus Stops/README_EN.md +++ b/solution/1100-1199/1184.Distance Between Bus Stops/README_EN.md @@ -25,13 +25,17 @@ tags:Return the shortest distance between the given start and destination stops.
+
Example 1:
+ Input: distance = [1,2,3,4], start = 0, destination = 1 + Output: 1 + Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.
@@ -41,9 +45,13 @@ tags:
+ Input: distance = [1,2,3,4], start = 0, destination = 2 + Output: 3 + Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3. +
@@ -53,19 +61,29 @@ tags:
+ Input: distance = [1,2,3,4], start = 0, destination = 3 + Output: 4 + Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4. +
+
Constraints:
1 <= n <= 10^4distance.length == n0 <= start, destination < n0 <= distance[i] <= 10^41 <= n <= 10^4distance.length == n0 <= start, destination < n0 <= distance[i] <= 10^4给定一个链接 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 主机名 的全部链接。
给定一个网址 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 主机名 的全部链接。
该爬虫得到的全部链接可以 任何顺序 返回结果。
+该爬虫得到的全部网址可以 任何顺序 返回结果。
你的网络爬虫应当按照如下模式工作：
startUrl 开始爬取HtmlParser.getUrls(url) 来获得链接url页面中的全部链接startUrl 开始爬取HtmlParser.getUrls(url) 来获得给定 url 网址中的全部链接startUrl 相同 的链接集合startUrl 相同 的链接集合
如上所示的一个链接，其域名为 example.org。简单起见，你可以假设所有的链接都采用 http协议 并没有指定 端口。例如，链接 http://leetcode.com/problems 和 http://leetcode.com/contest 是同一个域名下的，而链接 http://example.org/test 和 http://example.com/abc 是不在同一域名下的。
如上所示的一个网址，其域名为 example.org。简单起见，你可以假设所有的网址都采用 http协议 并没有指定 端口。例如，网址 http://leetcode.com/problems 和 http://leetcode.com/contest 是同一个域名下的，而网址 http://example.org/test 和 http://example.com/abc 是不在同一域名下的。
HtmlParser 接口定义如下：
下面是两个实例，用以解释该问题的设计功能，对于自定义测试，你可以使用三个变量 urls, edges 和 startUrl。注意在代码实现中，你只可以访问 startUrl ，而 urls 和 edges 不可以在你的代码中被直接访问。
注意：将尾随斜线“/”的相同 URL 视为不同的 URL。例如，“http://news.yahoo.com” 和 “http://news.yahoo.com/” 是不同的域名。
+注意：将尾随斜线“/”的相同网址视为不同的网址。例如，“http://news.yahoo.com” 和 “http://news.yahoo.com/” 是不同的网址。
diff --git a/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md b/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md index 57a0b48ed9325..f3d3a209aa212 100644 --- a/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md +++ b/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md @@ -23,35 +23,53 @@ tags:
Given 2 integers n and start. Your task is return any permutation p of (0,1,2.....,2^n -1) such that :
p[0] = startp[i] and p[i+1] differ by only one bit in their binary representation.p[0] and p[2^n -1] must also differ by only one bit in their binary representation.p[0] = startp[i] and p[i+1] differ by only one bit in their binary representation.p[0] and p[2^n -1] must also differ by only one bit in their binary representation.+
Example 1:
+ Input: n = 2, start = 3 + Output: [3,2,0,1] + Explanation: The binary representation of the permutation is (11,10,00,01). + All the adjacent element differ by one bit. Another valid permutation is [3,1,0,2] +
Example 2:
+ Input: n = 3, start = 2 + Output: [2,6,7,5,4,0,1,3] + Explanation: The binary representation of the permutation is (010,110,111,101,100,000,001,011). +
+
Constraints:
1 <= n <= 160 <= start < 2 ^ n1 <= n <= 160 <= start < 2 ^ n
+
Example 1:
+ Input: num = 23 + Output: "1000" +
Example 2:
+ Input: num = 107 + Output: "101100" +
+
Constraints:
0 <= num <= 10^90 <= num <= 10^9给你一些区域列表 regions ，每个列表的第一个区域都包含这个列表内所有其他区域。
给你一些区域列表 regions ，每个列表的第一个区域都 直接 包含这个列表内所有其他区域。
如果一个区域 x 直接包含区域 y，并且区域 y 直接包含区域 z，那么说区域 x 间接 包含区域 z。请注意，区域 x 也 间接 包含所有在 y 中 间接 包含的区域。
很自然地，如果区域 x 包含区域 y ，那么区域 x 比区域 y 大。同时根据定义，区域 x 包含自身。
给定两个区域 region1 和 region2 ，找到同时包含这两个区域的 最小 区域。
如果给定区域 r1，r2 和 r3，使得 r1 包含 r3，那么数据保证 r2 不会包含 r3 。
数据同样保证最小区域一定存在。
diff --git a/solution/1200-1299/1257.Smallest Common Region/README_EN.md b/solution/1200-1299/1257.Smallest Common Region/README_EN.md index d5b52f58e36c7..2085a7c0a74a4 100644 --- a/solution/1200-1299/1257.Smallest Common Region/README_EN.md +++ b/solution/1200-1299/1257.Smallest Common Region/README_EN.md @@ -23,13 +23,13 @@ tags: -
You are given some lists of regions where the first region of each list includes all other regions in that list.
You are given some lists of regions where the first region of each list directly contains all other regions in that list.
Naturally, if a region x contains another region y then x is bigger than y. Also, by definition, a region x contains itself.
If a region x contains a region y directly, and region y contains region z directly, then region x is said to contain region z indirectly. Note that region x also indirectly contains all regions indirectly containd in y.
Given two regions: region1 and region2, return the smallest region that contains both of them.
Naturally, if a region x contains (either directly or indirectly) another region y, then x is bigger than or equal to y in size. Also, by definition, a region x contains itself.
If you are given regions r1, r2, and r3 such that r1 includes r3, it is guaranteed there is no r2 such that r2 includes r3.
Given two regions: region1 and region2, return the smallest region that contains both of them.
It is guaranteed the smallest region exists.
@@ -65,6 +65,7 @@ region2 = "New York"region1 != region2regions[i][j], region1, and region2 consist of English letters.请你返回该链表所表示数字的 十进制值 。
+最高位 在链表的头部。
+
示例 1：
-
