feat: add solutions to lc problems: No.1692,1695,1732+ (doocs#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**