feat: add solutions to lc problems: No.2046,2050 (doocs#2515)

Author: yanglbme

solution/2000-2099/2000.Reverse Prefix of Word/README.md

@@ -164,25 +164,4 @@ class Solution {
 
 <!-- tabs:end -->
 
-### 方法二
-
-<!-- tabs:start -->
-
-```java
-class Solution {
-    public String reversePrefix(String word, char ch) {
-        int j = word.indexOf(ch);
-        if (j == -1) {
-            return word;
-        }
-        return new StringBuilder(word.substring(0, j + 1))
-            .reverse()
-            .append(word.substring(j + 1))
-            .toString();
-    }
-}
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/2000-2099/2000.Reverse Prefix of Word/README_EN.md

@@ -163,25 +163,4 @@ class Solution {
 
 <!-- tabs:end -->
 
-### Solution 2
-
-<!-- tabs:start -->
-
-```java
-class Solution {
-    public String reversePrefix(String word, char ch) {
-        int j = word.indexOf(ch);
-        if (j == -1) {
-            return word;
-        }
-        return new StringBuilder(word.substring(0, j + 1))
-            .reverse()
-            .append(word.substring(j + 1))
-            .toString();
-    }
-}
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/2000-2099/2000.Reverse Prefix of Word/Solution2.java

@@ -58,7 +58,9 @@
 
 ### 方法一：头插法
 
-先默认第一个点已经排序完毕。然后从第二个点开始，遇到值为负数的节点，采用头插法；非负数，则继续往下遍历即可。
+我们先默认第一个点已经排序完毕，然后从第二个点开始，遇到值为负数的节点，采用头插法；非负数，则继续往下遍历即可。
+
+时间复杂度 $O(n)$，其中 $n$ 为链表的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -172,6 +174,36 @@ func sortLinkedList(head *ListNode) *ListNode {
 }
 ```
 
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function sortLinkedList(head: ListNode | null): ListNode | null {
+    let [prev, curr] = [head, head.next];
+    while (curr !== null) {
+        if (curr.val < 0) {
+            const t = curr.next;
+            prev.next = t;
+            curr.next = head;
+            head = curr;
+            curr = t;
+        } else {
+            [prev, curr] = [curr, curr.next];
+        }
+    }
+    return head;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2000-2099/2046.Sort Linked List Already Sorted Using Absolute Values/README.md

@@ -54,7 +54,11 @@ The linked list is already sorted in non-decreasing order.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Head Insertion Method
+
+We first assume that the first node is already sorted. Starting from the second node, when we encounter a node with a negative value, we use the head insertion method. For non-negative values, we continue to traverse down.
+
+The time complexity is $O(n)$, where $n$ is the length of the linked list. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -168,6 +172,36 @@ func sortLinkedList(head *ListNode) *ListNode {
 }
 ```
 
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function sortLinkedList(head: ListNode | null): ListNode | null {
+    let [prev, curr] = [head, head.next];
+    while (curr !== null) {
+        if (curr.val < 0) {
+            const t = curr.next;
+            prev.next = t;
+            curr.next = head;
+            head = curr;
+            curr = t;
+        } else {
+            [prev, curr] = [curr, curr.next];
+        }
+    }
+    return head;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2000-2099/2046.Sort Linked List Already Sorted Using Absolute Values/README_EN.md

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function sortLinkedList(head: ListNode | null): ListNode | null {
+    let [prev, curr] = [head, head.next];
+    while (curr !== null) {
+        if (curr.val < 0) {
+            const t = curr.next;
+            prev.next = t;
+            curr.next = head;
+            head = curr;
+            curr = t;
+        } else {
+            [prev, curr] = [curr, curr.next];
+        }
+    }
+    return head;
+}

solution/2000-2099/2046.Sort Linked List Already Sorted Using Absolute Values/Solution.ts

@@ -78,7 +78,7 @@
 -   数组 $f$ 存储每个节点的最早完成时间，初始时 $f[i] = 0$；
 -   变量 $ans$ 记录最终的答案，初始时 $ans = 0$；
 
-当 $q$ 非空时，依次取出队首节点 $i$，遍历 $g[i]$ 中的每个节点 $j$，更新 $f[j] = max(f[j], f[i] + time[j])$，同时更新 $ans = \max(ans, f[j])$，并将 $j$ 的入度减 $1$，如果此时 $j$ 的入度为 $0$，则将 $j$ 加入队列 $q$ 中；
+当 $q$ 非空时，依次取出队首节点 $i$，遍历 $g[i]$ 中的每个节点 $j$，更新 $f[j] = \max(f[j], f[i] + time[j])$，同时更新 $ans = \max(ans, f[j])$，并将 $j$ 的入度减 $1$，如果此时 $j$ 的入度为 $0$，则将 $j$ 加入队列 $q$ 中；
 
 最终返回 $ans$。
 

solution/2000-2099/2050.Parallel Courses III/README.md

@@ -63,7 +63,22 @@ Thus, the minimum time needed to complete all the courses is 7 + 5 = 12 months.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Topological Sorting + Dynamic Programming
+
+First, we construct a directed acyclic graph based on the given prerequisite course relationships, perform topological sorting on this graph, and then use dynamic programming to find the minimum time required to complete all courses according to the results of the topological sorting.
+
+We define the following data structures or variables:
+
+-   Adjacency list $g$ stores the directed acyclic graph, and an array $indeg$ stores the in-degree of each node;
+-   Queue $q$ stores all nodes with an in-degree of $0$;
+-   Array $f$ stores the earliest completion time of each node, initially $f[i] = 0$;
+-   Variable $ans$ records the final answer, initially $ans = 0$;
+
+When $q$ is not empty, take out the head node $i$ in turn, traverse each node $j$ in $g[i]$, update $f[j] = \max(f[j], f[i] + time[j])$, update $ans = \max(ans, f[j])$ at the same time, and reduce the in-degree of $j$ by $1$. If the in-degree of $j$ is $0$ at this time, add $j$ to the queue $q$;
+
+Finally, return $ans$.
+
+The time complexity is $O(m + n)$, and the space complexity is $O(m + n)$. Where $m$ is the length of the array $relations$.
 
 <!-- tabs:start -->
 

solution/2000-2099/2050.Parallel Courses III/README_EN.md

@@ -57,7 +57,7 @@
 
 ### 方法一：排序 + 二分查找
 
-时间复杂度 $O(nlogn)$，其中 $n$ 表示 $events$ 的长度。
+时间复杂度 $O(n \times \log n)$，其中 $n$ 表示 $events$ 的长度。
 
 <!-- tabs:start -->