feat: add solutions to lc problem: No.1190

No.1190.Reverse Substrings Between Each Pair of Parentheses

Author: yanglbme

solution/1100-1199/1190.Reverse Substrings Between Each Pair of Parentheses/README.md

@@ -56,7 +56,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-用双端队列或者栈，模拟反转过程
+**方法一：模拟**
+
+用双端队列或者栈，模拟反转的过程。
+
+时间复杂度 $O(n^2)$，其中 $n$ 为字符串 $s$ 的长度。
+
+**方法二：脑筋急转弯**
+
+我们观察发现，遍历字符串时，每一次遇到 `(` 或者 `)`，都是跳到对应的 `)` 或者 `(`，然后反转遍历的方向，继续遍历。
+
+因此，我们可以用一个数组 $d$ 来记录每个 `(` 或者 `)` 对应的另一个括号的位置，即 $d[i]$ 表示 $i$ 处的括号对应的另一个括号的位置。直接用栈就可以求出 $d$ 数组。
+
+然后，我们从左到右遍历字符串，遇到 `(` 或者 `)` 时，根据 $d$ 数组跳到对应的位置，然后反转方向，继续遍历，直到遍历完整个字符串。
+
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
@@ -67,17 +81,41 @@
 ```python
 class Solution:
     def reverseParentheses(self, s: str) -> str:
-        stack = []
+        stk = []
         for c in s:
-            if c == ")":
-                tmp = []
-                while stack[-1] != "(":
-                    tmp += stack.pop()
-                stack.pop()
-                stack += tmp
+            if c == ')':
+                t = []
+                while stk[-1] != '(':
+                    t.append(stk.pop())
+                stk.pop()
+                stk.extend(t)
+            else:
+                stk.append(c)
+        return ''.join(stk)
+```
+
+```python
+class Solution:
+    def reverseParentheses(self, s: str) -> str:
+        n = len(s)
+        d = [0] * n
+        stk = []
+        for i, c in enumerate(s):
+            if c == '(':
+                stk.append(i)
+            elif c == ')':
+                j = stk.pop()
+                d[i], d[j] = j, i
+        i, x = 0, 1
+        ans = []
+        while i < n:
+            if s[i] in '()':
+                i = d[i]
+                x = -x
             else:
-                stack.append(c)
-        return "".join(stack)
+                ans.append(s[i])
+            i += x
+        return ''.join(ans)
 ```
 
 ### **Java**
@@ -87,27 +125,140 @@ class Solution:
 ```java
 class Solution {
     public String reverseParentheses(String s) {
-        Deque<Character> deque = new ArrayDeque<>();
-        for (char c : s.toCharArray()) {
+        int n = s.length();
+        int[] d = new int[n];
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            if (s.charAt(i) == '(') {
+                stk.push(i);
+            } else if (s.charAt(i) == ')') {
+                int j = stk.pop();
+                d[i] = j;
+                d[j] = i;
+            }
+        }
+        StringBuilder ans = new StringBuilder();
+        int i = 0, x = 1;
+        while (i < n) {
+            if (s.charAt(i) == '(' || s.charAt(i) == ')') {
+                i = d[i];
+                x = -x;
+            } else {
+                ans.append(s.charAt(i));
+            }
+            i += x;
+        }
+        return ans.toString();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string reverseParentheses(string s) {
+        string stk;
+        for (char& c : s) {
             if (c == ')') {
-                StringBuilder sb = new StringBuilder();
-                while (deque.peekLast() != '(') {
-                    sb.append(deque.pollLast());
-                }
-                deque.pollLast();
-                for (int i = 0, n = sb.length(); i < n; i++) {
-                    deque.offerLast(sb.charAt(i));
+                string t;
+                while (stk.back() != '(') {
+                    t.push_back(stk.back());
+                    stk.pop_back();
                 }
+                stk.pop_back();
+                stk += t;
             } else {
-                deque.offerLast(c);
+                stk.push_back(c);
+            }
+        }
+        return stk;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    string reverseParentheses(string s) {
+        int n = s.size();
+        vector<int> d(n);
+        stack<int> stk;
+        for (int i = 0; i < n; ++i) {
+            if (s[i] == '(') {
+                stk.push(i);
+            } else if (s[i] == ')') {
+                int j = stk.top();
+                stk.pop();
+                d[i] = j;
+                d[j] = i;
             }
         }
-        StringBuilder sb = new StringBuilder();
-        while (!deque.isEmpty()) {
-            sb.append(deque.pollFirst());
+        int i = 0, x = 1;
+        string ans;
+        while (i < n) {
+            if (s[i] == '(' || s[i] == ')') {
+                i = d[i];
+                x = -x;
+            } else {
+                ans.push_back(s[i]);
+            }
+            i += x;
         }
-        return sb.toString();
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func reverseParentheses(s string) string {
+	stk := []byte{}
+	for i := range s {
+		if s[i] == ')' {
+			t := []byte{}
+			for stk[len(stk)-1] != '(' {
+				t = append(t, stk[len(stk)-1])
+				stk = stk[:len(stk)-1]
+			}
+			stk = stk[:len(stk)-1]
+			stk = append(stk, t...)
+		} else {
+			stk = append(stk, s[i])
+		}
+	}
+	return string(stk)
+}
+```
+
+```go
+func reverseParentheses(s string) string {
+	n := len(s)
+	d := make([]int, n)
+	stk := []int{}
+	for i, c := range s {
+		if c == '(' {
+			stk = append(stk, i)
+		} else if c == ')' {
+			j := stk[len(stk)-1]
+			stk = stk[:len(stk)-1]
+			d[i], d[j] = j, i
+		}
+	}
+	ans := []byte{}
+	i, x := 0, 1
+	for i < n {
+		if s[i] == '(' || s[i] == ')' {
+			i = d[i]
+			x = -x
+		} else {
+			ans = append(ans, s[i])
+		}
+		i += x
+	}
+	return string(ans)
 }
 ```
 
@@ -119,33 +270,32 @@ class Solution {
  * @return {string}
  */
 var reverseParentheses = function (s) {
-    let stack = [];
-    let hashMap = {};
     const n = s.length;
-    for (let i = 0; i < n; i++) {
-        let cur = s.charAt(i);
-        if (cur == '(') {
-            stack.push(i);
-        } else if (cur == ')') {
-            let left = stack.pop();
-            hashMap[left] = i;
-            hashMap[i] = left;
+    const d = new Array(n).fill(0);
+    const stk = [];
+    for (let i = 0; i < n; ++i) {
+        if (s[i] == '(') {
+            stk.push(i);
+        } else if (s[i] == ')') {
+            const j = stk.pop();
+            d[i] = j;
+            d[j] = i;
         }
     }
-    let res = [];
     let i = 0;
-    let step = 1; // 1向右，-1向左
-    while (i > -1 && i < n) {
-        let cur = s.charAt(i);
-        if (cur == '(' || cur == ')') {
-            step = -step;
-            i = hashMap[i];
+    let x = 1;
+    const ans = [];
+    while (i < n) {
+        const c = s.charAt(i);
+        if (c == '(' || c == ')') {
+            i = d[i];
+            x = -x;
         } else {
-            res.push(cur);
+            ans.push(c);
         }
-        i += step;
+        i += x;
     }
-    return res.join('');
+    return ans.join('');
 };
 ```