feat: add solutions to lc problems: No.1790+ (doocs#2126)

Author: yanglbme

solution/1700-1799/1790.Check if One String Swap Can Make Strings Equal/README.md

@@ -53,15 +53,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：简单计数**
+**方法一：计数**
 
 我们用变量 $cnt$ 记录两个字符串中相同位置字符不同的个数，两个字符串若满足题目要求，那么 $cnt$ 一定为 $0$ 或 $2$。另外用两个字符变量 $c1$ 和 $c2$ 记录两个字符串中相同位置字符不同的字符。
 
 同时遍历两个字符串，对于相同位置的两个字符 $a$ 和 $b$，如果 $a \ne b$，那么 $cnt$ 自增 $1$。如果此时 $cnt$ 大于 $2$，或者 $cnt$ 为 $2$ 且 $a \ne c2$ 或 $b \ne c1$，那么直接返回 `false`。注意记录一下 $c1$ 和 $c2$。
 
-遍历结束，若 $cnt\neq 1$，返回 `true`。
+遍历结束，若 $cnt \neq 1$，返回 `true`。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1700-1799/1790.Check if One String Swap Can Make Strings Equal/README_EN.md

@@ -44,6 +44,16 @@
 
 ## Solutions
 
+**Solution 1: Counting**
+
+We use a variable $cnt$ to record the number of characters at the same position in the two strings that are different. If the two strings meet the requirements of the problem, then $cnt$ must be $0$ or $2$. We also use two character variables $c1$ and $c2$ to record the characters that are different at the same position in the two strings.
+
+While traversing the two strings simultaneously, for two characters $a$ and $b$ at the same position, if $a \ne b$, then $cnt$ is incremented by $1$. If at this time $cnt$ is greater than $2$, or $cnt$ is $2$ and $a \ne c2$ or $b \ne c1$, then we directly return `false`. Note to record $c1$ and $c2$.
+
+At the end of the traversal, if $cnt \neq 1$, return `true`.
+
+The time complexity is $O(n)$, where $n$ is the length of the string. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1791.Find Center of Star Graph/README.md

@@ -48,7 +48,7 @@
 
 中心点的特点是，它与其他所有点都相连，因此只要比较前两条边的点，如果有相同的点，那么这个点就是中心点。
 
-时间复杂度 $O(1)$。
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1700-1799/1791.Find Center of Star Graph/README_EN.md

@@ -38,6 +38,12 @@
 
 ## Solutions
 
+**Solution 1: Directly Compare the Points of the First Two Edges**
+
+The characteristic of the center point is that it is connected to all other points. Therefore, as long as we compare the points of the first two edges, if there are the same points, then this point is the center point.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1792.Maximum Average Pass Ratio/README.md

@@ -56,7 +56,7 @@
 
 最后，我们将所有班级的通过率求和，然后除以班级数目，即为答案。
 
-时间复杂度 $O(n\log n)$，其中 $n$ 为班级数目。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为班级数目。
 
 <!-- tabs:start -->
 

solution/1700-1799/1792.Maximum Average Pass Ratio/README_EN.md

@@ -40,6 +40,18 @@
 
 ## Solutions
 
+**Solution 1: Priority Queue (Max-Heap of Increment)**
+
+Suppose a class currently has a pass rate of $\frac{a}{b}$. If we arrange a smart student into this class, then the pass rate of the class will become $\frac{a+1}{b+1}$. We can find that the increment of the pass rate is $\frac{a+1}{b+1} - \frac{a}{b}$.
+
+We maintain a max-heap, which stores the increment of the pass rate for each class.
+
+Perform `extraStudents` operations, each time taking a class from the top of the heap, adding $1$ to both the number of students and the number of passes in this class, then recalculating the increment of the pass rate of this class and putting it back into the heap. Repeat this process until all students are allocated.
+
+Finally, we sum up the pass rates of all classes, and then divide by the number of classes to get the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the number of classes.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1700-1799/1794.Count Pairs of Equal Substrings With Minimum Difference/README.md

@@ -160,6 +160,31 @@ func countQuadruples(firstString string, secondString string) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countQuadruples(firstString: string, secondString: string): number {
+    const last: number[] = new Array(26).fill(0);
+    for (let i = 0; i < secondString.length; ++i) {
+        last[secondString.charCodeAt(i) - 97] = i + 1;
+    }
+    let [ans, mi] = [0, Infinity];
+    for (let i = 0; i < firstString.length; ++i) {
+        const j = last[firstString.charCodeAt(i) - 97];
+        if (j) {
+            const t = i - j;
+            if (mi > t) {
+                mi = t;
+                ans = 1;
+            } else if (mi === t) {
+                ++ans;
+            }
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1700-1799/1794.Count Pairs of Equal Substrings With Minimum Difference/README_EN.md

@@ -42,6 +42,14 @@
 
 ## Solutions
 
+**Solution 1: Greedy + Hash Table**
+
+The problem actually asks us to find a smallest index $i$ and a largest index $j$ such that $firstString[i]$ equals $secondString[j]$, and the value of $i - j$ is the smallest among all index pairs that meet the conditions.
+
+Therefore, we first use a hash table $last$ to record the index of the last occurrence of each character in $secondString$. Then we traverse $firstString$. For each character $c$, if $c$ has appeared in $secondString$, we calculate $i - last[c]$. If the value of $i - last[c]$ is less than the current minimum value, we update the minimum value and set the answer to 1. If the value of $i - last[c]$ equals the current minimum value, we increment the answer by 1.
+
+The time complexity is $O(m + n)$, and the space complexity is $O(C)$. Here, $m$ and $n$ are the lengths of $firstString$ and $secondString$ respectively, and $C$ is the size of the character set. In this problem, $C = 26$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -142,6 +150,31 @@ func countQuadruples(firstString string, secondString string) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countQuadruples(firstString: string, secondString: string): number {
+    const last: number[] = new Array(26).fill(0);
+    for (let i = 0; i < secondString.length; ++i) {
+        last[secondString.charCodeAt(i) - 97] = i + 1;
+    }
+    let [ans, mi] = [0, Infinity];
+    for (let i = 0; i < firstString.length; ++i) {
+        const j = last[firstString.charCodeAt(i) - 97];
+        if (j) {
+            const t = i - j;
+            if (mi > t) {
+                mi = t;
+                ans = 1;
+            } else if (mi === t) {
+                ++ans;
+            }
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/1700-1799/1794.Count Pairs of Equal Substrings With Minimum Difference/Solution.ts

@@ -0,0 +1,20 @@
+function countQuadruples(firstString: string, secondString: string): number {
+    const last: number[] = new Array(26).fill(0);
+    for (let i = 0; i < secondString.length; ++i) {
+        last[secondString.charCodeAt(i) - 97] = i + 1;
+    }
+    let [ans, mi] = [0, Infinity];
+    for (let i = 0; i < firstString.length; ++i) {
+        const j = last[firstString.charCodeAt(i) - 97];
+        if (j) {
+            const t = i - j;
+            if (mi > t) {
+                mi = t;
+                ans = 1;
+            } else if (mi === t) {
+                ++ans;
+            }
+        }
+    }
+    return ans;
+}

solution/1700-1799/1796.Second Largest Digit in a String/README.md

@@ -49,7 +49,7 @@
 
 遍历结束，返回 $b$ 即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
 **方法二：位运算**
 
@@ -59,7 +59,7 @@
 
 最后，我们从高位向低位遍历 $mask$，找到第二个为 $1$ 的二进制位，其对应的数字即为第二大数字。如果不存在第二大数字，返回 $-1$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->