Merge branch 'doocs:main' into main

Author: Nothing-avil

solution/0600-0699/0633.Sum of Square Numbers/README.md

@@ -37,7 +37,11 @@
 
 ## 解法
 
-### 方法一
+### 方法一：数学 + 双指针
+
+我们可以使用双指针的方法来解决这个问题，定义两个指针 $a$ 和 $b$，分别指向 $0$ 和 $\sqrt{c}$。在每一步中，我们会计算 $s = a^2 + b^2$ 的值，然后比较 $s$ 与 $c$ 的大小。如果 $s = c$，我们就找到了两个整数 $a$ 和 $b$，使得 $a^2 + b^2 = c$。如果 $s < c$，我们将 $a$ 的值增加 $1$，如果 $s > c$，我们将 $b$ 的值减小 $1$。我们不断进行这个过程直到找到答案，或者 $a$ 的值大于 $b$ 的值，返回 `false`。
+
+时间复杂度 $O(\sqrt{c})$，其中 $c$ 是给定的非负整数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -80,14 +84,17 @@ class Solution {
 class Solution {
 public:
     bool judgeSquareSum(int c) {
-        long a = 0, b = (long) sqrt(c);
+        long long a = 0, b = sqrt(c);
         while (a <= b) {
-            long s = a * a + b * b;
-            if (s == c) return true;
-            if (s < c)
+            long long s = a * a + b * b;
+            if (s == c) {
+                return true;
+            }
+            if (s < c) {
                 ++a;
-            else
+            } else {
                 --b;
+            }
         }
         return false;
     }
@@ -114,12 +121,13 @@ func judgeSquareSum(c int) bool {
 
 ```ts
 function judgeSquareSum(c: number): boolean {
-    let a = 0,
-        b = Math.floor(Math.sqrt(c));
+    let [a, b] = [0, Math.floor(Math.sqrt(c))];
     while (a <= b) {
-        let sum = a ** 2 + b ** 2;
-        if (sum == c) return true;
-        if (sum < c) {
+        const s = a * a + b * b;
+        if (s === c) {
+            return true;
+        }
+        if (s < c) {
             ++a;
         } else {
             --b;
@@ -131,22 +139,22 @@ function judgeSquareSum(c: number): boolean {
 
 ```rust
 use std::cmp::Ordering;
+
 impl Solution {
     pub fn judge_square_sum(c: i32) -> bool {
-        let c = c as i64;
-        let mut left = 0;
-        let mut right = (c as f64).sqrt() as i64;
-        while left <= right {
-            let num = left * left + right * right;
-            match num.cmp(&c) {
+        let mut a: i64 = 0;
+        let mut b: i64 = (c as f64).sqrt() as i64;
+        while a <= b {
+            let s = a * a + b * b;
+            match s.cmp(&(c as i64)) {
+                Ordering::Equal => {
+                    return true;
+                }
                 Ordering::Less => {
-                    left += 1;
+                    a += 1;
                 }
                 Ordering::Greater => {
-                    right -= 1;
-                }
-                Ordering::Equal => {
-                    return true;
+                    b -= 1;
                 }
             }
         }

solution/0600-0699/0633.Sum of Square Numbers/README_EN.md

@@ -33,7 +33,11 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Mathematics + Two Pointers
+
+We can use the two-pointer method to solve this problem. Define two pointers $a$ and $b$, pointing to $0$ and $\sqrt{c}$ respectively. In each step, we calculate the value of $s = a^2 + b^2$, and then compare the size of $s$ and $c$. If $s = c$, we have found two integers $a$ and $b$ such that $a^2 + b^2 = c$. If $s < c$, we increase the value of $a$ by $1$. If $s > c$, we decrease the value of $b$ by $1$. We continue this process until we find the answer, or the value of $a$ is greater than the value of $b$, and return `false`.
+
+The time complexity is $O(\sqrt{c})$, where $c$ is the given non-negative integer. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -76,14 +80,17 @@ class Solution {
 class Solution {
 public:
     bool judgeSquareSum(int c) {
-        long a = 0, b = (long) sqrt(c);
+        long long a = 0, b = sqrt(c);
         while (a <= b) {
-            long s = a * a + b * b;
-            if (s == c) return true;
-            if (s < c)
+            long long s = a * a + b * b;
+            if (s == c) {
+                return true;
+            }
+            if (s < c) {
                 ++a;
-            else
+            } else {
                 --b;
+            }
         }
         return false;
     }
@@ -110,12 +117,13 @@ func judgeSquareSum(c int) bool {
 
 ```ts
 function judgeSquareSum(c: number): boolean {
-    let a = 0,
-        b = Math.floor(Math.sqrt(c));
+    let [a, b] = [0, Math.floor(Math.sqrt(c))];
     while (a <= b) {
-        let sum = a ** 2 + b ** 2;
-        if (sum == c) return true;
-        if (sum < c) {
+        const s = a * a + b * b;
+        if (s === c) {
+            return true;
+        }
+        if (s < c) {
             ++a;
         } else {
             --b;
@@ -127,22 +135,22 @@ function judgeSquareSum(c: number): boolean {
 
 ```rust
 use std::cmp::Ordering;
+
 impl Solution {
     pub fn judge_square_sum(c: i32) -> bool {
-        let c = c as i64;
-        let mut left = 0;
-        let mut right = (c as f64).sqrt() as i64;
-        while left <= right {
-            let num = left * left + right * right;
-            match num.cmp(&c) {
+        let mut a: i64 = 0;
+        let mut b: i64 = (c as f64).sqrt() as i64;
+        while a <= b {
+            let s = a * a + b * b;
+            match s.cmp(&(c as i64)) {
+                Ordering::Equal => {
+                    return true;
+                }
                 Ordering::Less => {
-                    left += 1;
+                    a += 1;
                 }
                 Ordering::Greater => {
-                    right -= 1;
-                }
-                Ordering::Equal => {
-                    return true;
+                    b -= 1;
                 }
             }
         }

solution/0600-0699/0633.Sum of Square Numbers/Solution.cpp

@@ -1,14 +1,17 @@
 class Solution {
 public:
     bool judgeSquareSum(int c) {
-        long a = 0, b = (long) sqrt(c);
+        long long a = 0, b = sqrt(c);
         while (a <= b) {
-            long s = a * a + b * b;
-            if (s == c) return true;
-            if (s < c)
+            long long s = a * a + b * b;
+            if (s == c) {
+                return true;
+            }
+            if (s < c) {
                 ++a;
-            else
+            } else {
                 --b;
+            }
         }
         return false;
     }

solution/0600-0699/0633.Sum of Square Numbers/Solution.rs

@@ -1,20 +1,20 @@
 use std::cmp::Ordering;
+
 impl Solution {
     pub fn judge_square_sum(c: i32) -> bool {
-        let c = c as i64;
-        let mut left = 0;
-        let mut right = (c as f64).sqrt() as i64;
-        while left <= right {
-            let num = left * left + right * right;
-            match num.cmp(&c) {
+        let mut a: i64 = 0;
+        let mut b: i64 = (c as f64).sqrt() as i64;
+        while a <= b {
+            let s = a * a + b * b;
+            match s.cmp(&(c as i64)) {
+                Ordering::Equal => {
+                    return true;
+                }
                 Ordering::Less => {
-                    left += 1;
+                    a += 1;
                 }
                 Ordering::Greater => {
-                    right -= 1;
-                }
-                Ordering::Equal => {
-                    return true;
+                    b -= 1;
                 }
             }
         }

solution/0600-0699/0633.Sum of Square Numbers/Solution.ts

@@ -1,10 +1,11 @@
 function judgeSquareSum(c: number): boolean {
-    let a = 0,
-        b = Math.floor(Math.sqrt(c));
+    let [a, b] = [0, Math.floor(Math.sqrt(c))];
     while (a <= b) {
-        let sum = a ** 2 + b ** 2;
-        if (sum == c) return true;
-        if (sum < c) {
+        const s = a * a + b * b;
+        if (s === c) {
+            return true;
+        }
+        if (s < c) {
             ++a;
         } else {
             --b;

solution/0600-0699/0634.Find the Derangement of An Array/README.md

@@ -56,9 +56,7 @@ $$
 
 最终答案即为 $f[n]$。注意答案的取模操作。
 
-我们发现，状态转移方程中只与 $f[i - 1]$ 和 $f[i - 2]$ 有关，因此我们可以使用两个变量 $a$ 和 $b$ 来分别表示 $f[i - 1]$ 和 $f[i - 2]$，从而将空间复杂度降低到 $O(1)$。
-
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -116,7 +114,9 @@ func findDerangement(n int) int {
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：动态规划（空间优化）
+
+我们发现，状态转移方程中只与 $f[i - 1]$ 和 $f[i - 2]$ 有关，因此我们可以使用两个变量 $a$ 和 $b$ 来分别表示 $f[i - 1]$ 和 $f[i - 2]$，从而将空间复杂度降低到 $O(1)$。
 
 <!-- tabs:start -->
 

solution/0600-0699/0634.Find the Derangement of An Array/README_EN.md

@@ -35,7 +35,24 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i]$ as the number of derangement of an array of length $i$. Initially, $f[0] = 1$, $f[1] = 0$. The answer is $f[n]$.
+
+For an array of length $i$, we consider where to place the number $1$. Suppose it is placed in the $j$-th position, where there are $i-1$ choices. Then, the number $j$ has two choices:
+
+-   Placed in the first position, then the remaining $i - 2$ positions have $f[i - 2]$ derangements, so there are a total of $(i - 1) \times f[i - 2]$ derangements;
+-   Not placed in the first position, which is equivalent to the derangement of an array of length $i - 1$, so there are a total of $(i - 1) \times f[i - 1]$ derangements.
+
+In summary, we have the following state transition equation:
+
+$$
+f[i] = (i - 1) \times (f[i - 1] + f[i - 2])
+$$
+
+The final answer is $f[n]$. Note the modulo operation in the answer.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -93,7 +110,9 @@ func findDerangement(n int) int {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Dynamic Programming (Space Optimization)
+
+We notice that the state transition equation only relates to $f[i - 1]$ and $f[i - 2]$. Therefore, we can use two variables $a$ and $b$ to represent $f[i - 1]$ and $f[i - 2]$ respectively, thereby reducing the space complexity to $O(1)$.
 
 <!-- tabs:start -->
 

solution/0600-0699/0635.Design Log Storage System/README_EN.md

@@ -56,7 +56,11 @@ logSystem.retrieve("2016:01:01:01:01:01", "2017:01:01:23:00:00&qu
 
 ## Solutions
 
-### Solution 1
+### Solution 1: String Comparison
+
+Store the `id` and `timestamp` of the logs as tuples in an array. Then in the `retrieve()` method, truncate the corresponding parts of `start` and `end` based on `granularity`, and traverse the array, adding the `id` that meets the conditions to the result array.
+
+In terms of time complexity, the time complexity of the `put()` method is $O(1)$, and the time complexity of the `retrieve()` method is $O(n)$, where $n$ is the length of the array.
 
 <!-- tabs:start -->
 

solution/2200-2299/2208.Minimum Operations to Halve Array Sum/README_EN.md

@@ -53,7 +53,13 @@ It can be shown that we cannot reduce the sum by at least half in less than 3 op
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Greedy + Priority Queue (Max Heap)
+
+According to the problem description, each operation will halve a number in the array. To minimize the number of operations that reduce the array sum by at least half, each operation should halve the current maximum value in the array.
+
+Therefore, we first calculate the total sum $s$ that the array needs to reduce, and then use a priority queue (max heap) to maintain all the numbers in the array. Each time we take the maximum value $t$ from the priority queue, halve it, and then put the halved number back into the priority queue, while updating $s$, until $s \le 0$. The number of operations at this time is the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array.
 
 <!-- tabs:start -->
 

solution/2200-2299/2209.Minimum White Tiles After Covering With Carpets/README_EN.md

@@ -49,7 +49,20 @@ Note that the carpets are able to overlap one another.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Memoization Search
+
+Design a function $dfs(i, j)$ to represent the minimum number of white bricks that are not covered starting from index $i$ using $j$ carpets. The answer is $dfs(0, numCarpets)$.
+
+For index $i$, we discuss different cases:
+
+-   If $i \ge n$, it means that all bricks have been covered, return $0$;
+-   If $floor[i] = 0$, there is no need to use a carpet, just skip it, that is, $dfs(i, j) = dfs(i + 1, j)$;
+-   If $j = 0$, we can directly calculate the number of remaining white bricks that have not been covered using the prefix sum array $s$, that is, $dfs(i, j) = s[n] - s[i]$;
+-   If $floor[i] = 1$, we can choose to use a carpet to cover it, or choose not to use a carpet to cover it, and take the minimum of the two, that is, $dfs(i, j) = min(dfs(i + 1, j), dfs(i + carpetLen, j - 1))$.
+
+Use memoization search.
+
+The time complexity is $O(n\times m)$, and the space complexity is $O(n\times m)$. Where $n$ and $m$ are the lengths of the string $floor$ and the value of $numCarpets$ respectively.
 
 <!-- tabs:start -->