Merge branch 'doocs:main' into main

Author: Nothing-avil

.github/workflows/deploy.yml

@@ -7,6 +7,9 @@ on:
       - docs
   workflow_dispatch:
 
+env:
+  MKDOCS_API_KEYS: ${{ secrets.MKDOCS_API_KEYS }}
+
 permissions:
   contents: write
 

solution/1900-1999/1997.First Day Where You Have Been in All the Rooms/README.md

@@ -133,6 +133,32 @@ func firstDayBeenInAllRooms(nextVisit []int) int {
 }
 ```
 
+```ts
+function firstDayBeenInAllRooms(nextVisit: number[]): number {
+    const n = nextVisit.length;
+    const mod = 1e9 + 7;
+    const f: number[] = new Array<number>(n).fill(0);
+    for (let i = 1; i < n; ++i) {
+        f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+    }
+    return f[n - 1];
+}
+```
+
+```cs
+public class Solution {
+    public int FirstDayBeenInAllRooms(int[] nextVisit) {
+        int n = nextVisit.Length;
+        long[] f = new long[n];
+        int mod = (int)1e9 + 7;
+        for (int i = 1; i < n; ++i) {
+            f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+        }
+        return (int)f[n - 1];
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/1900-1999/1997.First Day Where You Have Been in All the Rooms/README_EN.md

@@ -63,7 +63,17 @@ Day 6 is the first day where you have been in all the rooms.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i]$ as the date number of the first visit to the $i$-th room, so the answer is $f[n - 1]$.
+
+Consider the date number of the first arrival at the $(i-1)$-th room, denoted as $f[i-1]$. At this time, it takes one day to return to the $nextVisit[i-1]$-th room. Why return? Because the problem restricts $0 \leq nextVisit[i] \leq i$.
+
+After returning, the $nextVisit[i-1]$-th room is visited an odd number of times, and the rooms from $nextVisit[i-1]+1$ to $i-1$ are visited an even number of times. At this time, we go to the $(i-1)$-th room again from the $nextVisit[i-1]$-th room, which takes $f[i-1] - f[nextVisit[i-1]]$ days, and then it takes one more day to reach the $i$-th room. Therefore, $f[i] = f[i-1] + 1 + f[i-1] - f[nextVisit[i-1]] + 1$. Since $f[i]$ may be very large, we need to take the remainder of $10^9 + 7$, and to prevent negative numbers, we need to add $10^9 + 7$.
+
+Finally, return $f[n-1]$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of rooms.
 
 <!-- tabs:start -->
 
@@ -119,6 +129,32 @@ func firstDayBeenInAllRooms(nextVisit []int) int {
 }
 ```
 
+```ts
+function firstDayBeenInAllRooms(nextVisit: number[]): number {
+    const n = nextVisit.length;
+    const mod = 1e9 + 7;
+    const f: number[] = new Array<number>(n).fill(0);
+    for (let i = 1; i < n; ++i) {
+        f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+    }
+    return f[n - 1];
+}
+```
+
+```cs
+public class Solution {
+    public int FirstDayBeenInAllRooms(int[] nextVisit) {
+        int n = nextVisit.Length;
+        long[] f = new long[n];
+        int mod = (int)1e9 + 7;
+        for (int i = 1; i < n; ++i) {
+            f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+        }
+        return (int)f[n - 1];
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/1900-1999/1997.First Day Where You Have Been in All the Rooms/Solution.cs

@@ -0,0 +1,11 @@
+public class Solution {
+    public int FirstDayBeenInAllRooms(int[] nextVisit) {
+        int n = nextVisit.Length;
+        long[] f = new long[n];
+        int mod = (int)1e9 + 7;
+        for (int i = 1; i < n; ++i) {
+            f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+        }
+        return (int)f[n - 1];
+    }
+}

solution/1900-1999/1997.First Day Where You Have Been in All the Rooms/Solution.ts

@@ -0,0 +1,9 @@
+function firstDayBeenInAllRooms(nextVisit: number[]): number {
+    const n = nextVisit.length;
+    const mod = 1e9 + 7;
+    const f: number[] = new Array<number>(n).fill(0);
+    for (let i = 1; i < n; ++i) {
+        f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + mod) % mod;
+    }
+    return f[n - 1];
+}

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 -->