1190. 反转每对括号间的子串LeetCode

1190. 反转每对括号间的子串

• 用栈去模拟
  时间复杂度：$O(n^2)$

import java.util.*;

class Solution {
    public String reverseParentheses(String s) {
        StringBuilder stringBuilder = new StringBuilder();
        Stack<Character> stack = new Stack<>();
        char[] cs = s.toCharArray();
        for (char c : cs) {
            if (c == ')') {
                List<Character> buffer = new ArrayList<>();
                while (stack.peek() != '(') {
                    buffer.add(stack.pop());
                }
                stack.pop();
                stack.addAll(buffer);
            } else {
                stack.push(c);
            }
        }
        while (!stack.isEmpty()) {
            stringBuilder.append(stack.pop());
        }
        return stringBuilder.reverse().toString();
    }
}

• 官方的奇妙的做法
  很形象，但是自己想不到。。。

时间复杂度：$O(n)$
之所以时间复杂度减少了，是因为在上面的方法中是通过出栈操作去找左括号的，而在这里，通过预处理括号对，无需暴力寻找匹配。

class Solution {
public:
    string reverseParentheses(string s) {
        int n = s.size();
        string ans;
        vector<int> pair(n);
        stack<int> st;
        for(int i = 0; i < n; i++) {
            if(s[i] == '(') {
                st.push(i);       
            } else if (s[i] == ')'){
                int j = st.top();
                st.pop();
                pair[i] = j;
                pair[j] = i;
            }
        }
        // 很形象的做法，左右括号就像是传送门一样
        int step = 1, idx = 0;
        while(idx < n) {
            if(s[idx] == '(' || s[idx] ==')') {
                idx = pair[idx];
                step = -step;
            } else {
                ans += s[idx];
            }
            idx += step;
        }
        return ans;
    }
};