feat: update solutions to lcci problems (doocs#2088)

Author: yanglbme

lcci/04.12.Paths with Sum/README_EN.md

@@ -44,6 +44,24 @@ Given the following tree and &nbsp;<code>sum = 22,</code></p>
 
 ## Solutions
 
+**Solution 1: Hash Table + Prefix Sum + Recursion**
+
+We can use the idea of prefix sum to recursively traverse the binary tree, and use a hash table $cnt$ to count the occurrence of each prefix sum on the path from the root node to the current node.
+
+We design a recursive function $dfs(node, s)$, where the current node being traversed is $node$, and the prefix sum on the path from the root node to the current node is $s$. The return value of the function is the number of paths with the path sum equal to $sum$ and the path ends at the $node$ node or its subtree nodes. Therefore, the answer is $dfs(root, 0)$.
+
+The recursive process of the function $dfs(node, s)$ is as follows:
+
+-   If the current node $node$ is null, return $0$.
+-   Calculate the prefix sum $s$ on the path from the root node to the current node.
+-   Use $cnt[s - sum]$ to represent the number of paths with the path sum equal to $sum$ and the path ends at the current node, where $cnt[s - sum]$ is the count of the prefix sum equal to $s - sum$ in $cnt$.
+-   Add the count of the prefix sum $s$ by $1$, i.e., $cnt[s] = cnt[s] + 1$.
+-   Recursively traverse the left and right child nodes of the current node, i.e., call the functions $dfs(node.left, s)$ and $dfs(node.right, s)$, and add their return values.
+-   After the return value is calculated, subtract the count of the prefix sum $s$ of the current node by $1$, i.e., execute $cnt[s] = cnt[s] - 1$.
+-   Finally, return the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes in the binary tree.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/05.01.Insert Into Bits/README_EN.md

@@ -24,6 +24,12 @@
 
 ## Solutions
 
+**Solution 1: Bit Manipulation**
+
+First, we clear the bits from the $i$-th to the $j$-th in $N$, then we left shift $M$ by $i$ bits, and finally perform a bitwise OR operation on $M$ and $N$.
+
+The time complexity is $O(\log n)$, where $n$ is the size of $N$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/05.02.Binary Number to String/README_EN.md

@@ -1,4 +1,4 @@
-# [05.02. Binary Number to String](https://leetcode.cn/problems/bianry-number-to-string-lcci)
+# [05.02. Binary Number to String](https://leetcode.cn/problems/binary-number-to-string-lcci)
 
 [中文文档](/lcci/05.02.Binary%20Number%20to%20String/README.md)
 
@@ -30,6 +30,29 @@
 
 ## Solutions
 
+**Solution 1: Decimal Fraction to Binary Fraction**
+
+The method of converting a decimal fraction to a binary fraction is as follows: multiply the decimal part by $2$, take the integer part as the next digit of the binary fraction, and take the decimal part as the multiplicand for the next multiplication, until the decimal part is $0$ or the length of the binary fraction exceeds $32$ bits.
+
+Let's take an example, suppose we want to convert $0.8125$ to a binary fraction, the process is as follows:
+
+$$
+\begin{aligned}
+0.8125 \times 2 &= 1.625 \quad \text{take the integer part} \quad 1 \\
+0.625 \times 2 &= 1.25 \quad \text{take the integer part} \quad 1 \\
+0.25 \times 2 &= 0.5 \quad \text{take the integer part} \quad 0 \\
+0.5 \times 2 &= 1 \quad \text{take the integer part} \quad 1 \\
+\end{aligned}
+$$
+
+So the binary fraction representation of the decimal fraction $0.8125$ is $0.1101_{(2)}$.
+
+For this problem, since the real number is between $0$ and $1$, its integer part must be $0$. We only need to convert the decimal part into a binary fraction according to the above method. Stop the conversion when the decimal part is $0$ or the length of the binary fraction is not less than $32$ bits.
+
+Finally, if the decimal part is not $0$, it means that the real number cannot be represented in binary within $32$ bits, return the string `"ERROR"`. Otherwise, return the converted binary fraction.
+
+The time complexity is $O(C)$, and the space complexity is $O(C)$. Here, $C$ is the length of the binary fraction, with a maximum of $32$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/05.03.Reverse Bits/README_EN.md

@@ -24,6 +24,14 @@
 
 ## Solutions
 
+**Solution 1: Two Pointers**
+
+We can use two pointers $i$ and $j$ to maintain a sliding window, where $i$ is the right pointer and $j$ is the left pointer. Each time the right pointer $i$ moves one bit to the right, if the number of $0$s in the window exceeds $1$, then the left pointer $j$ moves one bit to the right, until the number of $0$s in the window does not exceed $1$. Then calculate the length of the window at this time, compare it with the current maximum length, and take the larger value as the current maximum length.
+
+Finally, return the maximum length.
+
+The time complexity is $O(\log M)$, and the space complexity is $O(1)$. Here, $M$ is the maximum value of a 32-bit integer.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/05.04.Closed Number/README_EN.md

@@ -29,6 +29,20 @@
 
 ## Solutions
 
+**Solution 1: Bit Manipulation**
+
+First, let's consider how to find the first number that is larger than $num$ and has the same number of $1$s in its binary representation.
+
+We can traverse the adjacent two binary bits of $num$ from low to high. If the lower bit is $1$ and the adjacent higher bit is $0$, then we have found a position where we can change the $0$ at this position to $1$ and change the $1$ at this position to $0$. Then we move all the remaining lower bits of $1$ to the lowest bit, so we get a number that is larger than $num$ and has the same number of $1$s in its binary representation.
+
+Similarly, we can find the first number that is smaller than $num$ and has the same number of $1$s in its binary representation.
+
+We can traverse the adjacent two binary bits of $num$ from low to high. If the lower bit is $0$ and the adjacent higher bit is $1$, then we have found a position where we can change the $1$ at this position to $0$ and change the $0$ at this position to $1$. Then we move all the remaining lower bits of $0$ to the lowest bit, so we get a number that is smaller than $num$ and has the same number of $1$s in its binary representation.
+
+In implementation, we can use a piece of code to handle the above two situations uniformly.
+
+The time complexity is $O(\log n)$, where $n$ is the size of $num$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/05.06.Convert Integer/README_EN.md

@@ -46,6 +46,12 @@
 
 ## Solutions
 
+**Solution 1: Bit Manipulation**
+
+We perform a bitwise XOR operation on A and B. The number of $1$s in the result is the number of bits that need to be changed.
+
+The time complexity is $O(\log n)$, where $n$ is the maximum value of A and B. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/08.01.Three Steps Problem/README_EN.md

@@ -32,6 +32,42 @@
 
 ## Solutions
 
+**Solution 1: Recursion**
+
+We define $f[i]$ as the number of ways to reach the $i$-th step, initially $f[1]=1$, $f[2]=2$, $f[3]=4$. The answer is $f[n]$.
+
+The recursion formula is $f[i] = f[i-1] + f[i-2] + f[i-3]$.
+
+Since $f[i]$ is only related to $f[i-1]$, $f[i-2]$, $f[i-3]$, we can use three variables $a$, $b$, $c$ to store the values of $f[i-1]$, $f[i-2]$, $f[i-3]$, reducing the space complexity to $O(1)$.
+
+The time complexity is $O(n)$, where $n$ is the given integer. The space complexity is $O(1)$.
+
+**Solution 2: Matrix Quick Power to Accelerate Recursion**
+
+We set $F(n)$ to represent a $1 \times 3$ matrix $\begin{bmatrix} F_{n - 1} & F_{n - 2} & F_{n - 3} \end{bmatrix}$, where $F_{n - 1}$, $F_{n - 2}$ and $F_{n - 3}$ respectively represent the number of ways to reach the $n - 1$-th, $n - 2$-th and $n - 3$-th steps.
+
+We hope to derive $F(n)$ based on $F(n-1) = \begin{bmatrix} F_{n - 2} & F_{n - 3} & F_{n - 4} \end{bmatrix}$. That is to say, we need a matrix $base$, so that $F(n - 1) \times base = F(n)$, i.e.:
+
+$$
+\begin{bmatrix}
+F_{n - 2} & F_{n - 3} & F_{n - 4}
+\end{bmatrix} \times base = \begin{bmatrix} F_{n - 1} & F_{n - 2} & F_{n - 3} \end{bmatrix}
+$$
+
+Since $F_n = F_{n - 1} + F_{n - 2} + F_{n - 3}$, the matrix $base$ is:
+
+$$
+\begin{bmatrix}
+ 1 & 1 & 0 \\
+ 1 & 0 & 1 \\
+ 1 & 0 & 0
+\end{bmatrix}
+$$
+
+We define the initial matrix $res = \begin{bmatrix} 1 & 1  & 0 \end{bmatrix}$, then $F_n$ equals the sum of all elements in the result matrix of $res$ multiplied by $base^{n - 4}$. It can be solved using matrix quick power.
+
+The time complexity is $O(\log n)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/08.02.Robot in a Grid/README_EN.md

@@ -32,6 +32,14 @@
 
 ## Solutions
 
+**Solution 1: DFS (Depth-First Search)**
+
+We can use depth-first search to solve this problem. We start from the top left corner and move right or down until we reach the bottom right corner. If at some step, we find that the current position is an obstacle, or the current position is already in the path, then we return. Otherwise, we add the current position to the path and mark the current position as visited, then continue to move right or down.
+
+If we can finally reach the bottom right corner, then we have found a feasible path, otherwise, it means there is no feasible path.
+
+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 grid, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

lcci/08.04.Power Set/README.md

@@ -35,15 +35,15 @@
 
 当前枚举到的元素下标为 $u$，我们可以选择将其加入子集 $t$ 中，也可以选择不加入子集 $t$ 中。递归这两种选择，即可得到所有的子集。
 
-时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。数组中每个元素有两种状态，即选择或不选择，共 $2^n$ 种状态，每种状态需要 $O(n)$ 的时间来构造子集。
+时间复杂度 $O(n \times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。数组中每个元素有两种状态，即选择或不选择，共 $2^n$ 种状态，每种状态需要 $O(n)$ 的时间来构造子集。
 
 **方法二：二进制枚举**
 
 我们可以将方法一中的递归过程改写成迭代的形式，即使用二进制枚举的方法来枚举所有的子集。
 
 我们可以使用 $2^n$ 个二进制数来表示 $n$ 个元素的所有子集，若某个二进制数 `mask` 的第 $i$ 位为 $1$，表示子集中包含数组第 $i$ 个元素 $v$；若为 $0$，表示子集中不包含数组第 $i$ 个元素 $v$。
 
-时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。一共有 $2^n$ 个子集，每个子集需要 $O(n)$ 的时间来构造。
+时间复杂度 $O(n \times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。一共有 $2^n$ 个子集，每个子集需要 $O(n)$ 的时间来构造。
 
 <!-- tabs:start -->
 

lcci/08.04.Power Set/README_EN.md

@@ -40,7 +40,21 @@
 
 ## Solutions
 
-Backtracking
+**Solution 1: Recursive Enumeration**
+
+We design a recursive function $dfs(u, t)$, where $u$ is the index of the current element being enumerated, and $t$ is the current subset.
+
+For the current element with index $u$, we can choose to add it to the subset $t$, or we can choose not to add it to the subset $t$. Recursively making these two choices will yield all subsets.
+
+The time complexity is $O(n \times 2^n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array. Each element in the array has two states, namely chosen or not chosen, for a total of $2^n$ states. Each state requires $O(n)$ time to construct the subset.
+
+**Solution 2: Binary Enumeration**
+
+We can rewrite the recursive process in Method 1 into an iterative form, that is, using binary enumeration to enumerate all subsets.
+
+We can use $2^n$ binary numbers to represent all subsets of $n$ elements. If the $i$-th bit of a binary number `mask` is $1$, it means that the subset contains the $i$-th element $v$ of the array; if it is $0$, it means that the subset does not contain the $i$-th element $v$ of the array.
+
+The time complexity is $O(n \times 2^n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array. There are a total of $2^n$ subsets, and each subset requires $O(n)$ time to construct.
 
 <!-- tabs:start -->