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

给出一个字符串 s（仅含有小写英文字母和括号）。

请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。

注意，您的结果中不应包含任何括号。

示例 1：

输入：s = "(abcd)"

输出："dcba"

示例 2：

输入：s = "(u(love)i)"

输出："iloveu"

解释：先反转子字符串 "love" ，然后反转整个字符串。

示例 3：

输入：s = "(ed(et(oc))el)"

输出："leetcode"

解释：先反转子字符串 "oc" ，接着反转 "etco" ，然后反转整个字符串。

提示：

1 <= s.length <= 2000

s 中只有小写英文字母和括号

题目测试用例确保所有括号都是成对出现的

法一：遇到括号后，将其中内容反转，然后拼接到上一层：

cpp 复制代码

class Solution {
public:
    string reverseParentheses(string s) {
        vector<string> stk;
        string str;
        for (int i = 0; i < s.size(); ++i) {
            if (s[i] == '(') {
                stk.push_back(str);
                // 每次遇到左括号，将str保存到栈顶，然后清空str，用来保存本层括号内即将用来反转的内容
                str = "";
            } else if (s[i] == ')') {
                // 遇到右括号时，说明本层括号内容已遍历完，需要反转括号内内容
                reverse(str.begin(), str.end());
                // 反转完成后，将其拼接到已处理的内容之后
                str = stk.back() + str;
                stk.pop_back();
            } else {
                str += s[i];
            }
        }

        return str;
    }
};

如果s的长度为n，则此算法时间复杂度为O(n2^22)，空间复杂度为O(n)。

法二：我们可以记录下来每对括号的起始和终止位置，如果遇到了括号，就跳转到括号的另一半位置，向相反方向遍历：

cpp 复制代码

class Solution {
public:
    string reverseParentheses(string s) {
        unordered_map<int, int> pairs;
        vector<int> stk;
        // 预处理，记录下每对括号的起始和终止位置
        for (int i = 0; i < s.size(); ++i) {
            if (s[i] == '(') {
                stk.push_back(i);
            } else if (s[i] == ')') {
                pairs[stk.back()] = i;
                pairs[i] = stk.back();

                stk.pop_back();
            }
        }

        string ans;
        int idx = 0;
        int direction = 1;
        while (idx < s.size()) {
            // 遇到括号
            if (s[idx] == '(' || s[idx] == ')') {
                // 跳转到括号的另一半，并改变遍历方向
                idx = pairs[idx];
                direction = -direction;
            } else {
                ans += s[idx];
            }

            idx += direction;
        }

        return ans;
    }
};

如果s的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。