feat: add solutions to lc problems

* No.0777.Swap Adjacent in LR String
* No.2337.Move Pieces to Obtain a String

solution/0600-0699/0647.Palindromic Substrings/README.md

@@ -50,7 +50,7 @@
 
 **方法二：Manacher 算法**
 
-在 Manacher 算法的计算过程中，$p[i]-1$ 表示以第 $i$ 位为中心的最大回文长度，以第 $i$ 位为中心的回文串数量为 $\left \lceil \frac{p[i]-1}{2}  \right \rceil$。
+在 Manacher 算法的计算过程中，用 $p[i]-1$ 表示以第 $i$ 位为中心的最大回文长度，以第 $i$ 位为中心的回文串数量为 $\left \lceil \frac{p[i]-1}{2}  \right \rceil$。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串 `s` 的长度。
 

solution/0600-0699/0649.Dota2 Senate/README.md

@@ -13,7 +13,6 @@
 <ol>
 	<li>
 	<p><code>禁止一名参议员的权利</code>：</p>
-
     <p>参议员可以让另一位参议员在这一轮和随后的几轮中丧失<strong>所有的权利</strong>。</p>
     </li>
     <li>

solution/0600-0699/0652.Find Duplicate Subtrees/README.md

@@ -51,7 +51,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-后序遍历，序列化每个子树，用哈希表判断序列化的字符串出现次数是否等于 2，若是，说明这棵子树重复。
+**方法一：后序遍历**
+
+后序遍历，序列化每个子树，用哈希表判断序列化的字符串出现次数是否等于 `2`，若是，说明这棵子树重复。
 
 <!-- tabs:start -->
 

solution/0600-0699/0653.Two Sum IV - Input is a BST/README.md

@@ -39,8 +39,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：哈希表**
+
 用哈希表记录访问过的节点。
 
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/0600-0699/0655.Print Binary Tree/README.md

@@ -58,19 +58,19 @@
 
 **方法一：两次 DFS**
 
-先通过 $DFS$ 求二叉树的高度 $h$（高度从 $0$ 开始），然后根据 $h$ 求得结果列表的行数 $m$ 和列数 $n$。
+先通过 `DFS` 求二叉树的高度 $h$（高度从 `0` 开始），然后根据 $h$ 求得结果列表的行数 $m$ 和列数 $n$。
 
-根据 $m$, $n$ 初始化结果列表 $ans$，然后 $DFS$ 遍历二叉树，依次在每个位置填入二叉树节点值（字符串形式）即可。
+根据 $m$, $n$ 初始化结果列表 `ans`，然后 `DFS` 遍历二叉树，依次在每个位置填入二叉树节点值（字符串形式）即可。
 
-时间复杂度 $O(h \times 2^h)$，空间复杂度 $O(h)$。其中 $h$ 是二叉树的高度。忽略结果返回值的空间消耗。
+时间复杂度 $O(h\times 2^h)$，空间复杂度 $O(h)$。其中 $h$ 是二叉树的高度。忽略结果返回值的空间消耗。
 
 **方法二：两次 BFS**
 
-方法一中，我们是通过 $DFS$ 来求二叉树的高度，我们也可以改成 $BFS$ 的方式，逐层往下扩展，那么扩展的层数就是二叉树的高度。
+方法一中，我们是通过 `DFS` 来求二叉树的高度，我们也可以改成 `BFS` 的方式，逐层往下扩展，那么扩展的层数就是二叉树的高度。
 
-同样，我们初始化结果列表 $ans$，然后 $BFS$ 遍历二叉树，依次在每个位置填入二叉树节点值（字符串形式）即可。
+同样，我们初始化结果列表 `ans`，然后 `BFS` 遍历二叉树，依次在每个位置填入二叉树节点值（字符串形式）即可。
 
-时间复杂度 $O(h \times 2^h)$，空间复杂度 $O(h)$。其中 $h$ 是二叉树的高度。忽略结果返回值的空间消耗。
+时间复杂度 $O(h\times 2^h)$，空间复杂度 $O(h)$。其中 $h$ 是二叉树的高度。忽略结果返回值的空间消耗。
 
 <!-- tabs:start -->
 

solution/0700-0799/0777.Swap Adjacent in LR String/README.md

@@ -36,22 +36,130 @@ XRLXXRRLX
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：双指针**
+
+替换操作可以实际上是将 `L` 往左移动（`L` 左边为 `X` 时才能移动），`R` 往右移动（`R` 右边是 `X` 时才能移动），但 `L` 无法穿过 `R`。所以，如果去掉 `start` 和 `end` 中的所有 `X`，剩下的字符应该时相同的，否则返回 `false`。
+
+双指针遍历 `start` 和 `end`：
+
+-   如果当前字符为 `L` 且 $i\lt j$，那么这个 `L` 无法向右移动，返回 `false`；
+-   如果当前字符为 `R` 且 $i\gt j$，那么这个 `R` 无法向左移动，返回 `false`。
+
+如果双指针均遍历到末尾，返回 `true`。
+
+时间复杂度 $O(n)$，其中 $n$ 表示字符串 `start` 或 `end` 的长度。
+
+相似题目：[2337. 移动片段得到字符串](/solution/2300-2399/2337.Move%20Pieces%20to%20Obtain%20a%20String/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def canTransform(self, start: str, end: str) -> bool:
+        n = len(start)
+        i = j = 0
+        while 1:
+            while i < n and start[i] == 'X':
+                i += 1
+            while j < n and end[j] == 'X':
+                j += 1
+            if i >= n and j >= n:
+                return True
+            if i >= n or j >= n or start[i] != end[j]:
+                return False
+            if start[i] == 'L' and i < j:
+                return False
+            if start[i] == 'R' and i > j:
+                return False
+            i, j = i + 1, j + 1
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean canTransform(String start, String end) {
+        int n = start.length();
+        int i = 0, j = 0;
+        while (true) {
+            while (i < n && start.charAt(i) == 'X') {
+                ++i;
+            }
+            while (j < n && end.charAt(j) == 'X') {
+                ++j;
+            }
+            if (i == n && j == n) {
+                return true;
+            }
+            if (i == n || j == n || start.charAt(i) != end.charAt(j)) {
+                return false;
+            }
+            if (start.charAt(i) == 'L' && i < j || start.charAt(i) == 'R' && i > j) {
+                return false;
+            }
+            ++i;
+            ++j;
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool canTransform(string start, string end) {
+        int n = start.size();
+        int i = 0, j = 0;
+        while (true) {
+            while (i < n && start[i] == 'X') ++i;
+            while (j < n && end[j] == 'X') ++j;
+            if (i == n && j == n) return true;
+            if (i == n || j == n || start[i] != end[j]) return false;
+            if (start[i] == 'L' && i < j) return false;
+            if (start[i] == 'R' && i > j) return false;
+            ++i;
+            ++j;
+        }
+    }
+};
+```
 
+### **Go**
+
+```go
+func canTransform(start string, end string) bool {
+	n := len(start)
+	i, j := 0, 0
+	for {
+		for i < n && start[i] == 'X' {
+			i++
+		}
+		for j < n && end[j] == 'X' {
+			j++
+		}
+		if i == n && j == n {
+			return true
+		}
+		if i == n || j == n || start[i] != end[j] {
+			return false
+		}
+		if start[i] == 'L' && i < j {
+			return false
+		}
+		if start[i] == 'R' && i > j {
+			return false
+		}
+		i, j = i+1, j+1
+	}
+}
 ```
 
 ### **...**

solution/0700-0799/0777.Swap Adjacent in LR String/README_EN.md

@@ -43,13 +43,106 @@ XRLXXRRLX
 ### **Python3**
 
 ```python
-
+class Solution:
+    def canTransform(self, start: str, end: str) -> bool:
+        n = len(start)
+        i = j = 0
+        while 1:
+            while i < n and start[i] == 'X':
+                i += 1
+            while j < n and end[j] == 'X':
+                j += 1
+            if i >= n and j >= n:
+                return True
+            if i >= n or j >= n or start[i] != end[j]:
+                return False
+            if start[i] == 'L' and i < j:
+                return False
+            if start[i] == 'R' and i > j:
+                return False
+            i, j = i + 1, j + 1
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean canTransform(String start, String end) {
+        int n = start.length();
+        int i = 0, j = 0;
+        while (true) {
+            while (i < n && start.charAt(i) == 'X') {
+                ++i;
+            }
+            while (j < n && end.charAt(j) == 'X') {
+                ++j;
+            }
+            if (i == n && j == n) {
+                return true;
+            }
+            if (i == n || j == n || start.charAt(i) != end.charAt(j)) {
+                return false;
+            }
+            if (start.charAt(i) == 'L' && i < j || start.charAt(i) == 'R' && i > j) {
+                return false;
+            }
+            ++i;
+            ++j;
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool canTransform(string start, string end) {
+        int n = start.size();
+        int i = 0, j = 0;
+        while (true) {
+            while (i < n && start[i] == 'X') ++i;
+            while (j < n && end[j] == 'X') ++j;
+            if (i == n && j == n) return true;
+            if (i == n || j == n || start[i] != end[j]) return false;
+            if (start[i] == 'L' && i < j) return false;
+            if (start[i] == 'R' && i > j) return false;
+            ++i;
+            ++j;
+        }
+    }
+};
+```
 
+### **Go**
+
+```go
+func canTransform(start string, end string) bool {
+	n := len(start)
+	i, j := 0, 0
+	for {
+		for i < n && start[i] == 'X' {
+			i++
+		}
+		for j < n && end[j] == 'X' {
+			j++
+		}
+		if i == n && j == n {
+			return true
+		}
+		if i == n || j == n || start[i] != end[j] {
+			return false
+		}
+		if start[i] == 'L' && i < j {
+			return false
+		}
+		if start[i] == 'R' && i > j {
+			return false
+		}
+		i, j = i+1, j+1
+	}
+}
 ```
 
 ### **...**

solution/0700-0799/0777.Swap Adjacent in LR String/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool canTransform(string start, string end) {
+        int n = start.size();
+        int i = 0, j = 0;
+        while (true) {
+            while (i < n && start[i] == 'X') ++i;
+            while (j < n && end[j] == 'X') ++j;
+            if (i == n && j == n) return true;
+            if (i == n || j == n || start[i] != end[j]) return false;
+            if (start[i] == 'L' && i < j) return false;
+            if (start[i] == 'R' && i > j) return false;
+            ++i;
+            ++j;
+        }
+    }
+};

solution/0700-0799/0777.Swap Adjacent in LR String/Solution.go

@@ -0,0 +1,25 @@
+func canTransform(start string, end string) bool {
+	n := len(start)
+	i, j := 0, 0
+	for {
+		for i < n && start[i] == 'X' {
+			i++
+		}
+		for j < n && end[j] == 'X' {
+			j++
+		}
+		if i == n && j == n {
+			return true
+		}
+		if i == n || j == n || start[i] != end[j] {
+			return false
+		}
+		if start[i] == 'L' && i < j {
+			return false
+		}
+		if start[i] == 'R' && i > j {
+			return false
+		}
+		i, j = i+1, j+1
+	}
+}

solution/0700-0799/0777.Swap Adjacent in LR String/Solution.java

@@ -1,20 +1,18 @@
 class Solution {
     public boolean canTransform(String start, String end) {
-        if (start.length() != end.length()) {
-            return false;
-        }
+        int n = start.length();
         int i = 0, j = 0;
         while (true) {
-            while (i < start.length() && start.charAt(i) == 'X') {
+            while (i < n && start.charAt(i) == 'X') {
                 ++i;
             }
-            while (j < end.length() && end.charAt(j) == 'X') {
+            while (j < n && end.charAt(j) == 'X') {
                 ++j;
             }
-            if (i == start.length() && j == start.length()) {
+            if (i == n && j == n) {
                 return true;
             }
-            if (i == start.length() || j == start.length() || start.charAt(i) != end.charAt(j)) {
+            if (i == n || j == n || start.charAt(i) != end.charAt(j)) {
                 return false;
             }
             if (start.charAt(i) == 'L' && i < j || start.charAt(i) == 'R' && i > j) {
@@ -24,4 +22,4 @@ public boolean canTransform(String start, String end) {
             ++j;
         }
     }
-}
+}