feat: add solutions to lc problems: No.1227+ (doocs#2152)

Author: yanglbme

solution/1200-1299/1227.Airplane Seat Assignment Probability/README_EN.md

@@ -38,6 +38,85 @@
 
 ## Solutions
 
+**Solution 1: Mathematics**
+
+Let $f(n)$ represent the probability that the $n$th passenger will sit in their own seat when there are $n$ passengers boarding. Consider from the simplest case:
+
+-   When $n=1$, there is only 1 passenger and 1 seat, so the first passenger can only sit in the first seat, $f(1)=1$;
+
+-   When $n=2$, there are 2 seats, each seat has a probability of 0.5 to be chosen by the first passenger. After the first passenger chooses a seat, the second passenger can only choose the remaining seat, so the second passenger has a probability of 0.5 to sit in their own seat, $f(2)=0.5$.
+
+When $n>2$, how to calculate the value of $f(n)$? Consider the seat chosen by the first passenger, there are three cases.
+
+-   The first passenger has a probability of $\frac{1}{n}$ to choose the first seat, then all passengers can sit in their own seats, so the probability of the $n$th passenger sitting in their own seat is 1.0.
+
+-   The first passenger has a probability of $\frac{1}{n}$ to choose the $n$th seat, then the second to the $(n-1)$th passengers can sit in their own seats, the $n$th passenger can only sit in the first seat, so the probability of the $n$th passenger sitting in their own seat is 0.0.
+
+-   The first passenger has a probability of $\frac{n-2}{n}$ to choose the remaining seats, each seat has a probability of $\frac{1}{n}$ to be chosen.
+    Suppose the first passenger chooses the $i$th seat, where $2 \le i \le n-1$, then the second to the $(i-1)$th passengers can sit in their own seats, the seats of the $i$th to the $n$th passengers are uncertain, the $i$th passenger will randomly choose from the remaining $n-(i-1)=n-i+1$ seats (including the first seat and the $(i+1)$th to the $n$th seats). Since the number of remaining passengers and seats is $n-i+1$, and 1 passenger will randomly choose a seat, the problem size is reduced from $n$ to $n-i+1$.
+
+Combining the above three cases, we can get the recursive formula of $f(n)$:
+
+$$
+\begin{aligned}
+f(n) &= \frac{1}{n} \times 1.0 + \frac{1}{n} \times 0.0 + \frac{1}{n} \times \sum_{i=2}^{n-1} f(n-i+1) \\
+&= \frac{1}{n}(1.0+\sum_{i=2}^{n-1} f(n-i+1))
+\end{aligned}
+$$
+
+In the above recursive formula, there are $n-2$ values of $i$, since the number of values of $i$ must be a non-negative integer, so the above recursive formula only holds when $n-2 \ge 0$ i.e., $n \ge 2$.
+
+If you directly use the above recursive formula to calculate the value of $f(n)$, the time complexity is $O(n^2)$, which cannot pass all test cases, so it needs to be optimized.
+
+Replace $n$ with $n-1$ in the above recursive formula, you can get the recursive formula:
+
+$$
+f(n-1) = \frac{1}{n-1}(1.0+\sum_{i=2}^{n-2} f(n-i))
+$$
+
+In the above recursive formula, there are $n-3$ values of $i$, and the above recursive formula only holds when $n-3 \ge 0$ i.e., $n \ge 3$.
+
+When $n \ge 3$, the above two recursive formulas can be written as follows:
+
+$$
+\begin{aligned}
+n \times f(n) &= 1.0+\sum_{i=2}^{n-1} f(n-i+1) \\
+(n-1) \times f(n-1) &= 1.0+\sum_{i=2}^{n-2} f(n-i)
+\end{aligned}
+$$
+
+Subtract the above two formulas:
+
+$$
+\begin{aligned}
+&~~~~~ n \times f(n) - (n-1) \times f(n-1) \\
+&= (1.0+\sum_{i=2}^{n-1} f(n-i+1)) - (1.0+\sum_{i=2}^{n-2} f(n-i)) \\
+&= \sum_{i=2}^{n-1} f(n-i+1) - \sum_{i=2}^{n-2} f(n-i) \\
+&= f(2)+f(3)+...+f(n-1) - (f(2)+f(3)+...+f(n-2)) \\
+&= f(n-1)
+\end{aligned}
+$$
+
+After simplification, we get the simplified recursive formula:
+
+$$
+\begin{aligned}
+n \times f(n) &= n \times f(n-1) \\
+f(n) &= f(n-1)
+\end{aligned}
+$$
+
+Since we know that $f(1)=1$ and $f(2)=0.5$, therefore when $n \ge 3$, according to $f(n) = f(n-1)$, we know that for any positive integer $n$, $f(n)=0.5$. And since $f(2)=0.5$, therefore when $n \ge 2$, for any positive integer $n$, $f(n)=0.5$.
+
+From this, we can get the result of $f(n)$:
+
+$$
+f(n) = \begin{cases}
+1.0, & n = 1 \\
+0.5, & n \ge 2
+\end{cases}
+$$
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1228.Missing Number In Arithmetic Progression/README.md

@@ -51,7 +51,7 @@
 
 因此，缺失的数为 $\frac{n + 1}{2}(a_1 + a_n) - \sum_{i = 0}^n a_i$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1200-1299/1228.Missing Number In Arithmetic Progression/README_EN.md

@@ -37,6 +37,16 @@
 
 ## Solutions
 
+**Solution 1: Arithmetic Series Sum Formula**
+
+The sum formula for an arithmetic series is $\frac{n(a_1 + a_n)}{2}$, where $n$ is the number of terms in the arithmetic series, $a_1$ is the first term of the arithmetic series, and $a_n$ is the last term of the arithmetic series.
+
+Since the array given in the problem is an arithmetic series and is missing a number, the number of terms in the array is $n + 1$, the first term is $a_1$, and the last term is $a_n$, so the sum of the array is $\frac{n + 1}{2}(a_1 + a_n)$.
+
+Therefore, the missing number is $\frac{n + 1}{2}(a_1 + a_n) - \sum_{i = 0}^n a_i$.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1229.Meeting Scheduler/README_EN.md

@@ -41,6 +41,12 @@
 
 ## Solutions
 
+**Solution 1: Sorting + Two Pointers**
+
+We can sort the free time of the two people separately, then use two pointers to traverse the two arrays, find the intersection of the free time periods of the two people, and if the length of the intersection is greater than or equal to `duration`, then return the start time of the intersection and the start time plus `duration`.
+
+The time complexity is $O(m \times \log m + n \times \log n)$, and the space complexity is $O(\log m + \log n)$. Where $m$ and $n$ are the lengths of the two arrays respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1231.Divide Chocolate/README_EN.md

@@ -47,6 +47,16 @@
 
 ## Solutions
 
+**Solution 1: Binary Search + Greedy**
+
+We notice that if we can eat a piece of chocolate with sweetness $x$, then we can also eat all chocolates with sweetness less than or equal to $x$. This shows monotonicity, therefore, we can use binary search to find the maximum $x$ that satisfies the condition.
+
+We define the left boundary of the binary search as $l=0$, and the right boundary as $r=\sum_{i=0}^{n-1} sweetness[i]$. Each time, we take the middle value $mid$ of $l$ and $r$, and then determine whether we can eat a piece of chocolate with sweetness $mid$. If we can, then we try to eat a piece of chocolate with greater sweetness, i.e., let $l=mid$; otherwise, we try to eat a piece of chocolate with smaller sweetness, i.e., let $r=mid-1$. After the binary search ends, we return $l$.
+
+The key to the problem is how to determine whether we can eat a piece of chocolate with sweetness $x$. We can use a greedy approach, traverse the array from left to right, accumulate the current sweetness each time, when the accumulated sweetness is greater than or equal to $x$, the chocolate count $cnt$ is increased by $1$, and the accumulated sweetness is reset to zero. Finally, check whether $cnt$ is greater than $k$.
+
+The time complexity is $O(n \times \log \sum_{i=0}^{n-1} sweetness[i])$, and the space complexity is $O(1)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1232.Check If It Is a Straight Line/README.md

@@ -45,7 +45,7 @@
 
 **方法一：数学**
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 表示 `coordinates` 数组的长度。
+时间复杂度 $O(n)$，其中 $n$ 表示 `coordinates` 数组的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1200-1299/1232.Check If It Is a Straight Line/README_EN.md

@@ -39,6 +39,10 @@
 
 ## Solutions
 
+**Solution 1: Mathematics**
+
+The time complexity is $O(n)$, where $n$ is the length of the `coordinates` array. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README_EN.md

@@ -51,6 +51,22 @@
 
 ## Solutions
 
+**Solution 1: Sorting**
+
+First, we sort the array `folder` in lexicographical order, then traverse the array. For the current folder $f$ we are traversing, if its length is greater than or equal to the length of the last folder in the answer array, and its prefix includes the last folder in the answer array plus a `/`, then $f$ is a subfolder of the last folder in the answer array, and we don't need to add it to the answer array. Otherwise, we add $f$ to the answer array.
+
+After the traversal ends, the folders in the answer array are the answer required by the problem.
+
+The time complexity is $O(n \times \log n \times m)$, and the space complexity is $O(m)$. Where $n$ and $m$ are the length of the array `folder` and the maximum length of the strings in the array `folder`, respectively.
+
+**Solution 2: Trie**
+
+We can use a trie to store all the folders in the array `folder`. Each node of the trie contains a `children` field, used to store the child nodes of the current node, and a `fid` field, used to store the index of the folder corresponding to the current node in the array `folder`.
+
+For each folder $f$ in the array `folder`, we first split $f$ into several substrings according to `/`, then start from the root node and add the substrings to the trie in turn. Next, we start from the root node to search the trie. If the `fid` field of the current node is not `-1`, it means that the folder corresponding to the current node is a folder in the answer array. We add it to the answer array and return. Otherwise, we recursively search all child nodes of the current node and finally return the answer array.
+
+The time complexity is $O(n \times m)$, and the space complexity is $O(n \times m)$. Where $n$ and $m$ are the length of the array `folder` and the maximum length of the strings in the array `folder`, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1234.Replace the Substring for Balanced String/README_EN.md

@@ -47,6 +47,18 @@
 
 ## Solutions
 
+**Solution 1: Counting + Two Pointers**
+
+First, we use a hash table or array `cnt` to count the number of each character in string $s$. If the count of all characters does not exceed $n/4$, then the string $s$ is balanced, and we directly return $0$.
+
+Otherwise, we use two pointers $j$ and $i$ to maintain the left and right boundaries of the window, initially $j = 0$.
+
+Next, we traverse the string $s$ from left to right. Each time we encounter a character, we decrease its count by $1$, then we check whether the current window meets the condition, that is, the count of characters outside the window does not exceed $n/4$. If the condition is met, we update the answer, then move the left boundary of the window to the right until the condition is not met.
+
+Finally, we return the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(C)$. Where $n$ is the length of the string $s$; and $C$ is the size of the character set, in this problem $C = 4$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1200-1299/1235.Maximum Profit in Job Scheduling/README_EN.md

@@ -53,6 +53,45 @@ Profit obtained 150 = 20 + 70 + 60.
 
 ## Solutions
 
+**Solution 1: Memoization Search + Binary Search**
+
+First, we sort the jobs by start time in ascending order, then design a function $dfs(i)$ to represent the maximum profit that can be obtained starting from the $i$-th job. The answer is $dfs(0)$.
+
+The calculation process of function $dfs(i)$ is as follows:
+
+For the $i$-th job, we can choose to do it or not. If we don't do it, the maximum profit is $dfs(i + 1)$; if we do it, we can use binary search to find the first job that starts after the end time of the $i$-th job, denoted as $j$, then the maximum profit is $profit[i] + dfs(j)$. We take the larger of the two. That is:
+
+$$
+dfs(i)=\max(dfs(i+1),profit[i]+dfs(j))
+$$
+
+Where $j$ is the smallest index that satisfies $startTime[j] \ge endTime[i]$.
+
+In this process, we can use memoization search to save the answer of each state to avoid repeated calculations.
+
+The time complexity is $O(n \times \log n)$, where $n$ is the number of jobs.
+
+**Solution 2: Dynamic Programming + Binary Search**
+
+We can also change the memoization search in Solution 1 to dynamic programming.
+
+First, sort the jobs, this time we sort by end time in ascending order, then define $dp[i]$, which represents the maximum profit that can be obtained from the first $i$ jobs. The answer is $dp[n]$. Initialize $dp[0]=0$.
+
+For the $i$-th job, we can choose to do it or not. If we don't do it, the maximum profit is $dp[i]$; if we do it, we can use binary search to find the last job that ends before the start time of the $i$-th job, denoted as $j$, then the maximum profit is $profit[i] + dp[j]$. We take the larger of the two. That is:
+
+$$
+dp[i+1] = \max(dp[i], profit[i] + dp[j])
+$$
+
+Where $j$ is the largest index that satisfies $endTime[j] \leq startTime[i]$.
+
+The time complexity is $O(n \times \log n)$, where $n$ is the number of jobs.
+
+Similar problems:
+
+-   [2008. Maximum Earnings From Taxi](/solution/2000-2099/2008.Maximum%20Earnings%20From%20Taxi/README.md)
+-   [1751. Maximum Number of Events That Can Be Attended II](/solution/1700-1799/1751.Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended%20II/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**