deploy: 7840036

Author: yanglbme

en/lc/1130/index.html

@@ -77612,15 +77612,15 @@ <h3 id="solution-1-memoization-search">Solution 1: Memoization Search</h3>
 <p>In summary, we can get:</p>
 <p>$$
 dfs(i, j) = \begin{cases}
-0, &amp; \text{if } i = j \
-\min_{i \leq k &lt; j} {dfs(i, k) + dfs(k + 1, j) + \max_{i \leq t \leq k} {arr[t]} \max_{k &lt; t \leq j} {arr[t]}}, &amp; \text{if } i &lt; j
+0, &amp; \textit{if } i = j \
+\min_{i \leq k &lt; j} {dfs(i, k) + dfs(k + 1, j) + \max_{i \leq t \leq k} {arr[t]} \max_{k &lt; t \leq j} {arr[t]}}, &amp; \textit{if } i &lt; j
 \end{cases}
 $$</p>
 <p>In the above recursive process, we can use the method of memoization search to avoid repeated calculations. Additionally, we can use an array $g$ to record the maximum value of all leaf nodes in the index range $[i, j]$ of the array $arr$. This allows us to optimize the calculation process of $dfs(i, j)$:</p>
 <p>$$
 dfs(i, j) = \begin{cases}
-0, &amp; \text{if } i = j \
-\min_{i \leq k &lt; j} {dfs(i, k) + dfs(k + 1, j) + g[i][k] \cdot g[k + 1][j]}, &amp; \text{if } i &lt; j
+0, &amp; \textit{if } i = j \
+\min_{i \leq k &lt; j} {dfs(i, k) + dfs(k + 1, j) + g[i][k] \cdot g[k + 1][j]}, &amp; \textit{if } i &lt; j
 \end{cases}
 $$</p>
 <p>Finally, we return $dfs(0, n - 1)$.</p>
@@ -77908,8 +77908,8 @@ <h3 id="solution-2-dynamic-programming">Solution 2: Dynamic Programming</h3>
 <p>Define $f[i][j]$ to represent the minimum possible sum of all non-leaf node values in the index range $[i, j]$ of the array $arr$, and $g[i][j]$ to represent the maximum value of all leaf nodes in the index range $[i, j]$ of the array $arr$. Then, the state transition equation is:</p>
 <p>$$
 f[i][j] = \begin{cases}
-0, &amp; \text{if } i = j \
-\min_{i \leq k &lt; j} {f[i][k] + f[k + 1][j] + g[i][k] \cdot g[k + 1][j]}, &amp; \text{if } i &lt; j
+0, &amp; \textit{if } i = j \
+\min_{i \leq k &lt; j} {f[i][k] + f[k + 1][j] + g[i][k] \cdot g[k + 1][j]}, &amp; \textit{if } i &lt; j
 \end{cases}
 $$</p>
 <p>Finally, we return $f[0][n - 1]$.</p>

en/lc/1143/index.html

@@ -77576,8 +77576,8 @@ <h3 id="solution-1-dynamic-programming">Solution 1: Dynamic Programming</h3>
 <p>$$
 f[i][j] =
 \begin{cases}
-f[i - 1][j - 1] + 1, &amp; \text{if } text1[i - 1] = text2[j - 1] \
-\max(f[i - 1][j], f[i][j - 1]), &amp; \text{if } text1[i - 1] \neq text2[j - 1]
+f[i - 1][j - 1] + 1, &amp; \textit{if } text1[i - 1] = text2[j - 1] \
+\max(f[i - 1][j], f[i][j - 1]), &amp; \textit{if } text1[i - 1] \neq text2[j - 1]
 \end{cases}
 $$</p>
 <p>The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the lengths of $text1$ and $text2$, respectively.</p>

en/lc/1208/index.html

@@ -77916,7 +77916,7 @@ <h3 id="solution-1-prefix-sum-binary-search">Solution 1: Prefix Sum + Binary Sea
 <!-- solution:start -->
 
 <h3 id="solution-2-two-pointers">Solution 2: Two Pointers</h3>
-<p>We can maintain two pointers $l$ and $r$, initially $l = r = 0$; maintain a variable $\text{cost}$, which represents the sum of the absolute values of the ASCII code differences in the index interval $[l,..r]$. In each step, we move $r$ to the right by one position, then update $\text{cost} = \text{cost} + |s[r] - t[r]|$. If $\text{cost} \gt \text{maxCost}$, then we loop to move $l$ to the right by one position, and decrease the value of $\text{cost}$, until $\text{cost} \leq \text{maxCost}$. Then we update the answer, that is, $\text{ans} = \max(\text{ans}, r - l + 1)$.</p>
+<p>We can maintain two pointers $l$ and $r$, initially $l = r = 0$; maintain a variable $\textit{cost}$, which represents the sum of the absolute values of the ASCII code differences in the index interval $[l,..r]$. In each step, we move $r$ to the right by one position, then update $\textit{cost} = \textit{cost} + |s[r] - t[r]|$. If $\textit{cost} \gt \textit{maxCost}$, then we loop to move $l$ to the right by one position, and decrease the value of $\textit{cost}$, until $\textit{cost} \leq \textit{maxCost}$. Then we update the answer, that is, $\textit{ans} = \max(\textit{ans}, r - l + 1)$.</p>
 <p>Finally, return the answer.</p>
 <p>The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:5"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python3</label><label for="__tabbed_2_2">Java</label><label for="__tabbed_2_3">C++</label><label for="__tabbed_2_4">Go</label><label for="__tabbed_2_5">TypeScript</label></div>
@@ -78087,7 +78087,7 @@ <h3 id="solution-2-two-pointers">Solution 2: Two Pointers</h3>
 
 <h3 id="solution-3-another-way-of-using-two-pointers">Solution 3: Another Way of Using Two Pointers</h3>
 <p>In Solution 2, the interval maintained by the two pointers may become shorter or longer. Since the problem only requires the maximum length, we can maintain a monotonically increasing interval.</p>
-<p>Specifically, we use two pointers $l$ and $r$ to point to the left and right endpoints of the interval, initially $l = r = 0$. In each step, we move $r$ to the right by one position, then update $\text{cost} = \text{cost} + |s[r] - t[r]|$. If $\text{cost} \gt \text{maxCost}$, then we move $l$ to the right by one position, and decrease the value of $\text{cost}$.</p>
+<p>Specifically, we use two pointers $l$ and $r$ to point to the left and right endpoints of the interval, initially $l = r = 0$. In each step, we move $r$ to the right by one position, then update $\textit{cost} = \textit{cost} + |s[r] - t[r]|$. If $\textit{cost} \gt \textit{maxCost}$, then we move $l$ to the right by one position, and decrease the value of $\textit{cost}$.</p>
 <p>Finally, return $n - l$.</p>
 <p>The time complexity is $O(n)$, and the space complexity is $O(1)$. Where $n$ is the length of the string $s$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:5"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Python3</label><label for="__tabbed_3_2">Java</label><label for="__tabbed_3_3">C++</label><label for="__tabbed_3_4">Go</label><label for="__tabbed_3_5">TypeScript</label></div>
@@ -78275,14 +78275,14 @@ <h3 id="solution-3-another-way-of-using-two-pointers">Solution 3: Another Way of
 
     <nav>
 
-        <a href="https://github.com/rain84" class="md-author" title="@rain84">
+        <a href="https://github.com/yanglbme" class="md-author" title="@yanglbme">
 
-          <img src="https://avatars.githubusercontent.com/u/1732547?v=4&size=72" alt="rain84">
+          <img src="https://avatars.githubusercontent.com/u/21008209?v=4&size=72" alt="yanglbme">
         </a>
 
-        <a href="https://github.com/yanglbme" class="md-author" title="@yanglbme">
+        <a href="https://github.com/rain84" class="md-author" title="@rain84">
 
-          <img src="https://avatars.githubusercontent.com/u/21008209?v=4&size=72" alt="yanglbme">
+          <img src="https://avatars.githubusercontent.com/u/1732547?v=4&size=72" alt="rain84">
         </a>
 
 

en/lc/1252/index.html

@@ -77595,9 +77595,9 @@ <h2 id="solutions">Solutions</h2>
 <!-- solution:start -->
 
 <h3 id="solution-1-simulation">Solution 1: Simulation</h3>
-<p>We create a matrix $g$ to store the result of operations. For each pair $(r_i, c_i)$ in $\text{indices}$, we add $1$ to all numbers in the $r_i$-th row of the matrix and add $1$ to all elements in the $c_i$-th column.</p>
+<p>We create a matrix $g$ to store the result of operations. For each pair $(r_i, c_i)$ in $\textit{indices}$, we add $1$ to all numbers in the $r_i$-th row of the matrix and add $1$ to all elements in the $c_i$-th column.</p>
 <p>After the simulation ends, we traverse the matrix and count the number of odd numbers.</p>
-<p>The time complexity is $O(k \times (m + n) + m \times n)$, and the space complexity is $O(m \times n)$. Here, $k$ is the length of $\text{indices}$.</p>
+<p>The time complexity is $O(k \times (m + n) + m \times n)$, and the space complexity is $O(m \times n)$. Here, $k$ is the length of $\textit{indices}$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:4"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python3</label><label for="__tabbed_1_2">Java</label><label for="__tabbed_1_3">C++</label><label for="__tabbed_1_4">Go</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -77763,9 +77763,9 @@ <h3 id="solution-1-simulation">Solution 1: Simulation</h3>
 <!-- solution:start -->
 
 <h3 id="solution-2-space-optimization">Solution 2: Space Optimization</h3>
-<p>We can use a row array $\text{row}$ and a column array $\text{col}$ to record the number of times each row and column is incremented. For each pair $(r_i, c_i)$ in $\text{indices}$, we add $1$ to $\text{row}[r_i]$ and $\text{col}[c_i]$ respectively.</p>
-<p>After the operations are completed, the count at position $(i, j)$ can be calculated as $\text{row}[i] + \text{col}[j]$. We traverse the matrix and count the number of odd numbers.</p>
-<p>The time complexity is $O(k + m \times n)$, and the space complexity is $O(m + n)$. Here, $k$ is the length of $\text{indices}$.</p>
+<p>We can use a row array $\textit{row}$ and a column array $\textit{col}$ to record the number of times each row and column is incremented. For each pair $(r_i, c_i)$ in $\textit{indices}$, we add $1$ to $\textit{row}[r_i]$ and $\textit{col}[c_i]$ respectively.</p>
+<p>After the operations are completed, the count at position $(i, j)$ can be calculated as $\textit{row}[i] + \textit{col}[j]$. We traverse the matrix and count the number of odd numbers.</p>
+<p>The time complexity is $O(k + m \times n)$, and the space complexity is $O(m + n)$. Here, $k$ is the length of $\textit{indices}$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:4"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python3</label><label for="__tabbed_2_2">Java</label><label for="__tabbed_2_3">C++</label><label for="__tabbed_2_4">Go</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -77905,9 +77905,9 @@ <h3 id="solution-2-space-optimization">Solution 2: Space Optimization</h3>
 <!-- solution:start -->
 
 <h3 id="solution-3-mathematical-optimization">Solution 3: Mathematical Optimization</h3>
-<p>We notice that a number at position $(i, j)$ in the matrix will be odd only when exactly one of $\text{row}[i]$ and $\text{col}[j]$ is odd and the other is even.</p>
-<p>We count the number of odd numbers in $\text{row}$, denoted as $\text{cnt1}$, and the number of odd numbers in $\text{col}$, denoted as $\text{cnt2}$. Therefore, the final count of odd numbers is $\text{cnt1} \times (n - \text{cnt2}) + \text{cnt2} \times (m - \text{cnt1})$.</p>
-<p>The time complexity is $O(k + m + n)$, and the space complexity is $O(m + n)$. Here, $k$ is the length of $\text{indices}$.</p>
+<p>We notice that a number at position $(i, j)$ in the matrix will be odd only when exactly one of $\textit{row}[i]$ and $\textit{col}[j]$ is odd and the other is even.</p>
+<p>We count the number of odd numbers in $\textit{row}$, denoted as $\textit{cnt1}$, and the number of odd numbers in $\textit{col}$, denoted as $\textit{cnt2}$. Therefore, the final count of odd numbers is $\textit{cnt1} \times (n - \textit{cnt2}) + \textit{cnt2} \times (m - \textit{cnt1})$.</p>
+<p>The time complexity is $O(k + m + n)$, and the space complexity is $O(m + n)$. Here, $k$ is the length of $\textit{indices}$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:4"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">Python3</label><label for="__tabbed_3_2">Java</label><label for="__tabbed_3_3">C++</label><label for="__tabbed_3_4">Go</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">

en/lc/1411/index.html

@@ -77714,9 +77714,9 @@ <h3 id="solution-2-state-compression-dynamic-programming">Solution 2: State Comp
 <p>We notice that the grid only has $3$ columns, so there are at most $3^3=27$ different coloring schemes in a row.</p>
 <p>Therefore, we define $f[i][j]$ to represent the number of schemes in the first $i$ rows, where the coloring state of the $i$th row is $j$. The state $f[i][j]$ is transferred from $f[i - 1][k]$, where $k$ is the coloring state of the $i - 1$th row, and $k$ and $j$ meet the requirement of different colors being adjacent. That is:</p>
 <p>$$
-f[i][j] = \sum_{k \in \text{valid}(j)} f[i - 1][k]
+f[i][j] = \sum_{k \in \textit{valid}(j)} f[i - 1][k]
 $$</p>
-<p>where $\text{valid}(j)$ represents all legal predecessor states of state $j$.</p>
+<p>where $\textit{valid}(j)$ represents all legal predecessor states of state $j$.</p>
 <p>The final answer is the sum of $f[n][j]$, where $j$ is any legal state.</p>
 <p>We notice that $f[i][j]$ is only related to $f[i - 1][k]$, so we can use a rolling array to optimize the space complexity.</p>
 <p>The time complexity is $O((m + n) \times 3^{2m})$, and the space complexity is $O(3^m)$. Here, $m$ and $n$ are the number of rows and columns of the grid, respectively.</p>

en/lc/146/index.html

@@ -77592,7 +77592,7 @@ <h3 id="solution-1-hash-table-doubly-linked-list">Solution 1: Hash Table + Doubl
 </ul>
 <p>When accessing a node, if the node exists, we delete it from its original position and reinsert it at the head of the list. This ensures that the node stored at the tail of the list is the least recently used node. When the number of nodes exceeds the maximum cache space, we eliminate the node at the tail of the list.</p>
 <p>When inserting a node, if the node exists, we delete it from its original position and reinsert it at the head of the list. If it does not exist, we first check if the cache is full. If it is full, we delete the node at the tail of the list and insert the new node at the head of the list.</p>
-<p>The time complexity is $O(1)$, and the space complexity is $O(\text{capacity})$.</p>
+<p>The time complexity is $O(1)$, and the space complexity is $O(\textit{capacity})$.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:7"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python3</label><label for="__tabbed_1_2">Java</label><label for="__tabbed_1_3">C++</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">TypeScript</label><label for="__tabbed_1_6">Rust</label><label for="__tabbed_1_7">C#</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">