feat: add solutions to lc problems: No.1692,1695,1732+ (#2121)

Author: yanglbme

solution/1600-1699/1692.Count Ways to Distribute Candies/README.md

@@ -155,6 +155,24 @@ func waysToDistribute(n int, k int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function waysToDistribute(n: number, k: number): number {
+    const mod = 10 ** 9 + 7;
+    const f: number[][] = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: k + 1 }, () => 0),
+    );
+    f[0][0] = 1;
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= k; ++j) {
+            f[i][j] = (f[i - 1][j] * j + f[i - 1][j - 1]) % mod;
+        }
+    }
+    return f[n][k];
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1692.Count Ways to Distribute Candies/README_EN.md

@@ -145,6 +145,24 @@ func waysToDistribute(n int, k int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function waysToDistribute(n: number, k: number): number {
+    const mod = 10 ** 9 + 7;
+    const f: number[][] = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: k + 1 }, () => 0),
+    );
+    f[0][0] = 1;
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= k; ++j) {
+            f[i][j] = (f[i - 1][j] * j + f[i - 1][j - 1]) % mod;
+        }
+    }
+    return f[n][k];
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1692.Count Ways to Distribute Candies/Solution.ts

@@ -0,0 +1,13 @@
+function waysToDistribute(n: number, k: number): number {
+    const mod = 10 ** 9 + 7;
+    const f: number[][] = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: k + 1 }, () => 0),
+    );
+    f[0][0] = 1;
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= k; ++j) {
+            f[i][j] = (f[i - 1][j] * j + f[i - 1][j - 1]) % mod;
+        }
+    }
+    return f[n][k];
+}

solution/1600-1699/1695.Maximum Erasure Value/README.md

@@ -140,6 +140,27 @@ func maximumUniqueSubarray(nums []int) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumUniqueSubarray(nums: number[]): number {
+    const m = Math.max(...nums);
+    const n = nums.length;
+    const s: number[] = Array.from({ length: n + 1 }, () => 0);
+    for (let i = 1; i <= n; ++i) {
+        s[i] = s[i - 1] + nums[i - 1];
+    }
+    const d = Array.from({ length: m + 1 }, () => 0);
+    let [ans, j] = [0, 0];
+    for (let i = 1; i <= n; ++i) {
+        j = Math.max(j, d[nums[i - 1]]);
+        ans = Math.max(ans, s[i] - s[j]);
+        d[nums[i - 1]] = i;
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1695.Maximum Erasure Value/README_EN.md

@@ -130,6 +130,27 @@ func maximumUniqueSubarray(nums []int) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumUniqueSubarray(nums: number[]): number {
+    const m = Math.max(...nums);
+    const n = nums.length;
+    const s: number[] = Array.from({ length: n + 1 }, () => 0);
+    for (let i = 1; i <= n; ++i) {
+        s[i] = s[i - 1] + nums[i - 1];
+    }
+    const d = Array.from({ length: m + 1 }, () => 0);
+    let [ans, j] = [0, 0];
+    for (let i = 1; i <= n; ++i) {
+        j = Math.max(j, d[nums[i - 1]]);
+        ans = Math.max(ans, s[i] - s[j]);
+        d[nums[i - 1]] = i;
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1695.Maximum Erasure Value/Solution.ts

@@ -0,0 +1,16 @@
+function maximumUniqueSubarray(nums: number[]): number {
+    const m = Math.max(...nums);
+    const n = nums.length;
+    const s: number[] = Array.from({ length: n + 1 }, () => 0);
+    for (let i = 1; i <= n; ++i) {
+        s[i] = s[i - 1] + nums[i - 1];
+    }
+    const d = Array.from({ length: m + 1 }, () => 0);
+    let [ans, j] = [0, 0];
+    for (let i = 1; i <= n; ++i) {
+        j = Math.max(j, d[nums[i - 1]]);
+        ans = Math.max(ans, s[i] - s[j]);
+        d[nums[i - 1]] = i;
+    }
+    return ans;
+}

solution/1700-1799/1732.Find the Highest Altitude/README_EN.md

@@ -36,6 +36,26 @@
 
 ## Solutions
 
+**Solution 1: Prefix Sum (Difference Array)**
+
+We assume the altitude of each point is $h_i$. Since $gain[i]$ represents the altitude difference between the $i$th point and the $(i + 1)$th point, we have $gain[i] = h_{i + 1} - h_i$. Therefore:
+
+$$
+\sum_{i = 0}^{n-1} gain[i] = h_1 - h_0 + h_2 - h_1 + \cdots + h_n - h_{n - 1} = h_n - h_0 = h_n
+$$
+
+which implies:
+
+$$
+h_{i+1} = \sum_{j = 0}^{i} gain[j]
+$$
+
+We can see that the altitude of each point can be calculated through the prefix sum. Therefore, we only need to traverse the array once, find the maximum value of the prefix sum, which is the highest altitude.
+
+> In fact, the $gain$ array in the problem is a difference array. The prefix sum of the difference array gives the original altitude array. Then find the maximum value of the original altitude array.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array `gain`.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1734.Decode XORed Permutation/README_EN.md

@@ -37,6 +37,12 @@
 
 ## Solutions
 
+**Solution 1: Bitwise Operation**
+
+We notice that the array $perm$ is a permutation of the first $n$ positive integers, so the XOR of all elements in $perm$ is $1 \oplus 2 \oplus \cdots \oplus n$, denoted as $a$. And $encode[i]=perm[i] \oplus perm[i+1]$, if we denote the XOR of all elements $encode[0],encode[2],\cdots,encode[n-3]$ as $b$, then $perm[n-1]=a \oplus b$. Knowing the last element of $perm$, we can find all elements of $perm$ by traversing the array $encode$ in reverse order.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $perm$. Ignoring the space consumption of the answer, the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1735.Count Ways to Make Array With Product/README_EN.md

@@ -37,6 +37,22 @@
 
 ## Solutions
 
+**Solution 1: Prime Factorization + Combinatorial Mathematics**
+
+We can perform prime factorization on $k$, i.e., $k = p_1^{x_1} \times p_2^{x_2} \times \cdots \times p_m^{x_m}$, where $p_i$ is a prime number, and $x_i$ is the exponent of $p_i$. The problem is equivalent to: placing $x_1$ $p_1$s, $x_2$ $p_2$s, $\cdots$, $x_m$ $p_m$s into $n$ positions respectively, where a single position can be empty. The question is how many schemes are there.
+
+According to combinatorial mathematics, there are two cases when we put $x$ balls into $n$ boxes:
+
+If the box cannot be empty, the number of schemes is $C_{x-1}^{n-1}$. This is using the partition method, i.e., there are a total of $x$ balls, and we insert $n-1$ partitions at $x-1$ positions, thereby dividing the $x$ balls into $n$ groups.
+
+If the box can be empty, we can add $n$ virtual balls, and then use the partition method, i.e., there are a total of $x+n$ balls, and we insert $n-1$ partitions at $x+n-1$ positions, thereby dividing the actual $x$ balls into $n$ groups and allowing the box to be empty. Therefore, the number of schemes is $C_{x+n-1}^{n-1}$.
+
+Therefore, for each query $queries[i]$, we can first perform prime factorization on $k$ to get the exponents $x_1, x_2, \cdots, x_m$, then calculate $C_{x_1+n-1}^{n-1}, C_{x_2+n-1}^{n-1}, \cdots, C_{x_m+n-1}^{n-1}$, and finally multiply all the scheme numbers.
+
+So, the problem is transformed into how to quickly calculate $C_m^n$. According to the formula $C_m^n = \frac{m!}{n!(m-n)!}$, we can pre-process $m!$, and then use the inverse element to quickly calculate $C_m^n$.
+
+The time complexity is $O(K \times \log \log K + N + m \times \log K)$, and the space complexity is $O(N)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1736.Latest Time by Replacing Hidden Digits/README_EN.md

@@ -43,6 +43,17 @@
 
 ## Solutions
 
+**Solution 1: Greedy**
+
+We process each digit of the string in order, following these rules:
+
+1. First digit: If the value of the second digit is determined and falls within the range $[4, 9]$, then the first digit can only be $1$. Otherwise, the first digit can be up to $2$.
+1. Second digit: If the value of the first digit is determined and is $2$, then the second digit can be up to $3$. Otherwise, the second digit can be up to $9$.
+1. Third digit: The third digit can be up to $5$.
+1. Fourth digit: The fourth digit can be up to $9$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1737.Change Minimum Characters to Satisfy One of Three Conditions/README_EN.md

@@ -47,7 +47,17 @@ The best way was done in 2 operations (either condition 1 or condition 3).
 
 ## Solutions
 
-Prefix Sum
+**Solution 1: Counting + Enumeration**
+
+First, we count the number of occurrences of each letter in strings $a$ and $b$, denoted as $cnt_1$ and $cnt_2$.
+
+Then, we consider condition $3$, i.e., every letter in $a$ and $b$ is the same. We just need to enumerate the final letter $c$, and then count the number of letters in $a$ and $b$ that are not $c$. This is the number of characters that need to be changed.
+
+Next, we consider conditions $1$ and $2$, i.e., every letter in $a$ is less than every letter in $b$, or every letter in $b$ is less than every letter in $a$. For condition $1$, we make all characters in string $a$ less than character $c$, and all characters in string $b$ not less than $c$. We enumerate $c$ to find the smallest answer. Condition $2$ is similar.
+
+The final answer is the minimum of the above three cases.
+
+The time complexity is $O(m + n + C^2)$, where $m$ and $n$ are the lengths of strings $a$ and $b$ respectively, and $C$ is the size of the character set. In this problem, $C = 26$.
 
 <!-- tabs:start -->
 

solution/1700-1799/1738.Find Kth Largest XOR Coordinate Value/README.md

@@ -54,7 +54,23 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二维前缀异或，然后求第 k 大的值即可。
+**方法一：二维前缀异或 + 排序或快速选择**
+
+我们定义一个二维前缀异或数组 $s$，其中 $s[i][j]$ 表示矩阵前 $i$ 行和前 $j$ 列的元素异或运算的结果，即：
+
+$$
+s[i][j] = \bigoplus_{0 \leq x \leq i, 0 \leq y \leq j} matrix[x][y]
+$$
+
+而 $s[i][j]$ 可以由 $s[i - 1][j]$, $s[i][j - 1]$ 和 $s[i - 1][j - 1]$ 三个元素计算得到，即：
+
+$$
+s[i][j] = s[i - 1][j] \oplus s[i][j - 1] \oplus s[i - 1][j - 1] \oplus matrix[i - 1][j - 1]
+$$
+
+我们遍历矩阵，计算出所有的 $s[i][j]$，然后将其排序，最后返回第 $k$ 大的元素即可。如果不想使用排序，也可以使用快速选择算法，这样可以优化时间复杂度。
+
+时间复杂度 $O(m \times n \times \log (m \times n))$ 或 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
 <!-- tabs:start -->
 
@@ -81,7 +97,6 @@ class Solution:
 
 ```java
 class Solution {
-
     public int kthLargestValue(int[][] matrix, int k) {
         int m = matrix.length, n = matrix[0].length;
         int[][] s = new int[m + 1][n + 1];
@@ -140,6 +155,25 @@ func kthLargestValue(matrix [][]int, k int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function kthLargestValue(matrix: number[][], k: number): number {
+    const m: number = matrix.length;
+    const n: number = matrix[0].length;
+    const s = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+    const ans: number[] = [];
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            s[i + 1][j + 1] = s[i + 1][j] ^ s[i][j + 1] ^ s[i][j] ^ matrix[i][j];
+            ans.push(s[i + 1][j + 1]);
+        }
+    }
+    ans.sort((a, b) => b - a);
+    return ans[k - 1];
+}
+```
+
 ### **...**
 
 ```

solution/1700-1799/1738.Find Kth Largest XOR Coordinate Value/README_EN.md

@@ -47,6 +47,24 @@
 
 ## Solutions
 
+**Solution 1: Two-dimensional Prefix XOR + Sorting or Quick Selection**
+
+We define a two-dimensional prefix XOR array $s$, where $s[i][j]$ represents the XOR result of the elements in the first $i$ rows and the first $j$ columns of the matrix, i.e.,
+
+$$
+s[i][j] = \bigoplus_{0 \leq x \leq i, 0 \leq y \leq j} matrix[x][y]
+$$
+
+And $s[i][j]$ can be calculated from the three elements $s[i - 1][j]$, $s[i][j - 1]$ and $s[i - 1][j - 1]$, i.e.,
+
+$$
+s[i][j] = s[i - 1][j] \oplus s[i][j - 1] \oplus s[i - 1][j - 1] \oplus matrix[i - 1][j - 1]
+$$
+
+We traverse the matrix, calculate all $s[i][j]$, then sort them, and finally return the $k$th largest element. If you don't want to use sorting, you can also use the quick selection algorithm, which can optimize the time complexity.
+
+The time complexity is $O(m \times n \times \log (m \times n))$ or $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 matrix, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -68,7 +86,6 @@ class Solution:
 
 ```java
 class Solution {
-
     public int kthLargestValue(int[][] matrix, int k) {
         int m = matrix.length, n = matrix[0].length;
         int[][] s = new int[m + 1][n + 1];
@@ -127,6 +144,25 @@ func kthLargestValue(matrix [][]int, k int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function kthLargestValue(matrix: number[][], k: number): number {
+    const m: number = matrix.length;
+    const n: number = matrix[0].length;
+    const s = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+    const ans: number[] = [];
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            s[i + 1][j + 1] = s[i + 1][j] ^ s[i][j + 1] ^ s[i][j] ^ matrix[i][j];
+            ans.push(s[i + 1][j + 1]);
+        }
+    }
+    ans.sort((a, b) => b - a);
+    return ans[k - 1];
+}
+```
+
 ### **...**
 
 ```

solution/1700-1799/1738.Find Kth Largest XOR Coordinate Value/Solution.ts

@@ -0,0 +1,14 @@
+function kthLargestValue(matrix: number[][], k: number): number {
+    const m: number = matrix.length;
+    const n: number = matrix[0].length;
+    const s = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+    const ans: number[] = [];
+    for (let i = 0; i < m; ++i) {
+        for (let j = 0; j < n; ++j) {
+            s[i + 1][j + 1] = s[i + 1][j] ^ s[i][j + 1] ^ s[i][j] ^ matrix[i][j];
+            ans.push(s[i + 1][j + 1]);
+        }
+    }
+    ans.sort((a, b) => b - a);
+    return ans[k - 1];
+}

solution/1700-1799/1739.Building Boxes/README.md

@@ -69,7 +69,7 @@
 
 如果此时盒子还有剩余，那么可以从最低一层继续摆放，假设摆放 $i$ 个，那么累计可摆放的盒子个数为 $1+2+\cdots+i$。
 
-时间复杂度 $O(\sqrt{n})$，空间复杂度 $O(1)$。其中 $n$ 为题目给定的盒子数量。
+时间复杂度 $O(\sqrt{n})$，其中 $n$ 为题目给定的盒子数量。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1700-1799/1739.Building Boxes/README_EN.md

@@ -55,6 +55,16 @@ These boxes are placed in the corner of the room, where the corner is on the bac
 
 ## Solutions
 
+**Solution 1: Mathematical Rule**
+
+According to the problem description, the box with the highest number of layers needs to be placed in the corner of the wall, and the arrangement of the boxes is in a step-like shape, which can minimize the number of boxes touching the ground.
+
+Assume that the boxes are arranged in $k$ layers. From top to bottom, if each layer is filled, then the number of boxes in each layer is $1, 1+2, 1+2+3, \cdots, 1+2+\cdots+k$.
+
+If there are still remaining boxes at this point, they can continue to be placed from the lowest layer. Assume that $i$ boxes are placed, then the cumulative number of boxes that can be placed is $1+2+\cdots+i$.
+
+The time complexity is $O(\sqrt{n})$, where $n$ is the number of boxes given in the problem. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**