feat: add solutions to lc problems: No.2535~2538

* No.2535.Difference Between Element Sum and Digit Sum of an Array
* No.2536.Increment Submatrices by One
* No.2537.Count the Number of Good Subarrays
* No.2538.Difference Between Maximum and Minimum Price Sum

Author: yanglbme

solution/1400-1499/1443.Minimum Time to Collect All Apples in a Tree/README_EN.md

@@ -40,7 +40,6 @@
 	<li><code>edges.length == n - 1</code></li>
 	<li><code>edges[i].length == 2</code></li>
 	<li><code>0 &lt;= a<sub>i</sub> &lt; b<sub>i</sub> &lt;= n - 1</code></li>
-	<li><code>from<sub>i</sub> &lt; to<sub>i</sub></code></li>
 	<li><code>hasApple.length == n</code></li>
 </ul>
 

solution/1800-1899/1813.Sentence Similarity III/README.md

@@ -57,7 +57,7 @@
 
 **方法一：双指针**
 
-我们将两个句子分别用空格分割成单词数组 `words1` 和 `words2`，假设 `words1` 和 `words2` 的长度分别为 $m$ 和 $n$，不妨设 $m \geq n$。
+我们将两个句子按照空格分割成两个单词数组 `words1` 和 `words2`，假设 `words1` 和 `words2` 的长度分别为 $m$ 和 $n$，不妨设 $m \geq n$。
 
 我们使用双指针 $i$ 和 $j$，初始时 $i = j = 0$。接下来，我们循环判断 `words1[i]` 是否等于 `words2[i]`，是则指针 $i$ 继续右移；然后我们循环判断 `words1[m - 1 - j]` 是否等于 `words2[n - 1 - j]`，是则指针 $j$ 继续右移。
 
@@ -109,7 +109,7 @@ class Solution {
         while (j < n && words1[m - 1 - j].equals(words2[n - 1 - j])) {
             ++j;
         }
-        return i == n || j == n || i + j >= n;
+        return i + j >= n;
     }
 }
 ```

solution/1800-1899/1813.Sentence Similarity III/README_EN.md

@@ -86,7 +86,7 @@ class Solution {
         while (j < n && words1[m - 1 - j].equals(words2[n - 1 - j])) {
             ++j;
         }
-        return i == n || j == n || i + j >= n;
+        return i + j >= n;
     }
 }
 ```

solution/1800-1899/1813.Sentence Similarity III/Solution.java

@@ -15,6 +15,6 @@ public boolean areSentencesSimilar(String sentence1, String sentence2) {
         while (j < n && words1[m - 1 - j].equals(words2[n - 1 - j])) {
             ++j;
         }
-        return i == n || j == n || i + j >= n;
+        return i + j >= n;
     }
 }

solution/2200-2299/2296.Design a Text Editor/README_EN.md

@@ -124,17 +124,17 @@ class TextEditor {
     public TextEditor() {
 
     }
-    
+
     public void addText(String text) {
         left.append(text);
     }
-    
+
     public int deleteText(int k) {
         k = Math.min(k, left.length());
         left.setLength(left.length() - k);
         return k;
     }
-    
+
     public String cursorLeft(int k) {
         k = Math.min(k, left.length());
         for (int i = 0; i < k; ++i) {
@@ -143,7 +143,7 @@ class TextEditor {
         }
         return left.substring(Math.max(left.length() - 10, 0));
     }
-    
+
     public String cursorRight(int k) {
         k = Math.min(k, right.length());
         for (int i = 0; i < k; ++i) {

solution/2500-2599/2534.Time Taken to Cross the Door/README.md

@@ -0,0 +1,108 @@
+# [2534. 通过门的时间](https://leetcode.cn/problems/time-taken-to-cross-the-door)
+
+[English Version](/solution/2500-2599/2534.Time%20Taken%20to%20Cross%20the%20Door/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p><code>n</code> 个人，按从 <code>0</code> 到 <code>n - 1</code> 编号。现在有一扇门，每个人只能通过门进入或离开一次，耗时一秒。</p>
+
+<p>给你一个 <strong>非递减顺序</strong> 排列的整数数组 <code>arrival</code> ，数组长度为 <code>n</code> ，其中 <code>arrival[i]</code> 是第 <code>i</code> 个人到达门前的时间。另给你一个长度为 <code>n</code> 的数组 <code>state</code> ，其中 <code>state[i]</code> 是 <code>0</code> 则表示第 <code>i</code> 个人希望进入这扇门，是 <code>1</code> 则表示 TA 想要离开这扇门。</p>
+
+<p>如果 <strong>同时</strong> 有两个或更多人想要使用这扇门，则必须遵循以下规则：</p>
+
+<ul>
+	<li>如果前一秒 <strong>没有</strong> 使用门，那么想要 <strong>离开</strong> 的人会先离开。</li>
+	<li>如果前一秒使用门 <strong>进入</strong> ，那么想要 <strong>进入</strong> 的人会先进入。</li>
+	<li>如果前一秒使用门 <strong>离开</strong> ，那么想要 <strong>离开</strong> 的人会先离开。</li>
+	<li>如果多个人都想朝同一方向走（都进入或都离开），编号最小的人会先通过门。</li>
+</ul>
+
+<p>返回一个长度为 <code>n</code> 的数组<em> </em><code>answer</code><em> </em>，其中<em> </em><code>answer[i]</code><em> </em>是第 <code>i</code> 个人通过门的时刻（秒）。</p>
+<strong>注意：</strong>
+
+<ul>
+	<li>每秒只有一个人可以通过门。</li>
+	<li>为遵循上述规则，一个人可以在到达门附近后等待，而不通过门进入或离开。</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>arrival = [0,1,1,2,4], state = [0,1,0,0,1]
+<strong>输出：</strong>[0,3,1,2,4]
+<strong>解释：</strong>每秒发生的情况如下：
+- t = 0 ：第 0 个人是唯一一个想要进入的人，所以 TA 可以直接进入。
+- t = 1 ：第 1 个人想要离开，第 2 个人想要进入。因为前一秒有人使用门进入，所以第 2 个人先进入。
+- t = 2 ：第 1 个人还是想要离开，第 3 个人想要进入。因为前一秒有人使用门进入，所以第 3 个人先进入。
+- t = 3 ：第 1 个人是唯一一个想要离开的人，所以 TA 可以直接离开。
+- t = 4 ：第 4 个人是唯一一个想要进入的人，所以 TA 可以直接离开。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>arrival = [0,0,0], state = [1,0,1]
+<strong>输出：</strong>[0,2,1]
+<strong>解释：</strong>每秒发生的情况如下：
+- t = 0 ：第 1 个人想要进入，但是第 0 个人和第 2 个人都想要离开。因为前一秒没有使用门，所以想要离开的人会先离开。又因为第 0 个人的编号更小，所以 TA 先离开。
+- t = 1 ：第 1 个人想要进入，第 2 个人想要离开。因为前一秒有人使用门离开，所以第 2 个人先离开。
+- t = 2 ：第 1 个人是唯一一个想要进入的人，所以 TA 可以直接进入。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == arrival.length == state.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= arrival[i] &lt;= n</code></li>
+	<li><code>arrival</code> 按 <strong>非递减顺序</strong> 排列</li>
+	<li><code>state[i]</code> 为 <code>0</code> 或 <code>1</code></li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->

solution/2500-2599/2534.Time Taken to Cross the Door/README_EN.md

@@ -0,0 +1,99 @@
+# [2534. Time Taken to Cross the Door](https://leetcode.com/problems/time-taken-to-cross-the-door)
+
+[中文文档](/solution/2500-2599/2534.Time%20Taken%20to%20Cross%20the%20Door/README.md)
+
+## Description
+
+<p>There are <code>n</code> persons numbered from <code>0</code> to <code>n - 1</code> and a door. Each person can enter or exit through the door once, taking one second.</p>
+
+<p>You are given a <strong>non-decreasing</strong> integer array <code>arrival</code> of size <code>n</code>, where <code>arrival[i]</code> is the arrival time of the <code>i<sup>th</sup></code> person at the door. You are also given an array <code>state</code> of size <code>n</code>, where <code>state[i]</code> is <code>0</code> if person <code>i</code> wants to enter through the door or <code>1</code> if they want to exit through the door.</p>
+
+<p>If two or more persons want to use the door at the <strong>same</strong> time, they follow the following rules:</p>
+
+<ul>
+	<li>If the door was <strong>not</strong> used in the previous second, then the person who wants to <strong>exit</strong> goes first.</li>
+	<li>If the door was used in the previous second for <strong>entering</strong>, the person who wants to enter goes first.</li>
+	<li>If the door was used in the previous second for <strong>exiting</strong>, the person who wants to <strong>exit</strong> goes first.</li>
+	<li>If multiple persons want to go in the same direction, the person with the <strong>smallest</strong> index goes first.</li>
+</ul>
+
+<p>Return <em>an array </em><code>answer</code><em> of size </em><code>n</code><em> where </em><code>answer[i]</code><em> is the second at which the </em><code>i<sup>th</sup></code><em> person crosses the door</em>.</p>
+
+<p><strong>Note</strong> that:</p>
+
+<ul>
+	<li>Only one person can cross the door at each second.</li>
+	<li>A person may arrive at the door and wait without entering or exiting to follow the mentioned rules.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> arrival = [0,1,1,2,4], state = [0,1,0,0,1]
+<strong>Output:</strong> [0,3,1,2,4]
+<strong>Explanation:</strong> At each second we have the following:
+- At t = 0: Person 0 is the only one who wants to enter, so they just enter through the door.
+- At t = 1: Person 1 wants to exit, and person 2 wants to enter. Since the door was used the previous second for entering, person 2 enters.
+- At t = 2: Person 1 still wants to exit, and person 3 wants to enter. Since the door was used the previous second for entering, person 3 enters.
+- At t = 3: Person 1 is the only one who wants to exit, so they just exit through the door.
+- At t = 4: Person 4 is the only one who wants to exit, so they just exit through the door.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> arrival = [0,0,0], state = [1,0,1]
+<strong>Output:</strong> [0,2,1]
+<strong>Explanation:</strong> At each second we have the following:
+- At t = 0: Person 1 wants to enter while persons 0 and 2 want to exit. Since the door was not used in the previous second, the persons who want to exit get to go first. Since person 0 has a smaller index, they exit first.
+- At t = 1: Person 1 wants to enter, and person 2 wants to exit. Since the door was used in the previous second for exiting, person 2 exits.
+- At t = 2: Person 1 is the only one who wants to enter, so they just enter through the door.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == arrival.length == state.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= arrival[i] &lt;= n</code></li>
+	<li><code>arrival</code> is sorted in <strong>non-decreasing</strong> order.</li>
+	<li><code>state[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+
+## Solutions
+
+<!-- tabs:start -->
+
+### **Python3**
+
+```python
+
+```
+
+### **Java**
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->