) -> bool {
+ let n = nums.len();
+ let mut f = vec![vec![0; n]; n];
+
+ for i in 0..n {
+ f[i][i] = nums[i];
+ }
+
+ for i in (0..n - 1).rev() {
+ for j in i + 1..n {
+ f[i][j] = std::cmp::max(nums[i] - f[i + 1][j], nums[j] - f[i][j - 1]);
+ }
+ }
+
+ f[0][n - 1] >= 0
+ }
+}
diff --git a/solution/0400-0499/0486.Predict the Winner/Solution2.ts b/solution/0400-0499/0486.Predict the Winner/Solution2.ts
index b276dadc5cb88..ec8f5d5908551 100644
--- a/solution/0400-0499/0486.Predict the Winner/Solution2.ts
+++ b/solution/0400-0499/0486.Predict the Winner/Solution2.ts
@@ -1,6 +1,6 @@
-function PredictTheWinner(nums: number[]): boolean {
+function predictTheWinner(nums: number[]): boolean {
const n = nums.length;
- const f: number[][] = new Array(n).fill(0).map(() => new Array(n).fill(0));
+ const f: number[][] = Array.from({ length: n }, () => Array(n).fill(0));
for (let i = 0; i < n; ++i) {
f[i][i] = nums[i];
}
diff --git a/solution/0500-0599/0525.Contiguous Array/README.md b/solution/0500-0599/0525.Contiguous Array/README.md
index 0e49c1a1f4c82..9b170bc8e884f 100644
--- a/solution/0500-0599/0525.Contiguous Array/README.md
+++ b/solution/0500-0599/0525.Contiguous Array/README.md
@@ -20,28 +20,35 @@ tags:
给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。
-
+
-示例 1:
+示例 1：
-输入: nums = [0,1]
-输出: 2
-说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。
+输入：nums = [0,1]
+输出：2
+说明：[0, 1] 是具有相同数量 0 和 1 的最长连续子数组。
-示例 2:
+示例 2：
-输入: nums = [0,1,0]
-输出: 2
-说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
+输入：nums = [0,1,0]
+输出：2
+说明：[0, 1] (或 [1, 0]) 是具有相同数量 0 和 1 的最长连续子数组。
-
+示例 3：
+
+
+输入：nums = [0,1,1,1,1,1,0,0,0]
+输出：6
+解释：[1,1,1,0,0,0] 是具有相同数量 0 和 1 的最长连续子数组。
+
+
提示：
- 1 <= nums.length <= 1051 <= nums.length <= 105nums[i] 不是 0 就是 1
diff --git a/solution/0500-0599/0525.Contiguous Array/README_EN.md b/solution/0500-0599/0525.Contiguous Array/README_EN.md
index 8dfeb6693c9ae..1377e34ef50fa 100644
--- a/solution/0500-0599/0525.Contiguous Array/README_EN.md
+++ b/solution/0500-0599/0525.Contiguous Array/README_EN.md
@@ -37,6 +37,14 @@ tags:
Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+Example 3:
+
+
+Input: nums = [0,1,1,1,1,1,0,0,0]
+Output: 6
+Explanation: [1,1,1,0,0,0] is the longest contiguous subarray with equal number of 0 and 1.
+
+
Constraints:
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/README.md b/solution/0500-0599/0532.K-diff Pairs in an Array/README.md
index 6ec116976d429..1053a06cc32ac 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/README.md
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/README.md
@@ -77,11 +77,13 @@ tags:
### 方法一：哈希表
-由于 $k$ 是一个定值，因此用哈希表 $ans$ 记录数对的较小值，就能够确定较大的值。最后返回 ans 的大小作为答案。
+由于 $k$ 是一个定值，我们可以用一个哈希表 $\textit{ans}$ 记录数对的较小值，就能够确定较大的值。最后返回 $\textit{ans}$ 的大小作为答案。
-遍历数组 $nums$，当前遍历到的数 $nums[j]$，我们记为 $v$，用哈希表 $vis$ 记录此前遍历到的所有数字。若 $v-k$ 在 $vis$ 中，则将 $v-k$ 添加至 $ans$；若 $v+k$ 在 $vis$ 中，则将 $v$ 添加至 $ans$。
+遍历数组 $\textit{nums}$，当前遍历到的数 $x$，我们用哈希表 $\textit{vis}$ 记录此前遍历到的所有数字。若 $x-k$ 在 $\textit{vis}$ 中，则将 $x-k$ 添加至 $\textit{ans}$；若 $x+k$ 在 $\textit{vis}$ 中，则将 $x$ 添加至 $\textit{ans}$。然后我们将 $x$ 添加至 $\textit{vis}$。继续遍历数组 $\textit{nums}$ 直至遍历结束。
-时间复杂度 $O(n)$，其中 $n$ 表示数组 $nums$ 的长度。
+最后返回 $\textit{ans}$ 的大小作为答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。
@@ -90,13 +92,14 @@ tags:
```python
class Solution:
def findPairs(self, nums: List[int], k: int) -> int:
- vis, ans = set(), set()
- for v in nums:
- if v - k in vis:
- ans.add(v - k)
- if v + k in vis:
- ans.add(v)
- vis.add(v)
+ ans = set()
+ vis = set()
+ for x in nums:
+ if x - k in vis:
+ ans.add(x - k)
+ if x + k in vis:
+ ans.add(x)
+ vis.add(x)
return len(ans)
```
@@ -105,16 +108,16 @@ class Solution:
```java
class Solution {
public int findPairs(int[] nums, int k) {
- Set vis = new HashSet<>();
Set ans = new HashSet<>();
- for (int v : nums) {
- if (vis.contains(v - k)) {
- ans.add(v - k);
+ Set vis = new HashSet<>();
+ for (int x : nums) {
+ if (vis.contains(x - k)) {
+ ans.add(x - k);
}
- if (vis.contains(v + k)) {
- ans.add(v);
+ if (vis.contains(x + k)) {
+ ans.add(x);
}
- vis.add(v);
+ vis.add(x);
}
return ans.size();
}
@@ -127,12 +130,15 @@ class Solution {
class Solution {
public:
int findPairs(vector& nums, int k) {
- unordered_set vis;
- unordered_set ans;
- for (int& v : nums) {
- if (vis.count(v - k)) ans.insert(v - k);
- if (vis.count(v + k)) ans.insert(v);
- vis.insert(v);
+ unordered_set ans, vis;
+ for (int x : nums) {
+ if (vis.count(x - k)) {
+ ans.insert(x - k);
+ }
+ if (vis.count(x + k)) {
+ ans.insert(x);
+ }
+ vis.insert(x);
}
return ans.size();
}
@@ -143,52 +149,61 @@ public:
```go
func findPairs(nums []int, k int) int {
- vis := map[int]bool{}
- ans := map[int]bool{}
- for _, v := range nums {
- if vis[v-k] {
- ans[v-k] = true
+ ans := make(map[int]struct{})
+ vis := make(map[int]struct{})
+
+ for _, x := range nums {
+ if _, ok := vis[x-k]; ok {
+ ans[x-k] = struct{}{}
}
- if vis[v+k] {
- ans[v] = true
+ if _, ok := vis[x+k]; ok {
+ ans[x] = struct{}{}
}
- vis[v] = true
+ vis[x] = struct{}{}
}
return len(ans)
}
```
+#### TypeScript
+
+```ts
+function findPairs(nums: number[], k: number): number {
+ const ans = new Set();
+ const vis = new Set();
+ for (const x of nums) {
+ if (vis.has(x - k)) {
+ ans.add(x - k);
+ }
+ if (vis.has(x + k)) {
+ ans.add(x);
+ }
+ vis.add(x);
+ }
+ return ans.size;
+}
+```
+
#### Rust
```rust
+use std::collections::HashSet;
+
impl Solution {
- pub fn find_pairs(mut nums: Vec, k: i32) -> i32 {
- nums.sort();
- let n = nums.len();
- let mut res = 0;
- let mut left = 0;
- let mut right = 1;
- while right < n {
- let num = i32::abs(nums[left] - nums[right]);
- if num == k {
- res += 1;
+ pub fn find_pairs(nums: Vec, k: i32) -> i32 {
+ let mut ans = HashSet::new();
+ let mut vis = HashSet::new();
+
+ for &x in &nums {
+ if vis.contains(&(x - k)) {
+ ans.insert(x - k);
}
- if num <= k {
- right += 1;
- while right < n && nums[right - 1] == nums[right] {
- right += 1;
- }
- } else {
- left += 1;
- while left < right && nums[left - 1] == nums[left] {
- left += 1;
- }
- if left == right {
- right += 1;
- }
+ if vis.contains(&(x + k)) {
+ ans.insert(x);
}
+ vis.insert(x);
}
- res
+ ans.len() as i32
}
}
```
@@ -197,16 +212,4 @@ impl Solution {
-
-
-### 方法二：排序 + 双指针
-
-只需要统计组合的数量，因此可以改动原数组，对其排序，使用双指针来统计。
-
-声明 `left` 与 `right` 指针，初始化为 0 和 1。根据 `abs(nums[left] - nums[right])` 与 `k` 值对比结果移动指针。
-
-需要注意的是，**不能出现重复的组合**，所以移动指针时，不能仅仅是 `+1`，需要到一个不等于当前值的位置。
-
-
-
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/README_EN.md b/solution/0500-0599/0532.K-diff Pairs in an Array/README_EN.md
index df31876b15ab2..a7103510c9c72 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/README_EN.md
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/README_EN.md
@@ -73,7 +73,15 @@ Although we have two 1s in the input, we should only return the number of
-### Solution 1
+### Solution 1: Hash Table
+
+Since $k$ is a fixed value, we can use a hash table $\textit{ans}$ to record the smaller value of the pairs, which allows us to determine the larger value. Finally, we return the size of $\textit{ans}$ as the answer.
+
+We traverse the array $\textit{nums}$. For the current number $x$, we use a hash table $\textit{vis}$ to record all the numbers that have been traversed. If $x-k$ is in $\textit{vis}$, we add $x-k$ to $\textit{ans}$. If $x+k$ is in $\textit{vis}$, we add $x$ to $\textit{ans}$. Then, we add $x$ to $\textit{vis}$. Continue traversing the array $\textit{nums}$ until the end.
+
+Finally, we return the size of $\textit{ans}$ as the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $\textit{nums}$.
@@ -82,13 +90,14 @@ Although we have two 1s in the input, we should only return the number of int:
- vis, ans = set(), set()
- for v in nums:
- if v - k in vis:
- ans.add(v - k)
- if v + k in vis:
- ans.add(v)
- vis.add(v)
+ ans = set()
+ vis = set()
+ for x in nums:
+ if x - k in vis:
+ ans.add(x - k)
+ if x + k in vis:
+ ans.add(x)
+ vis.add(x)
return len(ans)
```
@@ -97,16 +106,16 @@ class Solution:
```java
class Solution {
public int findPairs(int[] nums, int k) {
- Set vis = new HashSet<>();
Set ans = new HashSet<>();
- for (int v : nums) {
- if (vis.contains(v - k)) {
- ans.add(v - k);
+ Set vis = new HashSet<>();
+ for (int x : nums) {
+ if (vis.contains(x - k)) {
+ ans.add(x - k);
}
- if (vis.contains(v + k)) {
- ans.add(v);
+ if (vis.contains(x + k)) {
+ ans.add(x);
}
- vis.add(v);
+ vis.add(x);
}
return ans.size();
}
@@ -119,12 +128,15 @@ class Solution {
class Solution {
public:
int findPairs(vector& nums, int k) {
- unordered_set vis;
- unordered_set ans;
- for (int& v : nums) {
- if (vis.count(v - k)) ans.insert(v - k);
- if (vis.count(v + k)) ans.insert(v);
- vis.insert(v);
+ unordered_set ans, vis;
+ for (int x : nums) {
+ if (vis.count(x - k)) {
+ ans.insert(x - k);
+ }
+ if (vis.count(x + k)) {
+ ans.insert(x);
+ }
+ vis.insert(x);
}
return ans.size();
}
@@ -135,52 +147,61 @@ public:
```go
func findPairs(nums []int, k int) int {
- vis := map[int]bool{}
- ans := map[int]bool{}
- for _, v := range nums {
- if vis[v-k] {
- ans[v-k] = true
+ ans := make(map[int]struct{})
+ vis := make(map[int]struct{})
+
+ for _, x := range nums {
+ if _, ok := vis[x-k]; ok {
+ ans[x-k] = struct{}{}
}
- if vis[v+k] {
- ans[v] = true
+ if _, ok := vis[x+k]; ok {
+ ans[x] = struct{}{}
}
- vis[v] = true
+ vis[x] = struct{}{}
}
return len(ans)
}
```
+#### TypeScript
+
+```ts
+function findPairs(nums: number[], k: number): number {
+ const ans = new Set();
+ const vis = new Set();
+ for (const x of nums) {
+ if (vis.has(x - k)) {
+ ans.add(x - k);
+ }
+ if (vis.has(x + k)) {
+ ans.add(x);
+ }
+ vis.add(x);
+ }
+ return ans.size;
+}
+```
+
#### Rust
```rust
+use std::collections::HashSet;
+
impl Solution {
- pub fn find_pairs(mut nums: Vec, k: i32) -> i32 {
- nums.sort();
- let n = nums.len();
- let mut res = 0;
- let mut left = 0;
- let mut right = 1;
- while right < n {
- let num = i32::abs(nums[left] - nums[right]);
- if num == k {
- res += 1;
+ pub fn find_pairs(nums: Vec, k: i32) -> i32 {
+ let mut ans = HashSet::new();
+ let mut vis = HashSet::new();
+
+ for &x in &nums {
+ if vis.contains(&(x - k)) {
+ ans.insert(x - k);
}
- if num <= k {
- right += 1;
- while right < n && nums[right - 1] == nums[right] {
- right += 1;
- }
- } else {
- left += 1;
- while left < right && nums[left - 1] == nums[left] {
- left += 1;
- }
- if left == right {
- right += 1;
- }
+ if vis.contains(&(x + k)) {
+ ans.insert(x);
}
+ vis.insert(x);
}
- res
+ ans.len() as i32
}
}
```
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.cpp b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.cpp
index 63a75d171b756..97132b90ddc92 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.cpp
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.cpp
@@ -1,13 +1,16 @@
class Solution {
public:
int findPairs(vector& nums, int k) {
- unordered_set vis;
- unordered_set ans;
- for (int& v : nums) {
- if (vis.count(v - k)) ans.insert(v - k);
- if (vis.count(v + k)) ans.insert(v);
- vis.insert(v);
+ unordered_set ans, vis;
+ for (int x : nums) {
+ if (vis.count(x - k)) {
+ ans.insert(x - k);
+ }
+ if (vis.count(x + k)) {
+ ans.insert(x);
+ }
+ vis.insert(x);
}
return ans.size();
}
-};
\ No newline at end of file
+};
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.go b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.go
index d54f2e347e780..065fa1e420e81 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.go
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.go
@@ -1,14 +1,15 @@
func findPairs(nums []int, k int) int {
- vis := map[int]bool{}
- ans := map[int]bool{}
- for _, v := range nums {
- if vis[v-k] {
- ans[v-k] = true
+ ans := make(map[int]struct{})
+ vis := make(map[int]struct{})
+
+ for _, x := range nums {
+ if _, ok := vis[x-k]; ok {
+ ans[x-k] = struct{}{}
}
- if vis[v+k] {
- ans[v] = true
+ if _, ok := vis[x+k]; ok {
+ ans[x] = struct{}{}
}
- vis[v] = true
+ vis[x] = struct{}{}
}
return len(ans)
-}
\ No newline at end of file
+}
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.java b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.java
index afd1420fa631d..23b97854299c3 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.java
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.java
@@ -1,16 +1,16 @@
class Solution {
public int findPairs(int[] nums, int k) {
- Set vis = new HashSet<>();
Set ans = new HashSet<>();
- for (int v : nums) {
- if (vis.contains(v - k)) {
- ans.add(v - k);
+ Set vis = new HashSet<>();
+ for (int x : nums) {
+ if (vis.contains(x - k)) {
+ ans.add(x - k);
}
- if (vis.contains(v + k)) {
- ans.add(v);
+ if (vis.contains(x + k)) {
+ ans.add(x);
}
- vis.add(v);
+ vis.add(x);
}
return ans.size();
}
-}
\ No newline at end of file
+}
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.py b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.py
index 8692434342cb1..2f14875c4ed39 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.py
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.py
@@ -1,10 +1,11 @@
class Solution:
def findPairs(self, nums: List[int], k: int) -> int:
- vis, ans = set(), set()
- for v in nums:
- if v - k in vis:
- ans.add(v - k)
- if v + k in vis:
- ans.add(v)
- vis.add(v)
+ ans = set()
+ vis = set()
+ for x in nums:
+ if x - k in vis:
+ ans.add(x - k)
+ if x + k in vis:
+ ans.add(x)
+ vis.add(x)
return len(ans)
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.rs b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.rs
index 6ee3845d36594..ea6651392f489 100644
--- a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.rs
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.rs
@@ -1,30 +1,19 @@
+use std::collections::HashSet;
+
impl Solution {
- pub fn find_pairs(mut nums: Vec, k: i32) -> i32 {
- nums.sort();
- let n = nums.len();
- let mut res = 0;
- let mut left = 0;
- let mut right = 1;
- while right < n {
- let num = i32::abs(nums[left] - nums[right]);
- if num == k {
- res += 1;
+ pub fn find_pairs(nums: Vec, k: i32) -> i32 {
+ let mut ans = HashSet::new();
+ let mut vis = HashSet::new();
+
+ for &x in &nums {
+ if vis.contains(&(x - k)) {
+ ans.insert(x - k);
}
- if num <= k {
- right += 1;
- while right < n && nums[right - 1] == nums[right] {
- right += 1;
- }
- } else {
- left += 1;
- while left < right && nums[left - 1] == nums[left] {
- left += 1;
- }
- if left == right {
- right += 1;
- }
+ if vis.contains(&(x + k)) {
+ ans.insert(x);
}
+ vis.insert(x);
}
- res
+ ans.len() as i32
}
}
diff --git a/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.ts b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.ts
new file mode 100644
index 0000000000000..9081b68088cf0
--- /dev/null
+++ b/solution/0500-0599/0532.K-diff Pairs in an Array/Solution.ts
@@ -0,0 +1,14 @@
+function findPairs(nums: number[], k: number): number {
+ const ans = new Set();
+ const vis = new Set();
+ for (const x of nums) {
+ if (vis.has(x - k)) {
+ ans.add(x - k);
+ }
+ if (vis.has(x + k)) {
+ ans.add(x);
+ }
+ vis.add(x);
+ }
+ return ans.size;
+}
diff --git a/solution/0500-0599/0568.Maximum Vacation Days/README.md b/solution/0500-0599/0568.Maximum Vacation Days/README.md
index 0b759e9bf93c8..c482a1c70a038 100644
--- a/solution/0500-0599/0568.Maximum Vacation Days/README.md
+++ b/solution/0500-0599/0568.Maximum Vacation Days/README.md
@@ -98,7 +98,7 @@ Ans = 7 + 7 + 7 = 21
我们定义 $f[k][j]$ 表示前 $k$ 周，且最后一周在城市 $j$ 休假的最长天数。初始时 $f[0][0]=0$，其它 $f[0][j]=-\infty$。答案为 $\max_{j=0}^{n-1} f[K][j]$。
-接下来，我们考虑如何计算 $f[k][j]$。对于当前这一周，我们可以枚举上一周所在的城市 $i$，城市 $i$ 可以和城市 $j$ 相等，那么 $f[k][j] = f[k-1][i]$；也可以和城市 $j$ 不相等，如果不相等，我们需要判断是否可以从城市 $i$ 飞到城市 $j$，如果可以，那么 $f[k][j] = max(f[k][j], f[k-1][i])$。最后，我们还需要加上这一周在城市 $j$ 休假的天数 $days[j][k-1]$。
+接下来，我们考虑如何计算 $f[k][j]$。对于当前这一周，我们可以枚举上一周所在的城市 $i$，城市 $i$ 可以和城市 $j$ 相等，那么 $f[k][j] = f[k-1][i]$；也可以和城市 $j$ 不相等，如果不相等，我们需要判断是否可以从城市 $i$ 飞到城市 $j$，如果可以，那么 $f[k][j] = \max(f[k][j], f[k-1][i])$。最后，我们还需要加上这一周在城市 $j$ 休假的天数 $\textit{days}[j][k-1]$。
最终的答案即为 $\max_{j=0}^{n-1} f[K][j]$。
@@ -220,6 +220,59 @@ func maxVacationDays(flights [][]int, days [][]int) (ans int) {
}
```
+#### TypeScript
+
+```ts
+function maxVacationDays(flights: number[][], days: number[][]): number {
+ const n = flights.length;
+ const K = days[0].length;
+ const inf = Number.NEGATIVE_INFINITY;
+ const f: number[][] = Array.from({ length: K + 1 }, () => Array(n).fill(inf));
+ f[0][0] = 0;
+ for (let k = 1; k <= K; k++) {
+ for (let j = 0; j < n; j++) {
+ f[k][j] = f[k - 1][j];
+ for (let i = 0; i < n; i++) {
+ if (flights[i][j]) {
+ f[k][j] = Math.max(f[k][j], f[k - 1][i]);
+ }
+ }
+ f[k][j] += days[j][k - 1];
+ }
+ }
+ return Math.max(...f[K]);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_vacation_days(flights: Vec>, days: Vec>) -> i32 {
+ let n = flights.len();
+ let k = days[0].len();
+ let inf = i32::MIN;
+
+ let mut f = vec![vec![inf; n]; k + 1];
+ f[0][0] = 0;
+
+ for step in 1..=k {
+ for j in 0..n {
+ f[step][j] = f[step - 1][j];
+ for i in 0..n {
+ if flights[i][j] == 1 {
+ f[step][j] = f[step][j].max(f[step - 1][i]);
+ }
+ }
+ f[step][j] += days[j][step - 1];
+ }
+ }
+
+ *f[k].iter().max().unwrap()
+ }
+}
+```
+
diff --git a/solution/0500-0599/0568.Maximum Vacation Days/README_EN.md b/solution/0500-0599/0568.Maximum Vacation Days/README_EN.md
index 03606fb98ba45..76fc29b6c73be 100644
--- a/solution/0500-0599/0568.Maximum Vacation Days/README_EN.md
+++ b/solution/0500-0599/0568.Maximum Vacation Days/README_EN.md
@@ -211,6 +211,59 @@ func maxVacationDays(flights [][]int, days [][]int) (ans int) {
}
```
+#### TypeScript
+
+```ts
+function maxVacationDays(flights: number[][], days: number[][]): number {
+ const n = flights.length;
+ const K = days[0].length;
+ const inf = Number.NEGATIVE_INFINITY;
+ const f: number[][] = Array.from({ length: K + 1 }, () => Array(n).fill(inf));
+ f[0][0] = 0;
+ for (let k = 1; k <= K; k++) {
+ for (let j = 0; j < n; j++) {
+ f[k][j] = f[k - 1][j];
+ for (let i = 0; i < n; i++) {
+ if (flights[i][j]) {
+ f[k][j] = Math.max(f[k][j], f[k - 1][i]);
+ }
+ }
+ f[k][j] += days[j][k - 1];
+ }
+ }
+ return Math.max(...f[K]);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_vacation_days(flights: Vec>, days: Vec>) -> i32 {
+ let n = flights.len();
+ let k = days[0].len();
+ let inf = i32::MIN;
+
+ let mut f = vec![vec![inf; n]; k + 1];
+ f[0][0] = 0;
+
+ for step in 1..=k {
+ for j in 0..n {
+ f[step][j] = f[step - 1][j];
+ for i in 0..n {
+ if flights[i][j] == 1 {
+ f[step][j] = f[step][j].max(f[step - 1][i]);
+ }
+ }
+ f[step][j] += days[j][step - 1];
+ }
+ }
+
+ *f[k].iter().max().unwrap()
+ }
+}
+```
+
diff --git a/solution/0500-0599/0568.Maximum Vacation Days/Solution.rs b/solution/0500-0599/0568.Maximum Vacation Days/Solution.rs
new file mode 100644
index 0000000000000..2483954a7ad16
--- /dev/null
+++ b/solution/0500-0599/0568.Maximum Vacation Days/Solution.rs
@@ -0,0 +1,24 @@
+impl Solution {
+ pub fn max_vacation_days(flights: Vec>, days: Vec>) -> i32 {
+ let n = flights.len();
+ let k = days[0].len();
+ let inf = i32::MIN;
+
+ let mut f = vec![vec![inf; n]; k + 1];
+ f[0][0] = 0;
+
+ for step in 1..=k {
+ for j in 0..n {
+ f[step][j] = f[step - 1][j];
+ for i in 0..n {
+ if flights[i][j] == 1 {
+ f[step][j] = f[step][j].max(f[step - 1][i]);
+ }
+ }
+ f[step][j] += days[j][step - 1];
+ }
+ }
+
+ *f[k].iter().max().unwrap()
+ }
+}
diff --git a/solution/0500-0599/0568.Maximum Vacation Days/Solution.ts b/solution/0500-0599/0568.Maximum Vacation Days/Solution.ts
new file mode 100644
index 0000000000000..23f7d25974af5
--- /dev/null
+++ b/solution/0500-0599/0568.Maximum Vacation Days/Solution.ts
@@ -0,0 +1,19 @@
+function maxVacationDays(flights: number[][], days: number[][]): number {
+ const n = flights.length;
+ const K = days[0].length;
+ const inf = Number.NEGATIVE_INFINITY;
+ const f: number[][] = Array.from({ length: K + 1 }, () => Array(n).fill(inf));
+ f[0][0] = 0;
+ for (let k = 1; k <= K; k++) {
+ for (let j = 0; j < n; j++) {
+ f[k][j] = f[k - 1][j];
+ for (let i = 0; i < n; i++) {
+ if (flights[i][j]) {
+ f[k][j] = Math.max(f[k][j], f[k - 1][i]);
+ }
+ }
+ f[k][j] += days[j][k - 1];
+ }
+ }
+ return Math.max(...f[K]);
+}
diff --git a/solution/0600-0699/0631.Design Excel Sum Formula/README.md b/solution/0600-0699/0631.Design Excel Sum Formula/README.md
index 5559a4feeaeec..fe1c6cd51ca57 100644
--- a/solution/0600-0699/0631.Design Excel Sum Formula/README.md
+++ b/solution/0600-0699/0631.Design Excel Sum Formula/README.md
@@ -7,6 +7,8 @@ tags:
- 设计
- 拓扑排序
- 数组
+ - 哈希表
+ - 字符串
- 矩阵
---
diff --git a/solution/0600-0699/0631.Design Excel Sum Formula/README_EN.md b/solution/0600-0699/0631.Design Excel Sum Formula/README_EN.md
index cd7ce68ca40f6..6c32824892c92 100644
--- a/solution/0600-0699/0631.Design Excel Sum Formula/README_EN.md
+++ b/solution/0600-0699/0631.Design Excel Sum Formula/README_EN.md
@@ -7,6 +7,8 @@ tags:
- Design
- Topological Sort
- Array
+ - Hash Table
+ - String
- Matrix
---
diff --git a/solution/0600-0699/0676.Implement Magic Dictionary/README.md b/solution/0600-0699/0676.Implement Magic Dictionary/README.md
index f7f70ca3b0acc..4ce831461d15b 100644
--- a/solution/0600-0699/0676.Implement Magic Dictionary/README.md
+++ b/solution/0600-0699/0676.Implement Magic Dictionary/README.md
@@ -430,53 +430,59 @@ class MagicDictionary {
#### Rust
```rust
-use std::collections::HashMap;
-
-#[derive(Clone)]
struct Trie {
- children: Vec>>,
+ children: [Option>; 26],
is_end: bool,
}
impl Trie {
fn new() -> Self {
Trie {
- children: vec![None; 26],
+ children: Default::default(),
is_end: false,
}
}
- fn insert(&mut self, word: &str) {
+ fn insert(&mut self, w: &str) {
let mut node = self;
- for &ch in word.as_bytes() {
- let index = (ch - b'a') as usize;
- node = node.children[index].get_or_insert_with(|| Box::new(Trie::new()));
+ for c in w.chars() {
+ let i = (c as usize) - ('a' as usize);
+ if node.children[i].is_none() {
+ node.children[i] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[i].as_mut().unwrap();
}
node.is_end = true;
}
- fn search(&self, word: &str, diff: i32) -> bool {
- if word.is_empty() {
+ fn search(&self, w: &str) -> bool {
+ self.dfs(w, 0, 0)
+ }
+
+ fn dfs(&self, w: &str, i: usize, diff: usize) -> bool {
+ if i == w.len() {
return diff == 1 && self.is_end;
}
- let index = (word.as_bytes()[0] - b'a') as usize;
- if let Some(child) = &self.children[index] {
- if child.search(&word[1..], diff) {
+ let j = (w.chars().nth(i).unwrap() as usize) - ('a' as usize);
+
+ if let Some(child) = &self.children[j] {
+ if child.dfs(w, i + 1, diff) {
return true;
}
}
if diff == 0 {
- for (i, child) in self.children.iter().enumerate() {
- if i != index && child.is_some() {
- if child.as_ref().unwrap().search(&word[1..], 1) {
- return true;
+ for k in 0..26 {
+ if k != j {
+ if let Some(child) = &self.children[k] {
+ if child.dfs(w, i + 1, 1) {
+ return true;
+ }
}
}
}
}
-
false
}
}
@@ -485,23 +491,21 @@ struct MagicDictionary {
trie: Trie,
}
-/**
- * `&self` means the method takes an immutable reference.
- * If you need a mutable reference, change it to `&mut self` instead.
- */
impl MagicDictionary {
fn new() -> Self {
- MagicDictionary { trie: Trie::new() }
+ MagicDictionary {
+ trie: Trie::new(),
+ }
}
fn build_dict(&mut self, dictionary: Vec) {
- for word in dictionary {
- self.trie.insert(&word);
+ for w in dictionary {
+ self.trie.insert(&w);
}
}
fn search(&self, search_word: String) -> bool {
- self.trie.search(&search_word, 0)
+ self.trie.search(&search_word)
}
}
```
diff --git a/solution/0600-0699/0676.Implement Magic Dictionary/README_EN.md b/solution/0600-0699/0676.Implement Magic Dictionary/README_EN.md
index 0eb29d8d584a3..649b6b231448e 100644
--- a/solution/0600-0699/0676.Implement Magic Dictionary/README_EN.md
+++ b/solution/0600-0699/0676.Implement Magic Dictionary/README_EN.md
@@ -422,53 +422,59 @@ class MagicDictionary {
#### Rust
```rust
-use std::collections::HashMap;
-
-#[derive(Clone)]
struct Trie {
- children: Vec>>,
+ children: [Option>; 26],
is_end: bool,
}
impl Trie {
fn new() -> Self {
Trie {
- children: vec![None; 26],
+ children: Default::default(),
is_end: false,
}
}
- fn insert(&mut self, word: &str) {
+ fn insert(&mut self, w: &str) {
let mut node = self;
- for &ch in word.as_bytes() {
- let index = (ch - b'a') as usize;
- node = node.children[index].get_or_insert_with(|| Box::new(Trie::new()));
+ for c in w.chars() {
+ let i = (c as usize) - ('a' as usize);
+ if node.children[i].is_none() {
+ node.children[i] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[i].as_mut().unwrap();
}
node.is_end = true;
}
- fn search(&self, word: &str, diff: i32) -> bool {
- if word.is_empty() {
+ fn search(&self, w: &str) -> bool {
+ self.dfs(w, 0, 0)
+ }
+
+ fn dfs(&self, w: &str, i: usize, diff: usize) -> bool {
+ if i == w.len() {
return diff == 1 && self.is_end;
}
- let index = (word.as_bytes()[0] - b'a') as usize;
- if let Some(child) = &self.children[index] {
- if child.search(&word[1..], diff) {
+ let j = (w.chars().nth(i).unwrap() as usize) - ('a' as usize);
+
+ if let Some(child) = &self.children[j] {
+ if child.dfs(w, i + 1, diff) {
return true;
}
}
if diff == 0 {
- for (i, child) in self.children.iter().enumerate() {
- if i != index && child.is_some() {
- if child.as_ref().unwrap().search(&word[1..], 1) {
- return true;
+ for k in 0..26 {
+ if k != j {
+ if let Some(child) = &self.children[k] {
+ if child.dfs(w, i + 1, 1) {
+ return true;
+ }
}
}
}
}
-
false
}
}
@@ -477,23 +483,21 @@ struct MagicDictionary {
trie: Trie,
}
-/**
- * `&self` means the method takes an immutable reference.
- * If you need a mutable reference, change it to `&mut self` instead.
- */
impl MagicDictionary {
fn new() -> Self {
- MagicDictionary { trie: Trie::new() }
+ MagicDictionary {
+ trie: Trie::new(),
+ }
}
fn build_dict(&mut self, dictionary: Vec) {
- for word in dictionary {
- self.trie.insert(&word);
+ for w in dictionary {
+ self.trie.insert(&w);
}
}
fn search(&self, search_word: String) -> bool {
- self.trie.search(&search_word, 0)
+ self.trie.search(&search_word)
}
}
```
diff --git a/solution/0600-0699/0676.Implement Magic Dictionary/Solution.rs b/solution/0600-0699/0676.Implement Magic Dictionary/Solution.rs
index c8ce751b9f346..55c42ecb0e9dd 100644
--- a/solution/0600-0699/0676.Implement Magic Dictionary/Solution.rs
+++ b/solution/0600-0699/0676.Implement Magic Dictionary/Solution.rs
@@ -1,50 +1,56 @@
-use std::collections::HashMap;
-
-#[derive(Clone)]
struct Trie {
- children: Vec>>,
+ children: [Option>; 26],
is_end: bool,
}
impl Trie {
fn new() -> Self {
Trie {
- children: vec![None; 26],
+ children: Default::default(),
is_end: false,
}
}
- fn insert(&mut self, word: &str) {
+ fn insert(&mut self, w: &str) {
let mut node = self;
- for &ch in word.as_bytes() {
- let index = (ch - b'a') as usize;
- node = node.children[index].get_or_insert_with(|| Box::new(Trie::new()));
+ for c in w.chars() {
+ let i = (c as usize) - ('a' as usize);
+ if node.children[i].is_none() {
+ node.children[i] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[i].as_mut().unwrap();
}
node.is_end = true;
}
- fn search(&self, word: &str, diff: i32) -> bool {
- if word.is_empty() {
+ fn search(&self, w: &str) -> bool {
+ self.dfs(w, 0, 0)
+ }
+
+ fn dfs(&self, w: &str, i: usize, diff: usize) -> bool {
+ if i == w.len() {
return diff == 1 && self.is_end;
}
- let index = (word.as_bytes()[0] - b'a') as usize;
- if let Some(child) = &self.children[index] {
- if child.search(&word[1..], diff) {
+ let j = (w.chars().nth(i).unwrap() as usize) - ('a' as usize);
+
+ if let Some(child) = &self.children[j] {
+ if child.dfs(w, i + 1, diff) {
return true;
}
}
if diff == 0 {
- for (i, child) in self.children.iter().enumerate() {
- if i != index && child.is_some() {
- if child.as_ref().unwrap().search(&word[1..], 1) {
- return true;
+ for k in 0..26 {
+ if k != j {
+ if let Some(child) = &self.children[k] {
+ if child.dfs(w, i + 1, 1) {
+ return true;
+ }
}
}
}
}
-
false
}
}
@@ -53,22 +59,18 @@ struct MagicDictionary {
trie: Trie,
}
-/**
- * `&self` means the method takes an immutable reference.
- * If you need a mutable reference, change it to `&mut self` instead.
- */
impl MagicDictionary {
fn new() -> Self {
MagicDictionary { trie: Trie::new() }
}
fn build_dict(&mut self, dictionary: Vec) {
- for word in dictionary {
- self.trie.insert(&word);
+ for w in dictionary {
+ self.trie.insert(&w);
}
}
fn search(&self, search_word: String) -> bool {
- self.trie.search(&search_word, 0)
+ self.trie.search(&search_word)
}
}
diff --git a/solution/0600-0699/0677.Map Sum Pairs/README.md b/solution/0600-0699/0677.Map Sum Pairs/README.md
index 3d87dc6955cc0..3d6d4d7790438 100644
--- a/solution/0600-0699/0677.Map Sum Pairs/README.md
+++ b/solution/0600-0699/0677.Map Sum Pairs/README.md
@@ -379,6 +379,196 @@ class MapSum {
*/
```
+#### Rust
+
+```rust
+struct Trie {
+ children: Vec>>,
+ val: i32,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: (0..26).map(|_| None).collect(),
+ val: 0,
+ }
+ }
+
+ fn insert(&mut self, w: &str, x: i32) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ node.val += x;
+ }
+ }
+
+ fn search(&self, w: &str) -> i32 {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ return 0;
+ }
+ node = node.children[idx].as_ref().unwrap();
+ }
+ node.val
+ }
+}
+
+struct MapSum {
+ d: std::collections::HashMap,
+ trie: Trie,
+}
+
+impl MapSum {
+ fn new() -> Self {
+ MapSum {
+ d: std::collections::HashMap::new(),
+ trie: Trie::new(),
+ }
+ }
+
+ fn insert(&mut self, key: String, val: i32) {
+ let x = val - self.d.get(&key).unwrap_or(&0);
+ self.d.insert(key.clone(), val);
+ self.trie.insert(&key, x);
+ }
+
+ fn sum(&self, prefix: String) -> i32 {
+ self.trie.search(&prefix)
+ }
+}
+```
+
+#### JavaScript
+
+```js
+class Trie {
+ constructor() {
+ this.children = new Array(26);
+ this.val = 0;
+ }
+
+ insert(w, x) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ node.children[i] = new Trie();
+ }
+ node = node.children[i];
+ node.val += x;
+ }
+ }
+
+ search(w) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ return 0;
+ }
+ node = node.children[i];
+ }
+ return node.val;
+ }
+}
+
+var MapSum = function () {
+ this.d = new Map();
+ this.t = new Trie();
+};
+
+/**
+ * @param {string} key
+ * @param {number} val
+ * @return {void}
+ */
+MapSum.prototype.insert = function (key, val) {
+ const x = val - (this.d.get(key) ?? 0);
+ this.d.set(key, val);
+ this.t.insert(key, x);
+};
+
+/**
+ * @param {string} prefix
+ * @return {number}
+ */
+MapSum.prototype.sum = function (prefix) {
+ return this.t.search(prefix);
+};
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * var obj = new MapSum()
+ * obj.insert(key,val)
+ * var param_2 = obj.sum(prefix)
+ */
+```
+
+#### C#
+
+```cs
+public class Trie {
+ private Trie[] children = new Trie[26];
+ private int val;
+
+ public void Insert(string w, int x) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx];
+ node.val += x;
+ }
+ }
+
+ public int Search(string w) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ return 0;
+ }
+ node = node.children[idx];
+ }
+ return node.val;
+ }
+}
+
+public class MapSum {
+ private Dictionary d = new Dictionary();
+ private Trie trie = new Trie();
+
+ public MapSum() {
+ }
+
+ public void Insert(string key, int val) {
+ int x = val - (d.ContainsKey(key) ? d[key] : 0);
+ d[key] = val;
+ trie.Insert(key, x);
+ }
+
+ public int Sum(string prefix) {
+ return trie.Search(prefix);
+ }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.Insert(key,val);
+ * int param_2 = obj.Sum(prefix);
+ */
+```
+
diff --git a/solution/0600-0699/0677.Map Sum Pairs/README_EN.md b/solution/0600-0699/0677.Map Sum Pairs/README_EN.md
index 6ca47cee79f59..0627ece6e63be 100644
--- a/solution/0600-0699/0677.Map Sum Pairs/README_EN.md
+++ b/solution/0600-0699/0677.Map Sum Pairs/README_EN.md
@@ -68,7 +68,20 @@ mapSum.sum("ap"); // return 5 (apple + app = 3
-### Solution 1
+### Solution 1: Hash Table + Trie
+
+We use a hash table $d$ to store key-value pairs and a trie $t$ to store the prefix sums of the key-value pairs. Each node in the trie contains two pieces of information:
+
+- `val`: the total sum of the values of the key-value pairs with this node as the prefix
+- `children`: an array of length $26$ that stores the child nodes of this node
+
+When inserting a key-value pair $(key, val)$, we first check if the key exists in the hash table. If it does, the `val` of each node in the trie needs to subtract the original value of the key and then add the new value. If it does not exist, the `val` of each node in the trie needs to add the new value.
+
+When querying the prefix sum, we start from the root node of the trie and traverse the prefix string. If the current node's child nodes do not contain the character, it means the prefix does not exist in the trie, and we return $0$. Otherwise, we continue to traverse the next character until we finish traversing the prefix string and return the `val` of the current node.
+
+In terms of time complexity, the time complexity of inserting a key-value pair is $O(n)$, where $n$ is the length of the key. The time complexity of querying the prefix sum is $O(m)$, where $m$ is the length of the prefix.
+
+The space complexity is $O(n \times m \times C)$, where $n$ and $m$ are the number of keys and the maximum length of the keys, respectively; and $C$ is the size of the character set, which is $26$ in this problem.
@@ -364,6 +377,196 @@ class MapSum {
*/
```
+#### Rust
+
+```rust
+struct Trie {
+ children: Vec>>,
+ val: i32,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: (0..26).map(|_| None).collect(),
+ val: 0,
+ }
+ }
+
+ fn insert(&mut self, w: &str, x: i32) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ node.val += x;
+ }
+ }
+
+ fn search(&self, w: &str) -> i32 {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ return 0;
+ }
+ node = node.children[idx].as_ref().unwrap();
+ }
+ node.val
+ }
+}
+
+struct MapSum {
+ d: std::collections::HashMap,
+ trie: Trie,
+}
+
+impl MapSum {
+ fn new() -> Self {
+ MapSum {
+ d: std::collections::HashMap::new(),
+ trie: Trie::new(),
+ }
+ }
+
+ fn insert(&mut self, key: String, val: i32) {
+ let x = val - self.d.get(&key).unwrap_or(&0);
+ self.d.insert(key.clone(), val);
+ self.trie.insert(&key, x);
+ }
+
+ fn sum(&self, prefix: String) -> i32 {
+ self.trie.search(&prefix)
+ }
+}
+```
+
+#### JavaScript
+
+```js
+class Trie {
+ constructor() {
+ this.children = new Array(26);
+ this.val = 0;
+ }
+
+ insert(w, x) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ node.children[i] = new Trie();
+ }
+ node = node.children[i];
+ node.val += x;
+ }
+ }
+
+ search(w) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ return 0;
+ }
+ node = node.children[i];
+ }
+ return node.val;
+ }
+}
+
+var MapSum = function () {
+ this.d = new Map();
+ this.t = new Trie();
+};
+
+/**
+ * @param {string} key
+ * @param {number} val
+ * @return {void}
+ */
+MapSum.prototype.insert = function (key, val) {
+ const x = val - (this.d.get(key) ?? 0);
+ this.d.set(key, val);
+ this.t.insert(key, x);
+};
+
+/**
+ * @param {string} prefix
+ * @return {number}
+ */
+MapSum.prototype.sum = function (prefix) {
+ return this.t.search(prefix);
+};
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * var obj = new MapSum()
+ * obj.insert(key,val)
+ * var param_2 = obj.sum(prefix)
+ */
+```
+
+#### C#
+
+```cs
+public class Trie {
+ private Trie[] children = new Trie[26];
+ private int val;
+
+ public void Insert(string w, int x) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx];
+ node.val += x;
+ }
+ }
+
+ public int Search(string w) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ return 0;
+ }
+ node = node.children[idx];
+ }
+ return node.val;
+ }
+}
+
+public class MapSum {
+ private Dictionary d = new Dictionary();
+ private Trie trie = new Trie();
+
+ public MapSum() {
+ }
+
+ public void Insert(string key, int val) {
+ int x = val - (d.ContainsKey(key) ? d[key] : 0);
+ d[key] = val;
+ trie.Insert(key, x);
+ }
+
+ public int Sum(string prefix) {
+ return trie.Search(prefix);
+ }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.Insert(key,val);
+ * int param_2 = obj.Sum(prefix);
+ */
+```
+
diff --git a/solution/0600-0699/0677.Map Sum Pairs/Solution.cs b/solution/0600-0699/0677.Map Sum Pairs/Solution.cs
new file mode 100644
index 0000000000000..e4361a2a35679
--- /dev/null
+++ b/solution/0600-0699/0677.Map Sum Pairs/Solution.cs
@@ -0,0 +1,53 @@
+public class Trie {
+ private Trie[] children = new Trie[26];
+ private int val;
+
+ public void Insert(string w, int x) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx];
+ node.val += x;
+ }
+ }
+
+ public int Search(string w) {
+ Trie node = this;
+ for (int i = 0; i < w.Length; ++i) {
+ int idx = w[i] - 'a';
+ if (node.children[idx] == null) {
+ return 0;
+ }
+ node = node.children[idx];
+ }
+ return node.val;
+ }
+}
+
+public class MapSum {
+ private Dictionary d = new Dictionary();
+ private Trie trie = new Trie();
+
+ public MapSum() {
+ }
+
+ public void Insert(string key, int val) {
+ int x = val - (d.ContainsKey(key) ? d[key] : 0);
+ d[key] = val;
+ trie.Insert(key, x);
+ }
+
+ public int Sum(string prefix) {
+ return trie.Search(prefix);
+ }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.Insert(key,val);
+ * int param_2 = obj.Sum(prefix);
+ */
diff --git a/solution/0600-0699/0677.Map Sum Pairs/Solution.js b/solution/0600-0699/0677.Map Sum Pairs/Solution.js
new file mode 100644
index 0000000000000..2dee19e3d25c2
--- /dev/null
+++ b/solution/0600-0699/0677.Map Sum Pairs/Solution.js
@@ -0,0 +1,61 @@
+class Trie {
+ constructor() {
+ this.children = new Array(26);
+ this.val = 0;
+ }
+
+ insert(w, x) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ node.children[i] = new Trie();
+ }
+ node = node.children[i];
+ node.val += x;
+ }
+ }
+
+ search(w) {
+ let node = this;
+ for (const c of w) {
+ const i = c.charCodeAt(0) - 97;
+ if (!node.children[i]) {
+ return 0;
+ }
+ node = node.children[i];
+ }
+ return node.val;
+ }
+}
+
+var MapSum = function () {
+ this.d = new Map();
+ this.t = new Trie();
+};
+
+/**
+ * @param {string} key
+ * @param {number} val
+ * @return {void}
+ */
+MapSum.prototype.insert = function (key, val) {
+ const x = val - (this.d.get(key) ?? 0);
+ this.d.set(key, val);
+ this.t.insert(key, x);
+};
+
+/**
+ * @param {string} prefix
+ * @return {number}
+ */
+MapSum.prototype.sum = function (prefix) {
+ return this.t.search(prefix);
+};
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * var obj = new MapSum()
+ * obj.insert(key,val)
+ * var param_2 = obj.sum(prefix)
+ */
diff --git a/solution/0600-0699/0677.Map Sum Pairs/Solution.rs b/solution/0600-0699/0677.Map Sum Pairs/Solution.rs
new file mode 100644
index 0000000000000..baac4b318e933
--- /dev/null
+++ b/solution/0600-0699/0677.Map Sum Pairs/Solution.rs
@@ -0,0 +1,61 @@
+struct Trie {
+ children: Vec>>,
+ val: i32,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: (0..26).map(|_| None).collect(),
+ val: 0,
+ }
+ }
+
+ fn insert(&mut self, w: &str, x: i32) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ node.val += x;
+ }
+ }
+
+ fn search(&self, w: &str) -> i32 {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ return 0;
+ }
+ node = node.children[idx].as_ref().unwrap();
+ }
+ node.val
+ }
+}
+
+struct MapSum {
+ d: std::collections::HashMap,
+ trie: Trie,
+}
+
+impl MapSum {
+ fn new() -> Self {
+ MapSum {
+ d: std::collections::HashMap::new(),
+ trie: Trie::new(),
+ }
+ }
+
+ fn insert(&mut self, key: String, val: i32) {
+ let x = val - self.d.get(&key).unwrap_or(&0);
+ self.d.insert(key.clone(), val);
+ self.trie.insert(&key, x);
+ }
+
+ fn sum(&self, prefix: String) -> i32 {
+ self.trie.search(&prefix)
+ }
+}
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 8f441c16a01eb..bf15fcb915ab3 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/README.md
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/README.md
@@ -60,121 +60,202 @@ tags:
-### 方法一：哈希表
+### 方法一：字典树
-用哈希表存放所有单词。遍历这些单词，找出**长度最长且字典序最小**的单词。
+我们可以使用字典树来存储所有的单词，然后遍历所有的单词，判断当前单词是否可以由字典树中的其他单词逐步添加一个字母组成，找出满足条件的最长的，且字典序最小的单词。
+
+时间复杂度 $O(L)$，空间复杂度 $O(L)$，其中 $L$ 是所有单词的长度之和。
#### Python3
```python
+class Trie:
+ def __init__(self):
+ self.children: List[Optional[Trie]] = [None] * 26
+ self.is_end = False
+
+ def insert(self, w: str):
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ node.children[idx] = Trie()
+ node = node.children[idx]
+ node.is_end = True
+
+ def search(self, w: str) -> bool:
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ return False
+ node = node.children[idx]
+ if not node.is_end:
+ return False
+ return True
+
+
class Solution:
def longestWord(self, words: List[str]) -> str:
- cnt, ans = 0, ''
- s = set(words)
- for w in s:
- n = len(w)
- if all(w[:i] in s for i in range(1, n)):
- if cnt < n:
- cnt, ans = n, w
- elif cnt == n and w < ans:
- ans = w
+ trie = Trie()
+ for w in words:
+ trie.insert(w)
+ ans = ""
+ for w in words:
+ if trie.search(w) and (
+ len(ans) < len(w) or (len(ans) == len(w) and ans > w)
+ ):
+ ans = w
return ans
```
#### Java
```java
-class Solution {
- private Set s;
-
- public String longestWord(String[] words) {
- s = new HashSet<>(Arrays.asList(words));
- int cnt = 0;
- String ans = "";
- for (String w : s) {
- int n = w.length();
- if (check(w)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w.compareTo(ans) < 0) {
- ans = w;
- }
+class Trie {
+ private Trie[] children = new Trie[26];
+ private boolean isEnd = false;
+
+ public void insert(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx];
}
- return ans;
+ node.isEnd = true;
}
- private boolean check(String word) {
- for (int i = 1, n = word.length(); i < n; ++i) {
- if (!s.contains(word.substring(0, i))) {
+ public boolean search(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null || !node.children[idx].isEnd) {
return false;
}
+ node = node.children[idx];
}
return true;
}
}
+
+class Solution {
+ public String longestWord(String[] words) {
+ Trie trie = new Trie();
+ for (String w : words) {
+ trie.insert(w);
+ }
+ String ans = "";
+ for (String w : words) {
+ if (trie.search(w)
+ && (ans.length() < w.length()
+ || (ans.length() == w.length() && w.compareTo(ans) < 0))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+}
```
#### C++
```cpp
-class Solution {
+class Trie {
public:
- string longestWord(vector& words) {
- unordered_set s(words.begin(), words.end());
- int cnt = 0;
- string ans = "";
- for (auto w : s) {
- int n = w.size();
- if (check(w, s)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w < ans)
- ans = w;
+ Trie* children[26] = {nullptr};
+ bool isEnd = false;
+
+ void insert(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr) {
+ node->children[idx] = new Trie();
}
+ node = node->children[idx];
}
- return ans;
+ node->isEnd = true;
}
- bool check(string& word, unordered_set& s) {
- for (int i = 1, n = word.size(); i < n; ++i)
- if (!s.count(word.substr(0, i)))
+ bool search(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr || !node->children[idx]->isEnd) {
return false;
+ }
+ node = node->children[idx];
+ }
return true;
}
};
+
+class Solution {
+public:
+ string longestWord(vector& words) {
+ Trie trie;
+ for (const string& w : words) {
+ trie.insert(w);
+ }
+
+ string ans = "";
+ for (const string& w : words) {
+ if (trie.search(w) && (ans.length() < w.length() || (ans.length() == w.length() && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children [26]*Trie
+ isEnd bool
+}
+
+func (t *Trie) insert(w string) {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil {
+ node.children[idx] = &Trie{}
+ }
+ node = node.children[idx]
+ }
+ node.isEnd = true
+}
+
+func (t *Trie) search(w string) bool {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil || !node.children[idx].isEnd {
+ return false
+ }
+ node = node.children[idx]
+ }
+ return true
+}
+
func longestWord(words []string) string {
- s := make(map[string]bool)
+ trie := &Trie{}
for _, w := range words {
- s[w] = true
+ trie.insert(w)
}
- cnt := 0
+
ans := ""
- check := func(word string) bool {
- for i, n := 1, len(word); i < n; i++ {
- if !s[word[:i]] {
- return false
- }
- }
- return true
- }
- for w, _ := range s {
- n := len(w)
- if check(w) {
- if cnt < n {
- cnt, ans = n, w
- } else if cnt == n && w < ans {
- ans = w
- }
+ for _, w := range words {
+ if trie.search(w) && (len(ans) < len(w) || (len(ans) == len(w) && w < ans)) {
+ ans = w
}
}
return ans
@@ -184,63 +265,165 @@ func longestWord(words []string) string {
#### TypeScript
```ts
-function longestWord(words: string[]): string {
- words.sort((a, b) => {
- const n = a.length;
- const m = b.length;
- if (n === m) {
- return a < b ? -1 : 1;
- }
- return m - n;
- });
- for (const word of words) {
- let isPass = true;
- for (let i = 1; i <= word.length; i++) {
- if (!words.includes(word.slice(0, i))) {
- isPass = false;
- break;
+class Trie {
+ children: (Trie | null)[] = new Array(26).fill(null);
+ isEnd: boolean = false;
+
+ insert(w: string): void {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx]!;
}
- if (isPass) {
- return word;
+ node.isEnd = true;
+ }
+
+ search(w: string): boolean {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx]!.isEnd) {
+ return false;
+ }
+ node = node.children[idx]!;
}
+ return true;
}
- return '';
+}
+
+function longestWord(words: string[]): string {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
+
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
}
```
#### Rust
```rust
-impl Solution {
- pub fn longest_word(mut words: Vec) -> String {
- words.sort_unstable_by(|a, b| (b.len(), a).cmp(&(a.len(), b)));
- for word in words.iter() {
- let mut is_pass = true;
- for i in 1..=word.len() {
- if !words.contains(&word[..i].to_string()) {
- is_pass = false;
- break;
- }
+struct Trie {
+ children: [Option>; 26],
+ is_end: bool,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: Default::default(),
+ is_end: false,
+ }
+ }
+
+ fn insert(&mut self, w: &str) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ }
+ node.is_end = true;
+ }
+
+ fn search(&self, w: &str) -> bool {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() || !node.children[idx].as_ref().unwrap().is_end {
+ return false;
}
- if is_pass {
- return word.clone();
+ node = node.children[idx].as_ref().unwrap();
+ }
+ true
+ }
+}
+
+impl Solution {
+ pub fn longest_word(words: Vec) -> String {
+ let mut trie = Trie::new();
+ for w in &words {
+ trie.insert(w);
+ }
+
+ let mut ans = String::new();
+ for w in words {
+ if trie.search(&w) && (ans.len() < w.len() || (ans.len() == w.len() && w < ans)) {
+ ans = w;
}
}
- String::new()
+ ans
}
}
```
-
+#### JavaScript
+
+```js
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+var longestWord = function (words) {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
-
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+};
-
+class Trie {
+ constructor() {
+ this.children = Array(26).fill(null);
+ this.isEnd = false;
+ }
-### 方法二：排序
+ insert(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx];
+ }
+ node.isEnd = true;
+ }
+
+ search(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx].isEnd) {
+ return false;
+ }
+ node = node.children[idx];
+ }
+ return true;
+ }
+}
+```
-优先返回符合条件、**长度最长且字典序最小**的单词，那么可以进行依照该规则，先对 `words` 进行排序，免去多个结果之间的比较。
+
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/README_EN.md b/solution/0700-0799/0720.Longest Word in Dictionary/README_EN.md
index 886cf6301b6d7..83a5493fded69 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/README_EN.md
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/README_EN.md
@@ -58,119 +58,202 @@ tags:
-### Solution 1
+### Solution 1: Trie
+
+We can use a trie to store all the words, then traverse all the words to determine if the current word can be formed by adding one letter at a time from other words in the trie. Find the longest word that meets the condition and has the smallest lexicographical order.
+
+The time complexity is $O(L)$, and the space complexity is $O(L)$, where $L$ is the sum of the lengths of all words.
#### Python3
```python
+class Trie:
+ def __init__(self):
+ self.children: List[Optional[Trie]] = [None] * 26
+ self.is_end = False
+
+ def insert(self, w: str):
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ node.children[idx] = Trie()
+ node = node.children[idx]
+ node.is_end = True
+
+ def search(self, w: str) -> bool:
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ return False
+ node = node.children[idx]
+ if not node.is_end:
+ return False
+ return True
+
+
class Solution:
def longestWord(self, words: List[str]) -> str:
- cnt, ans = 0, ''
- s = set(words)
- for w in s:
- n = len(w)
- if all(w[:i] in s for i in range(1, n)):
- if cnt < n:
- cnt, ans = n, w
- elif cnt == n and w < ans:
- ans = w
+ trie = Trie()
+ for w in words:
+ trie.insert(w)
+ ans = ""
+ for w in words:
+ if trie.search(w) and (
+ len(ans) < len(w) or (len(ans) == len(w) and ans > w)
+ ):
+ ans = w
return ans
```
#### Java
```java
-class Solution {
- private Set s;
-
- public String longestWord(String[] words) {
- s = new HashSet<>(Arrays.asList(words));
- int cnt = 0;
- String ans = "";
- for (String w : s) {
- int n = w.length();
- if (check(w)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w.compareTo(ans) < 0) {
- ans = w;
- }
+class Trie {
+ private Trie[] children = new Trie[26];
+ private boolean isEnd = false;
+
+ public void insert(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx];
}
- return ans;
+ node.isEnd = true;
}
- private boolean check(String word) {
- for (int i = 1, n = word.length(); i < n; ++i) {
- if (!s.contains(word.substring(0, i))) {
+ public boolean search(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null || !node.children[idx].isEnd) {
return false;
}
+ node = node.children[idx];
}
return true;
}
}
+
+class Solution {
+ public String longestWord(String[] words) {
+ Trie trie = new Trie();
+ for (String w : words) {
+ trie.insert(w);
+ }
+ String ans = "";
+ for (String w : words) {
+ if (trie.search(w)
+ && (ans.length() < w.length()
+ || (ans.length() == w.length() && w.compareTo(ans) < 0))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+}
```
#### C++
```cpp
-class Solution {
+class Trie {
public:
- string longestWord(vector& words) {
- unordered_set s(words.begin(), words.end());
- int cnt = 0;
- string ans = "";
- for (auto w : s) {
- int n = w.size();
- if (check(w, s)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w < ans)
- ans = w;
+ Trie* children[26] = {nullptr};
+ bool isEnd = false;
+
+ void insert(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr) {
+ node->children[idx] = new Trie();
}
+ node = node->children[idx];
}
- return ans;
+ node->isEnd = true;
}
- bool check(string& word, unordered_set& s) {
- for (int i = 1, n = word.size(); i < n; ++i)
- if (!s.count(word.substr(0, i)))
+ bool search(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr || !node->children[idx]->isEnd) {
return false;
+ }
+ node = node->children[idx];
+ }
return true;
}
};
+
+class Solution {
+public:
+ string longestWord(vector& words) {
+ Trie trie;
+ for (const string& w : words) {
+ trie.insert(w);
+ }
+
+ string ans = "";
+ for (const string& w : words) {
+ if (trie.search(w) && (ans.length() < w.length() || (ans.length() == w.length() && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children [26]*Trie
+ isEnd bool
+}
+
+func (t *Trie) insert(w string) {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil {
+ node.children[idx] = &Trie{}
+ }
+ node = node.children[idx]
+ }
+ node.isEnd = true
+}
+
+func (t *Trie) search(w string) bool {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil || !node.children[idx].isEnd {
+ return false
+ }
+ node = node.children[idx]
+ }
+ return true
+}
+
func longestWord(words []string) string {
- s := make(map[string]bool)
+ trie := &Trie{}
for _, w := range words {
- s[w] = true
+ trie.insert(w)
}
- cnt := 0
+
ans := ""
- check := func(word string) bool {
- for i, n := 1, len(word); i < n; i++ {
- if !s[word[:i]] {
- return false
- }
- }
- return true
- }
- for w, _ := range s {
- n := len(w)
- if check(w) {
- if cnt < n {
- cnt, ans = n, w
- } else if cnt == n && w < ans {
- ans = w
- }
+ for _, w := range words {
+ if trie.search(w) && (len(ans) < len(w) || (len(ans) == len(w) && w < ans)) {
+ ans = w
}
}
return ans
@@ -180,50 +263,160 @@ func longestWord(words []string) string {
#### TypeScript
```ts
-function longestWord(words: string[]): string {
- words.sort((a, b) => {
- const n = a.length;
- const m = b.length;
- if (n === m) {
- return a < b ? -1 : 1;
- }
- return m - n;
- });
- for (const word of words) {
- let isPass = true;
- for (let i = 1; i <= word.length; i++) {
- if (!words.includes(word.slice(0, i))) {
- isPass = false;
- break;
+class Trie {
+ children: (Trie | null)[] = new Array(26).fill(null);
+ isEnd: boolean = false;
+
+ insert(w: string): void {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx]!;
}
- if (isPass) {
- return word;
+ node.isEnd = true;
+ }
+
+ search(w: string): boolean {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx]!.isEnd) {
+ return false;
+ }
+ node = node.children[idx]!;
}
+ return true;
}
- return '';
+}
+
+function longestWord(words: string[]): string {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
+
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
}
```
#### Rust
```rust
+struct Trie {
+ children: [Option>; 26],
+ is_end: bool,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: Default::default(),
+ is_end: false,
+ }
+ }
+
+ fn insert(&mut self, w: &str) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ }
+ node.is_end = true;
+ }
+
+ fn search(&self, w: &str) -> bool {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() || !node.children[idx].as_ref().unwrap().is_end {
+ return false;
+ }
+ node = node.children[idx].as_ref().unwrap();
+ }
+ true
+ }
+}
+
impl Solution {
- pub fn longest_word(mut words: Vec) -> String {
- words.sort_unstable_by(|a, b| (b.len(), a).cmp(&(a.len(), b)));
- for word in words.iter() {
- let mut is_pass = true;
- for i in 1..=word.len() {
- if !words.contains(&word[..i].to_string()) {
- is_pass = false;
- break;
- }
+ pub fn longest_word(words: Vec) -> String {
+ let mut trie = Trie::new();
+ for w in &words {
+ trie.insert(w);
+ }
+
+ let mut ans = String::new();
+ for w in words {
+ if trie.search(&w) && (ans.len() < w.len() || (ans.len() == w.len() && w < ans)) {
+ ans = w;
}
- if is_pass {
- return word.clone();
+ }
+ ans
+ }
+}
+```
+
+#### JavaScript
+
+```js
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+var longestWord = function (words) {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
+
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+};
+
+class Trie {
+ constructor() {
+ this.children = Array(26).fill(null);
+ this.isEnd = false;
+ }
+
+ insert(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx];
}
- String::new()
+ node.isEnd = true;
+ }
+
+ search(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx].isEnd) {
+ return false;
+ }
+ node = node.children[idx];
+ }
+ return true;
}
}
```
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.cpp b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.cpp
index 49ea37bbdd0b2..8746bd16bc959 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.cpp
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.cpp
@@ -1,26 +1,47 @@
-class Solution {
+class Trie {
public:
- string longestWord(vector& words) {
- unordered_set s(words.begin(), words.end());
- int cnt = 0;
- string ans = "";
- for (auto w : s) {
- int n = w.size();
- if (check(w, s)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w < ans)
- ans = w;
+ Trie* children[26] = {nullptr};
+ bool isEnd = false;
+
+ void insert(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr) {
+ node->children[idx] = new Trie();
}
+ node = node->children[idx];
}
- return ans;
+ node->isEnd = true;
}
- bool check(string& word, unordered_set& s) {
- for (int i = 1, n = word.size(); i < n; ++i)
- if (!s.count(word.substr(0, i)))
+ bool search(const string& w) {
+ Trie* node = this;
+ for (char c : w) {
+ int idx = c - 'a';
+ if (node->children[idx] == nullptr || !node->children[idx]->isEnd) {
return false;
+ }
+ node = node->children[idx];
+ }
return true;
}
-};
\ No newline at end of file
+};
+
+class Solution {
+public:
+ string longestWord(vector& words) {
+ Trie trie;
+ for (const string& w : words) {
+ trie.insert(w);
+ }
+
+ string ans = "";
+ for (const string& w : words) {
+ if (trie.search(w) && (ans.length() < w.length() || (ans.length() == w.length() && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+};
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.go b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.go
index 3cca4beb6f63b..d6d857180e6fd 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.go
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.go
@@ -1,27 +1,43 @@
+type Trie struct {
+ children [26]*Trie
+ isEnd bool
+}
+
+func (t *Trie) insert(w string) {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil {
+ node.children[idx] = &Trie{}
+ }
+ node = node.children[idx]
+ }
+ node.isEnd = true
+}
+
+func (t *Trie) search(w string) bool {
+ node := t
+ for i := 0; i < len(w); i++ {
+ idx := w[i] - 'a'
+ if node.children[idx] == nil || !node.children[idx].isEnd {
+ return false
+ }
+ node = node.children[idx]
+ }
+ return true
+}
+
func longestWord(words []string) string {
- s := make(map[string]bool)
+ trie := &Trie{}
for _, w := range words {
- s[w] = true
+ trie.insert(w)
}
- cnt := 0
+
ans := ""
- check := func(word string) bool {
- for i, n := 1, len(word); i < n; i++ {
- if !s[word[:i]] {
- return false
- }
- }
- return true
- }
- for w, _ := range s {
- n := len(w)
- if check(w) {
- if cnt < n {
- cnt, ans = n, w
- } else if cnt == n && w < ans {
- ans = w
- }
+ for _, w := range words {
+ if trie.search(w) && (len(ans) < len(w) || (len(ans) == len(w) && w < ans)) {
+ ans = w
}
}
return ans
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.java b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.java
index 955f075a8dc2f..b0d44ba1e098a 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.java
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.java
@@ -1,30 +1,46 @@
-class Solution {
- private Set s;
+class Trie {
+ private Trie[] children = new Trie[26];
+ private boolean isEnd = false;
- public String longestWord(String[] words) {
- s = new HashSet<>(Arrays.asList(words));
- int cnt = 0;
- String ans = "";
- for (String w : s) {
- int n = w.length();
- if (check(w)) {
- if (cnt < n) {
- cnt = n;
- ans = w;
- } else if (cnt == n && w.compareTo(ans) < 0) {
- ans = w;
- }
+ public void insert(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null) {
+ node.children[idx] = new Trie();
}
+ node = node.children[idx];
}
- return ans;
+ node.isEnd = true;
}
- private boolean check(String word) {
- for (int i = 1, n = word.length(); i < n; ++i) {
- if (!s.contains(word.substring(0, i))) {
+ public boolean search(String w) {
+ Trie node = this;
+ for (char c : w.toCharArray()) {
+ int idx = c - 'a';
+ if (node.children[idx] == null || !node.children[idx].isEnd) {
return false;
}
+ node = node.children[idx];
}
return true;
}
-}
\ No newline at end of file
+}
+
+class Solution {
+ public String longestWord(String[] words) {
+ Trie trie = new Trie();
+ for (String w : words) {
+ trie.insert(w);
+ }
+ String ans = "";
+ for (String w : words) {
+ if (trie.search(w)
+ && (ans.length() < w.length()
+ || (ans.length() == w.length() && w.compareTo(ans) < 0))) {
+ ans = w;
+ }
+ }
+ return ans;
+ }
+}
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.js b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.js
new file mode 100644
index 0000000000000..8f54c997eb696
--- /dev/null
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.js
@@ -0,0 +1,49 @@
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+var longestWord = function (words) {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
+
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
+ }
+ }
+ return ans;
+};
+
+class Trie {
+ constructor() {
+ this.children = Array(26).fill(null);
+ this.isEnd = false;
+ }
+
+ insert(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx];
+ }
+ node.isEnd = true;
+ }
+
+ search(w) {
+ let node = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx].isEnd) {
+ return false;
+ }
+ node = node.children[idx];
+ }
+ return true;
+ }
+}
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.py b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.py
index bb9be70b2cfee..886a6430341b5 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.py
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.py
@@ -1,12 +1,38 @@
+class Trie:
+ def __init__(self):
+ self.children: List[Optional[Trie]] = [None] * 26
+ self.is_end = False
+
+ def insert(self, w: str):
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ node.children[idx] = Trie()
+ node = node.children[idx]
+ node.is_end = True
+
+ def search(self, w: str) -> bool:
+ node = self
+ for c in w:
+ idx = ord(c) - ord("a")
+ if node.children[idx] is None:
+ return False
+ node = node.children[idx]
+ if not node.is_end:
+ return False
+ return True
+
+
class Solution:
def longestWord(self, words: List[str]) -> str:
- cnt, ans = 0, ''
- s = set(words)
- for w in s:
- n = len(w)
- if all(w[:i] in s for i in range(1, n)):
- if cnt < n:
- cnt, ans = n, w
- elif cnt == n and w < ans:
- ans = w
+ trie = Trie()
+ for w in words:
+ trie.insert(w)
+ ans = ""
+ for w in words:
+ if trie.search(w) and (
+ len(ans) < len(w) or (len(ans) == len(w) and ans > w)
+ ):
+ ans = w
return ans
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.rs b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.rs
index fc3c4673b768f..24091db61cb1f 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.rs
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.rs
@@ -1,18 +1,54 @@
-impl Solution {
- pub fn longest_word(mut words: Vec) -> String {
- words.sort_unstable_by(|a, b| (b.len(), a).cmp(&(a.len(), b)));
- for word in words.iter() {
- let mut is_pass = true;
- for i in 1..=word.len() {
- if !words.contains(&word[..i].to_string()) {
- is_pass = false;
- break;
- }
+struct Trie {
+ children: [Option>; 26],
+ is_end: bool,
+}
+
+impl Trie {
+ fn new() -> Self {
+ Trie {
+ children: Default::default(),
+ is_end: false,
+ }
+ }
+
+ fn insert(&mut self, w: &str) {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() {
+ node.children[idx] = Some(Box::new(Trie::new()));
+ }
+ node = node.children[idx].as_mut().unwrap();
+ }
+ node.is_end = true;
+ }
+
+ fn search(&self, w: &str) -> bool {
+ let mut node = self;
+ for c in w.chars() {
+ let idx = (c as usize) - ('a' as usize);
+ if node.children[idx].is_none() || !node.children[idx].as_ref().unwrap().is_end {
+ return false;
}
- if is_pass {
- return word.clone();
+ node = node.children[idx].as_ref().unwrap();
+ }
+ true
+ }
+}
+
+impl Solution {
+ pub fn longest_word(words: Vec) -> String {
+ let mut trie = Trie::new();
+ for w in &words {
+ trie.insert(w);
+ }
+
+ let mut ans = String::new();
+ for w in words {
+ if trie.search(&w) && (ans.len() < w.len() || (ans.len() == w.len() && w < ans)) {
+ ans = w;
}
}
- String::new()
+ ans
}
}
diff --git a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.ts b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.ts
index 4c73b31ddc97d..6803cc5a46d21 100644
--- a/solution/0700-0799/0720.Longest Word in Dictionary/Solution.ts
+++ b/solution/0700-0799/0720.Longest Word in Dictionary/Solution.ts
@@ -1,23 +1,43 @@
-function longestWord(words: string[]): string {
- words.sort((a, b) => {
- const n = a.length;
- const m = b.length;
- if (n === m) {
- return a < b ? -1 : 1;
+class Trie {
+ children: (Trie | null)[] = new Array(26).fill(null);
+ isEnd: boolean = false;
+
+ insert(w: string): void {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null) {
+ node.children[idx] = new Trie();
+ }
+ node = node.children[idx]!;
}
- return m - n;
- });
- for (const word of words) {
- let isPass = true;
- for (let i = 1; i <= word.length; i++) {
- if (!words.includes(word.slice(0, i))) {
- isPass = false;
- break;
+ node.isEnd = true;
+ }
+
+ search(w: string): boolean {
+ let node: Trie = this;
+ for (let i = 0; i < w.length; i++) {
+ const idx: number = w.charCodeAt(i) - 'a'.charCodeAt(0);
+ if (node.children[idx] === null || !node.children[idx]!.isEnd) {
+ return false;
}
+ node = node.children[idx]!;
}
- if (isPass) {
- return word;
+ return true;
+ }
+}
+
+function longestWord(words: string[]): string {
+ const trie = new Trie();
+ for (const w of words) {
+ trie.insert(w);
+ }
+
+ let ans = '';
+ for (const w of words) {
+ if (trie.search(w) && (ans.length < w.length || (ans.length === w.length && w < ans))) {
+ ans = w;
}
}
- return '';
+ return ans;
}
diff --git a/solution/0700-0799/0722.Remove Comments/README.md b/solution/0700-0799/0722.Remove Comments/README.md
index 144b3f2264ef8..8ab1837937bdf 100644
--- a/solution/0700-0799/0722.Remove Comments/README.md
+++ b/solution/0700-0799/0722.Remove Comments/README.md
@@ -106,15 +106,15 @@ a = b + c;
### 方法一：分情况讨论
-我们用一个变量 $blockComment$ 来表示当前是否处于块注释中，初始时 $blockComment$ 为 `false`；用一个变量 $t$ 来存储当前行的有效字符。
+我们用一个变量 来表示当前是否处于块注释中，初始时 $\textit{blockComment}$ 为 `false`；用一个变量 $t$ 来存储当前行的有效字符。
接下来，遍历每一行，分情况讨论：
-如果当前处于块注释中，那么如果当前字符和下一个字符是 `'*/'`，说明块注释结束，我们将 $blockComment$ 置为 `false`，并且跳过这两个字符；否则，我们继续保持块注释状态，不做任何操作；
+如果当前处于块注释中，那么如果当前字符和下一个字符是 `'*/'`，说明块注释结束，我们将 $\textit{blockComment}$ 置为 `false`，并且跳过这两个字符；否则，我们继续保持块注释状态，不做任何操作；
-如果当前不处于块注释中，那么如果当前字符和下一个字符是 `'/*'`，说明块注释开始，我们将 $blockComment$ 置为 `true`，并且跳过这两个字符；如果当前字符和下一个字符是 `'//'`，那么说明行注释开始，我们直接退出当前行的遍历；否则，说明当前字符是有效字符，我们将其加入 $t$ 中；
+如果当前不处于块注释中，那么如果当前字符和下一个字符是 `'/*'`，说明块注释开始，我们将 $\textit{blockComment}$ 置为 `true`，并且跳过这两个字符；如果当前字符和下一个字符是 `'//'`，那么说明行注释开始，我们直接退出当前行的遍历；否则，说明当前字符是有效字符，我们将其加入 $t$ 中；
-遍历完当前行后，如果 $blockComment$ 为 `false`，并且 $t$ 不为空，说明当前行是有效行，我们将其加入答案数组中，并且清空 $t$。继续遍历下一行。
+遍历完当前行后，如果 $\textit{blockComment}$ 为 `false`，并且 $t$ 不为空，说明当前行是有效行，我们将其加入答案数组中，并且清空 $t$。继续遍历下一行。
时间复杂度 $O(L)$，空间复杂度 $O(L)$，其中 $L$ 是源代码的总长度。
diff --git a/solution/0700-0799/0722.Remove Comments/README_EN.md b/solution/0700-0799/0722.Remove Comments/README_EN.md
index 9d1a77e0b19a7..ee27b0a2e666c 100644
--- a/solution/0700-0799/0722.Remove Comments/README_EN.md
+++ b/solution/0700-0799/0722.Remove Comments/README_EN.md
@@ -102,7 +102,19 @@ a = b + c;
-### Solution 1
+### Solution 1: Case Analysis
+
+We use a variable $\textit{blockComment}$ to indicate whether we are currently in a block comment. Initially, $\textit{blockComment}$ is `false`. We use a variable $t$ to store the valid characters of the current line.
+
+Next, we traverse each line and discuss the following cases:
+
+If we are currently in a block comment, and the current character and the next character are `'*/'`, it means the block comment ends. We set $\textit{blockComment}$ to `false` and skip these two characters. Otherwise, we continue in the block comment state without doing anything.
+
+If we are not currently in a block comment, and the current character and the next character are `'/*'`, it means a block comment starts. We set $\textit{blockComment}$ to `true` and skip these two characters. If the current character and the next character are `'//'`, it means a line comment starts, and we exit the current line traversal. Otherwise, the current character is a valid character, and we add it to $t$.
+
+After traversing the current line, if $\textit{blockComment}$ is `false` and $t$ is not empty, it means the current line is valid. We add it to the answer array and clear $t$. Continue to traverse the next line.
+
+The time complexity is $O(L)$, and the space complexity is $O(L)$, where $L$ is the total length of the source code.
diff --git a/solution/0700-0799/0727.Minimum Window Subsequence/README.md b/solution/0700-0799/0727.Minimum Window Subsequence/README.md
index 3d34c288122be..f833e9bb1ec9d 100644
--- a/solution/0700-0799/0727.Minimum Window Subsequence/README.md
+++ b/solution/0700-0799/0727.Minimum Window Subsequence/README.md
@@ -60,7 +60,7 @@ s1 = "abcdebdde", s2 = "bde"
### 方法一：动态规划
-我们定义 $f[i][j]$ 表示字符串 $s1$ 的前 $i$ 个字符包含字符串 $s2$ 的前 $j$ 个字符时的最短子串的起始位置，如果不存在则为 $0$。
+我们定义 $f[i][j]$ 表示字符串 $\textit{s1}$ 的前 $i$ 个字符包含字符串 $\textit{s2}$ 的前 $j$ 个字符时的最短子串的起始位置，如果不存在则为 $0$。
我们可以得到状态转移方程：
@@ -72,9 +72,9 @@ f[i - 1][j], & s1[i-1] \ne s2[j-1]
\end{cases}
$$
-接下来我们只需要遍历 $s1$，如果 $f[i][n] \gt 0$，则更新最短子串的起始位置和长度。最后返回最短子串即可。
+接下来我们只需要遍历 $\textit{s1}$，如果 $f[i][n] \gt 0$，则更新最短子串的起始位置和长度。最后返回最短子串即可。
-时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为字符串 $s1$ 和 $s2$ 的长度。
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为字符串 $\textit{s1}$ 和 $\textit{s2}$ 的长度。
diff --git a/solution/0700-0799/0727.Minimum Window Subsequence/README_EN.md b/solution/0700-0799/0727.Minimum Window Subsequence/README_EN.md
index 844bccf6cddef..62a0a37bb8826 100644
--- a/solution/0700-0799/0727.Minimum Window Subsequence/README_EN.md
+++ b/solution/0700-0799/0727.Minimum Window Subsequence/README_EN.md
@@ -55,7 +55,23 @@ tags:
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i][j]$ to represent the starting position of the shortest substring of the first $i$ characters of string $\textit{s1}$ that contains the first $j$ characters of string $\textit{s2}$. If it does not exist, it is $0$.
+
+We can derive the state transition equation:
+
+$$
+f[i][j] = \begin{cases}
+i, & j = 1 \textit{ and } s1[i-1] = s2[j] \\
+f[i - 1][j - 1], & j > 1 \textit{ and } s1[i-1] = s2[j-1] \\
+f[i - 1][j], & s1[i-1] \ne s2[j-1]
+\end{cases}
+$$
+
+Next, we only need to traverse $\textit{s1}$. If $f[i][n] \gt 0$, update the starting position and length of the shortest substring. Finally, return the shortest substring.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the lengths of strings $\textit{s1}$ and $\textit{s2}$, respectively.
diff --git a/solution/0700-0799/0733.Flood Fill/README.md b/solution/0700-0799/0733.Flood Fill/README.md
index 9cbac1e653076..d7df13a582bc2 100644
--- a/solution/0700-0799/0733.Flood Fill/README.md
+++ b/solution/0700-0799/0733.Flood Fill/README.md
@@ -75,13 +75,11 @@ tags:
-### 方法一：Flood fill 算法
+### 方法一：DFS
-Flood fill 算法是从一个区域中提取若干个连通的点与其他相邻区域区分开（或分别染成不同颜色）的经典算法。因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。
+我们记初始像素的颜色为 $\textit{oc}$，如果 $\textit{oc}$ 不等于目标颜色 $\textit{color}$，我们就从 $(\textit{sr}, \textit{sc})$ 开始深度优先搜索，将所有符合条件的像素点的颜色都更改成目标颜色。
-最简单的实现方法是采用 DFS 的递归方法，也可以采用 BFS 的迭代来实现。
-
-时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为图像的行数和列数。
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为二维数组 $\textit{image}$ 的行数和列数。
@@ -92,22 +90,17 @@ class Solution:
def floodFill(
self, image: List[List[int]], sr: int, sc: int, color: int
) -> List[List[int]]:
- def dfs(i, j):
- if (
- not 0 <= i < m
- or not 0 <= j < n
- or image[i][j] != oc
- or image[i][j] == color
- ):
- return
+ def dfs(i: int, j: int):
image[i][j] = color
for a, b in pairwise(dirs):
- dfs(i + a, j + b)
+ x, y = i + a, j + b
+ if 0 <= x < len(image) and 0 <= y < len(image[0]) and image[x][y] == oc:
+ dfs(x, y)
- dirs = (-1, 0, 1, 0, -1)
- m, n = len(image), len(image[0])
oc = image[sr][sc]
- dfs(sr, sc)
+ if oc != color:
+ dirs = (-1, 0, 1, 0, -1)
+ dfs(sr, sc)
return image
```
@@ -115,27 +108,29 @@ class Solution:
```java
class Solution {
- private int[] dirs = {-1, 0, 1, 0, -1};
private int[][] image;
- private int nc;
private int oc;
+ private int color;
+ private final int[] dirs = {-1, 0, 1, 0, -1};
public int[][] floodFill(int[][] image, int sr, int sc, int color) {
- nc = color;
oc = image[sr][sc];
+ if (oc == color) {
+ return image;
+ }
this.image = image;
+ this.color = color;
dfs(sr, sc);
return image;
}
private void dfs(int i, int j) {
- if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != oc
- || image[i][j] == nc) {
- return;
- }
- image[i][j] = nc;
+ image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
}
}
@@ -149,14 +144,17 @@ public:
vector> floodFill(vector>& image, int sr, int sc, int color) {
int m = image.size(), n = image[0].size();
int oc = image[sr][sc];
- int dirs[5] = {-1, 0, 1, 0, -1};
- function dfs = [&](int i, int j) {
- if (i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color) {
- return;
- }
+ if (oc == color) {
+ return image;
+ }
+ const int dirs[5] = {-1, 0, 1, 0, -1};
+ auto dfs = [&](this auto&& dfs, int i, int j) -> void {
image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
};
dfs(sr, sc);
@@ -169,19 +167,25 @@ public:
```go
func floodFill(image [][]int, sr int, sc int, color int) [][]int {
- oc := image[sr][sc]
m, n := len(image), len(image[0])
+ oc := image[sr][sc]
+ if oc == color {
+ return image
+ }
+
dirs := []int{-1, 0, 1, 0, -1}
+
var dfs func(i, j int)
dfs = func(i, j int) {
- if i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color {
- return
- }
image[i][j] = color
for k := 0; k < 4; k++ {
- dfs(i+dirs[k], j+dirs[k+1])
+ x, y := i+dirs[k], j+dirs[k+1]
+ if x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc {
+ dfs(x, y)
+ }
}
}
+
dfs(sr, sc)
return image
}
@@ -190,27 +194,25 @@ func floodFill(image [][]int, sr int, sc int, color int) [][]int {
#### TypeScript
```ts
-function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
- const m = image.length;
- const n = image[0].length;
- const target = image[sr][sc];
- const dfs = (i: number, j: number) => {
- if (
- i < 0 ||
- i === m ||
- j < 0 ||
- j === n ||
- image[i][j] !== target ||
- image[i][j] === newColor
- ) {
- return;
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ const [m, n] = [image.length, image[0].length];
+ const oc = image[sr][sc];
+ if (oc === color) {
+ return image;
+ }
+
+ const dirs = [-1, 0, 1, 0, -1];
+
+ const dfs = (i: number, j: number): void => {
+ image[i][j] = color;
+ for (let k = 0; k < 4; k++) {
+ const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ dfs(x, y);
+ }
}
- image[i][j] = newColor;
- dfs(i + 1, j);
- dfs(i - 1, j);
- dfs(i, j + 1);
- dfs(i, j - 1);
};
+
dfs(sr, sc);
return image;
}
@@ -220,26 +222,42 @@ function floodFill(image: number[][], sr: number, sc: number, newColor: number):
```rust
impl Solution {
- fn dfs(image: &mut Vec>, sr: i32, sc: i32, new_color: i32, target: i32) {
- if sr < 0 || sr == (image.len() as i32) || sc < 0 || sc == (image[0].len() as i32) {
- return;
- }
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
let sr = sr as usize;
let sc = sc as usize;
- if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
- return;
+
+ let oc = image[sr][sc];
+ if oc == color {
+ return image;
}
- image[sr][sc] = new_color;
- let sr = sr as i32;
- let sc = sc as i32;
- Self::dfs(image, sr + 1, sc, new_color, target);
- Self::dfs(image, sr - 1, sc, new_color, target);
- Self::dfs(image, sr, sc + 1, new_color, target);
- Self::dfs(image, sr, sc - 1, new_color, target);
- }
- pub fn flood_fill(image: Vec>, sr: i32, sc: i32, new_color: i32) -> Vec> {
- let target = image[sr as usize][sc as usize];
- Self::dfs(&mut image, sr, sc, new_color, target);
+ let dirs = [-1, 0, 1, 0, -1];
+ fn dfs(
+ image: &mut Vec>,
+ i: usize,
+ j: usize,
+ oc: i32,
+ color: i32,
+ m: usize,
+ n: usize,
+ dirs: &[i32; 5],
+ ) {
+ image[i][j] = color;
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let x = x as usize;
+ let y = y as usize;
+ if image[x][y] == oc {
+ dfs(image, x, y, oc, color, m, n, dirs);
+ }
+ }
+ }
+ }
+
+ dfs(&mut image, sr, sc, oc, color, m, n, &dirs);
image
}
}
@@ -251,7 +269,13 @@ impl Solution {
-### 方法二
+### 方法二：BFS
+
+我们首先判断初始像素的颜色是否等于目标颜色，如果等于，直接返回原图像。否则，我们可以使用广度优先搜索的方法，从 $(\textit{sr}, \textit{sc})$ 开始，将所有符合条件的像素点的颜色都更改成目标颜色。
+
+具体地，我们定义一个队列 $\textit{q}$，将初始像素 $(\textit{sr}, \textit{sc})$ 加入队列。然后我们不断从队列中取出像素点 $(i, j)$，将其颜色更改成目标颜色，并将其上下左右四个方向上与初始像素的原始颜色相同的像素点加入队列。直到队列为空，我们就完成了图像的渲染。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为二维数组 $\textit{image}$ 的行数和列数。
@@ -363,6 +387,82 @@ func floodFill(image [][]int, sr int, sc int, color int) [][]int {
}
```
+#### TypeScript
+
+```ts
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ if (image[sr][sc] === color) {
+ return image;
+ }
+
+ const oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ const q: [number, number][] = [];
+ q.push([sr, sc]);
+
+ const dirs = [-1, 0, 1, 0, -1];
+ const [m, n] = [image.length, image[0].length];
+
+ while (q.length > 0) {
+ const [a, b] = q.shift()!;
+ for (let k = 0; k < 4; ++k) {
+ const x = a + dirs[k];
+ const y = b + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ q.push([x, y]);
+ image[x][y] = color;
+ }
+ }
+ }
+
+ return image;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::VecDeque;
+
+impl Solution {
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
+ let (sr, sc) = (sr as usize, sc as usize);
+
+ if image[sr][sc] == color {
+ return image;
+ }
+
+ let oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ let mut q = VecDeque::new();
+ q.push_back((sr, sc));
+
+ let dirs = [-1, 0, 1, 0, -1];
+
+ while let Some((i, j)) = q.pop_front() {
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let (x, y) = (x as usize, y as usize);
+ if image[x][y] == oc {
+ q.push_back((x, y));
+ image[x][y] = color;
+ }
+ }
+ }
+ }
+
+ image
+ }
+}
+```
+
diff --git a/solution/0700-0799/0733.Flood Fill/README_EN.md b/solution/0700-0799/0733.Flood Fill/README_EN.md
index 695663dd6381b..da347008f37fc 100644
--- a/solution/0700-0799/0733.Flood Fill/README_EN.md
+++ b/solution/0700-0799/0733.Flood Fill/README_EN.md
@@ -79,7 +79,11 @@ tags:
-### Solution 1
+### Solution 1: DFS
+
+We denote the initial pixel's color as $\textit{oc}$. If $\textit{oc}$ is not equal to the target color $\textit{color}$, we start a depth-first search from $(\textit{sr}, \textit{sc})$ to change the color of all eligible pixels to the target color.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the number of rows and columns of the 2D array $\textit{image}$, respectively.
@@ -90,22 +94,17 @@ class Solution:
def floodFill(
self, image: List[List[int]], sr: int, sc: int, color: int
) -> List[List[int]]:
- def dfs(i, j):
- if (
- not 0 <= i < m
- or not 0 <= j < n
- or image[i][j] != oc
- or image[i][j] == color
- ):
- return
+ def dfs(i: int, j: int):
image[i][j] = color
for a, b in pairwise(dirs):
- dfs(i + a, j + b)
+ x, y = i + a, j + b
+ if 0 <= x < len(image) and 0 <= y < len(image[0]) and image[x][y] == oc:
+ dfs(x, y)
- dirs = (-1, 0, 1, 0, -1)
- m, n = len(image), len(image[0])
oc = image[sr][sc]
- dfs(sr, sc)
+ if oc != color:
+ dirs = (-1, 0, 1, 0, -1)
+ dfs(sr, sc)
return image
```
@@ -113,27 +112,29 @@ class Solution:
```java
class Solution {
- private int[] dirs = {-1, 0, 1, 0, -1};
private int[][] image;
- private int nc;
private int oc;
+ private int color;
+ private final int[] dirs = {-1, 0, 1, 0, -1};
public int[][] floodFill(int[][] image, int sr, int sc, int color) {
- nc = color;
oc = image[sr][sc];
+ if (oc == color) {
+ return image;
+ }
this.image = image;
+ this.color = color;
dfs(sr, sc);
return image;
}
private void dfs(int i, int j) {
- if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != oc
- || image[i][j] == nc) {
- return;
- }
- image[i][j] = nc;
+ image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
}
}
@@ -147,14 +148,17 @@ public:
vector> floodFill(vector>& image, int sr, int sc, int color) {
int m = image.size(), n = image[0].size();
int oc = image[sr][sc];
- int dirs[5] = {-1, 0, 1, 0, -1};
- function dfs = [&](int i, int j) {
- if (i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color) {
- return;
- }
+ if (oc == color) {
+ return image;
+ }
+ const int dirs[5] = {-1, 0, 1, 0, -1};
+ auto dfs = [&](this auto&& dfs, int i, int j) -> void {
image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
};
dfs(sr, sc);
@@ -167,19 +171,25 @@ public:
```go
func floodFill(image [][]int, sr int, sc int, color int) [][]int {
- oc := image[sr][sc]
m, n := len(image), len(image[0])
+ oc := image[sr][sc]
+ if oc == color {
+ return image
+ }
+
dirs := []int{-1, 0, 1, 0, -1}
+
var dfs func(i, j int)
dfs = func(i, j int) {
- if i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color {
- return
- }
image[i][j] = color
for k := 0; k < 4; k++ {
- dfs(i+dirs[k], j+dirs[k+1])
+ x, y := i+dirs[k], j+dirs[k+1]
+ if x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc {
+ dfs(x, y)
+ }
}
}
+
dfs(sr, sc)
return image
}
@@ -188,27 +198,25 @@ func floodFill(image [][]int, sr int, sc int, color int) [][]int {
#### TypeScript
```ts
-function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
- const m = image.length;
- const n = image[0].length;
- const target = image[sr][sc];
- const dfs = (i: number, j: number) => {
- if (
- i < 0 ||
- i === m ||
- j < 0 ||
- j === n ||
- image[i][j] !== target ||
- image[i][j] === newColor
- ) {
- return;
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ const [m, n] = [image.length, image[0].length];
+ const oc = image[sr][sc];
+ if (oc === color) {
+ return image;
+ }
+
+ const dirs = [-1, 0, 1, 0, -1];
+
+ const dfs = (i: number, j: number): void => {
+ image[i][j] = color;
+ for (let k = 0; k < 4; k++) {
+ const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ dfs(x, y);
+ }
}
- image[i][j] = newColor;
- dfs(i + 1, j);
- dfs(i - 1, j);
- dfs(i, j + 1);
- dfs(i, j - 1);
};
+
dfs(sr, sc);
return image;
}
@@ -218,26 +226,42 @@ function floodFill(image: number[][], sr: number, sc: number, newColor: number):
```rust
impl Solution {
- fn dfs(image: &mut Vec>, sr: i32, sc: i32, new_color: i32, target: i32) {
- if sr < 0 || sr == (image.len() as i32) || sc < 0 || sc == (image[0].len() as i32) {
- return;
- }
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
let sr = sr as usize;
let sc = sc as usize;
- if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
- return;
+
+ let oc = image[sr][sc];
+ if oc == color {
+ return image;
}
- image[sr][sc] = new_color;
- let sr = sr as i32;
- let sc = sc as i32;
- Self::dfs(image, sr + 1, sc, new_color, target);
- Self::dfs(image, sr - 1, sc, new_color, target);
- Self::dfs(image, sr, sc + 1, new_color, target);
- Self::dfs(image, sr, sc - 1, new_color, target);
- }
- pub fn flood_fill(image: Vec>, sr: i32, sc: i32, new_color: i32) -> Vec> {
- let target = image[sr as usize][sc as usize];
- Self::dfs(&mut image, sr, sc, new_color, target);
+ let dirs = [-1, 0, 1, 0, -1];
+ fn dfs(
+ image: &mut Vec>,
+ i: usize,
+ j: usize,
+ oc: i32,
+ color: i32,
+ m: usize,
+ n: usize,
+ dirs: &[i32; 5],
+ ) {
+ image[i][j] = color;
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let x = x as usize;
+ let y = y as usize;
+ if image[x][y] == oc {
+ dfs(image, x, y, oc, color, m, n, dirs);
+ }
+ }
+ }
+ }
+
+ dfs(&mut image, sr, sc, oc, color, m, n, &dirs);
image
}
}
@@ -249,7 +273,13 @@ impl Solution {
-### Solution 2
+### Solution 2: BFS
+
+We first check if the initial pixel's color is equal to the target color. If it is, we return the original image directly. Otherwise, we can use the breadth-first search method, starting from $(\textit{sr}, \textit{sc})$, to change the color of all eligible pixels to the target color.
+
+Specifically, we define a queue $\textit{q}$ and add the initial pixel $(\textit{sr}, \textit{sc})$ to the queue. Then, we continuously take pixels $(i, j)$ from the queue, change their color to the target color, and add the pixels in the four directions (up, down, left, right) that have the same original color as the initial pixel to the queue. When the queue is empty, we have completed the flood fill.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the number of rows and columns of the 2D array $\textit{image}$, respectively.
@@ -361,6 +391,82 @@ func floodFill(image [][]int, sr int, sc int, color int) [][]int {
}
```
+#### TypeScript
+
+```ts
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ if (image[sr][sc] === color) {
+ return image;
+ }
+
+ const oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ const q: [number, number][] = [];
+ q.push([sr, sc]);
+
+ const dirs = [-1, 0, 1, 0, -1];
+ const [m, n] = [image.length, image[0].length];
+
+ while (q.length > 0) {
+ const [a, b] = q.shift()!;
+ for (let k = 0; k < 4; ++k) {
+ const x = a + dirs[k];
+ const y = b + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ q.push([x, y]);
+ image[x][y] = color;
+ }
+ }
+ }
+
+ return image;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::VecDeque;
+
+impl Solution {
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
+ let (sr, sc) = (sr as usize, sc as usize);
+
+ if image[sr][sc] == color {
+ return image;
+ }
+
+ let oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ let mut q = VecDeque::new();
+ q.push_back((sr, sc));
+
+ let dirs = [-1, 0, 1, 0, -1];
+
+ while let Some((i, j)) = q.pop_front() {
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let (x, y) = (x as usize, y as usize);
+ if image[x][y] == oc {
+ q.push_back((x, y));
+ image[x][y] = color;
+ }
+ }
+ }
+ }
+
+ image
+ }
+}
+```
+
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.cpp b/solution/0700-0799/0733.Flood Fill/Solution.cpp
index 159a549768809..d56f7b5fa156b 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.cpp
+++ b/solution/0700-0799/0733.Flood Fill/Solution.cpp
@@ -3,17 +3,20 @@ class Solution {
vector> floodFill(vector>& image, int sr, int sc, int color) {
int m = image.size(), n = image[0].size();
int oc = image[sr][sc];
- int dirs[5] = {-1, 0, 1, 0, -1};
- function dfs = [&](int i, int j) {
- if (i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color) {
- return;
- }
+ if (oc == color) {
+ return image;
+ }
+ const int dirs[5] = {-1, 0, 1, 0, -1};
+ auto dfs = [&](this auto&& dfs, int i, int j) -> void {
image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
};
dfs(sr, sc);
return image;
}
-};
\ No newline at end of file
+};
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.go b/solution/0700-0799/0733.Flood Fill/Solution.go
index 745e95d8ed566..e984a6a7c7bb6 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.go
+++ b/solution/0700-0799/0733.Flood Fill/Solution.go
@@ -1,17 +1,23 @@
func floodFill(image [][]int, sr int, sc int, color int) [][]int {
- oc := image[sr][sc]
m, n := len(image), len(image[0])
+ oc := image[sr][sc]
+ if oc == color {
+ return image
+ }
+
dirs := []int{-1, 0, 1, 0, -1}
+
var dfs func(i, j int)
dfs = func(i, j int) {
- if i < 0 || i >= m || j < 0 || j >= n || image[i][j] != oc || image[i][j] == color {
- return
- }
image[i][j] = color
for k := 0; k < 4; k++ {
- dfs(i+dirs[k], j+dirs[k+1])
+ x, y := i+dirs[k], j+dirs[k+1]
+ if x >= 0 && x < m && y >= 0 && y < n && image[x][y] == oc {
+ dfs(x, y)
+ }
}
}
+
dfs(sr, sc)
return image
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.java b/solution/0700-0799/0733.Flood Fill/Solution.java
index a8584e35c9e40..a932aa6f77a8e 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.java
+++ b/solution/0700-0799/0733.Flood Fill/Solution.java
@@ -1,25 +1,27 @@
class Solution {
- private int[] dirs = {-1, 0, 1, 0, -1};
private int[][] image;
- private int nc;
private int oc;
+ private int color;
+ private final int[] dirs = {-1, 0, 1, 0, -1};
public int[][] floodFill(int[][] image, int sr, int sc, int color) {
- nc = color;
oc = image[sr][sc];
+ if (oc == color) {
+ return image;
+ }
this.image = image;
+ this.color = color;
dfs(sr, sc);
return image;
}
private void dfs(int i, int j) {
- if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != oc
- || image[i][j] == nc) {
- return;
- }
- image[i][j] = nc;
+ image[i][j] = color;
for (int k = 0; k < 4; ++k) {
- dfs(i + dirs[k], j + dirs[k + 1]);
+ int x = i + dirs[k], y = j + dirs[k + 1];
+ if (x >= 0 && x < image.length && y >= 0 && y < image[0].length && image[x][y] == oc) {
+ dfs(x, y);
+ }
}
}
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.py b/solution/0700-0799/0733.Flood Fill/Solution.py
index 0c1e525a64c58..59f0414d33a6f 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.py
+++ b/solution/0700-0799/0733.Flood Fill/Solution.py
@@ -2,20 +2,15 @@ class Solution:
def floodFill(
self, image: List[List[int]], sr: int, sc: int, color: int
) -> List[List[int]]:
- def dfs(i, j):
- if (
- not 0 <= i < m
- or not 0 <= j < n
- or image[i][j] != oc
- or image[i][j] == color
- ):
- return
+ def dfs(i: int, j: int):
image[i][j] = color
for a, b in pairwise(dirs):
- dfs(i + a, j + b)
+ x, y = i + a, j + b
+ if 0 <= x < len(image) and 0 <= y < len(image[0]) and image[x][y] == oc:
+ dfs(x, y)
- dirs = (-1, 0, 1, 0, -1)
- m, n = len(image), len(image[0])
oc = image[sr][sc]
- dfs(sr, sc)
+ if oc != color:
+ dirs = (-1, 0, 1, 0, -1)
+ dfs(sr, sc)
return image
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.rs b/solution/0700-0799/0733.Flood Fill/Solution.rs
index 81a4f802a623f..646e7bf4f3e76 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.rs
+++ b/solution/0700-0799/0733.Flood Fill/Solution.rs
@@ -1,24 +1,40 @@
impl Solution {
- fn dfs(image: &mut Vec>, sr: i32, sc: i32, new_color: i32, target: i32) {
- if sr < 0 || sr == (image.len() as i32) || sc < 0 || sc == (image[0].len() as i32) {
- return;
- }
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
let sr = sr as usize;
let sc = sc as usize;
- if sr < 0 || image[sr][sc] == new_color || image[sr][sc] != target {
- return;
+
+ let oc = image[sr][sc];
+ if oc == color {
+ return image;
}
- image[sr][sc] = new_color;
- let sr = sr as i32;
- let sc = sc as i32;
- Self::dfs(image, sr + 1, sc, new_color, target);
- Self::dfs(image, sr - 1, sc, new_color, target);
- Self::dfs(image, sr, sc + 1, new_color, target);
- Self::dfs(image, sr, sc - 1, new_color, target);
- }
- pub fn flood_fill(image: Vec>, sr: i32, sc: i32, new_color: i32) -> Vec> {
- let target = image[sr as usize][sc as usize];
- Self::dfs(&mut image, sr, sc, new_color, target);
+ let dirs = [-1, 0, 1, 0, -1];
+ fn dfs(
+ image: &mut Vec>,
+ i: usize,
+ j: usize,
+ oc: i32,
+ color: i32,
+ m: usize,
+ n: usize,
+ dirs: &[i32; 5],
+ ) {
+ image[i][j] = color;
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let x = x as usize;
+ let y = y as usize;
+ if image[x][y] == oc {
+ dfs(image, x, y, oc, color, m, n, dirs);
+ }
+ }
+ }
+ }
+
+ dfs(&mut image, sr, sc, oc, color, m, n, &dirs);
image
}
}
diff --git a/solution/0700-0799/0733.Flood Fill/Solution.ts b/solution/0700-0799/0733.Flood Fill/Solution.ts
index cff3110f7ba91..01e6b5771a132 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution.ts
+++ b/solution/0700-0799/0733.Flood Fill/Solution.ts
@@ -1,24 +1,22 @@
-function floodFill(image: number[][], sr: number, sc: number, newColor: number): number[][] {
- const m = image.length;
- const n = image[0].length;
- const target = image[sr][sc];
- const dfs = (i: number, j: number) => {
- if (
- i < 0 ||
- i === m ||
- j < 0 ||
- j === n ||
- image[i][j] !== target ||
- image[i][j] === newColor
- ) {
- return;
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ const [m, n] = [image.length, image[0].length];
+ const oc = image[sr][sc];
+ if (oc === color) {
+ return image;
+ }
+
+ const dirs = [-1, 0, 1, 0, -1];
+
+ const dfs = (i: number, j: number): void => {
+ image[i][j] = color;
+ for (let k = 0; k < 4; k++) {
+ const [x, y] = [i + dirs[k], j + dirs[k + 1]];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ dfs(x, y);
+ }
}
- image[i][j] = newColor;
- dfs(i + 1, j);
- dfs(i - 1, j);
- dfs(i, j + 1);
- dfs(i, j - 1);
};
+
dfs(sr, sc);
return image;
}
diff --git a/solution/0700-0799/0733.Flood Fill/Solution2.cpp b/solution/0700-0799/0733.Flood Fill/Solution2.cpp
index 2425f5a5e6722..3767abe005cd0 100644
--- a/solution/0700-0799/0733.Flood Fill/Solution2.cpp
+++ b/solution/0700-0799/0733.Flood Fill/Solution2.cpp
@@ -1,7 +1,9 @@
class Solution {
public:
vector> floodFill(vector>& image, int sr, int sc, int color) {
- if (image[sr][sc] == color) return image;
+ if (image[sr][sc] == color) {
+ return image;
+ }
int oc = image[sr][sc];
image[sr][sc] = color;
queue> q;
@@ -21,4 +23,4 @@ class Solution {
}
return image;
}
-};
\ No newline at end of file
+};
diff --git a/solution/0700-0799/0733.Flood Fill/Solution2.rs b/solution/0700-0799/0733.Flood Fill/Solution2.rs
new file mode 100644
index 0000000000000..0b86fe472095d
--- /dev/null
+++ b/solution/0700-0799/0733.Flood Fill/Solution2.rs
@@ -0,0 +1,38 @@
+use std::collections::VecDeque;
+
+impl Solution {
+ pub fn flood_fill(mut image: Vec>, sr: i32, sc: i32, color: i32) -> Vec> {
+ let m = image.len();
+ let n = image[0].len();
+ let (sr, sc) = (sr as usize, sc as usize);
+
+ if image[sr][sc] == color {
+ return image;
+ }
+
+ let oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ let mut q = VecDeque::new();
+ q.push_back((sr, sc));
+
+ let dirs = [-1, 0, 1, 0, -1];
+
+ while let Some((i, j)) = q.pop_front() {
+ for k in 0..4 {
+ let x = i as isize + dirs[k] as isize;
+ let y = j as isize + dirs[k + 1] as isize;
+
+ if x >= 0 && x < m as isize && y >= 0 && y < n as isize {
+ let (x, y) = (x as usize, y as usize);
+ if image[x][y] == oc {
+ q.push_back((x, y));
+ image[x][y] = color;
+ }
+ }
+ }
+ }
+
+ image
+ }
+}
diff --git a/solution/0700-0799/0733.Flood Fill/Solution2.ts b/solution/0700-0799/0733.Flood Fill/Solution2.ts
new file mode 100644
index 0000000000000..344482e32d3cd
--- /dev/null
+++ b/solution/0700-0799/0733.Flood Fill/Solution2.ts
@@ -0,0 +1,28 @@
+function floodFill(image: number[][], sr: number, sc: number, color: number): number[][] {
+ if (image[sr][sc] === color) {
+ return image;
+ }
+
+ const oc = image[sr][sc];
+ image[sr][sc] = color;
+
+ const q: [number, number][] = [];
+ q.push([sr, sc]);
+
+ const dirs = [-1, 0, 1, 0, -1];
+ const [m, n] = [image.length, image[0].length];
+
+ while (q.length > 0) {
+ const [a, b] = q.shift()!;
+ for (let k = 0; k < 4; ++k) {
+ const x = a + dirs[k];
+ const y = b + dirs[k + 1];
+ if (x >= 0 && x < m && y >= 0 && y < n && image[x][y] === oc) {
+ q.push([x, y]);
+ image[x][y] = color;
+ }
+ }
+ }
+
+ return image;
+}
diff --git a/solution/0700-0799/0763.Partition Labels/README.md b/solution/0700-0799/0763.Partition Labels/README.md
index 2d5e408dd4339..705d41800366f 100644
--- a/solution/0700-0799/0763.Partition Labels/README.md
+++ b/solution/0700-0799/0763.Partition Labels/README.md
@@ -19,7 +19,7 @@ tags:
-
-