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

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

描述

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

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

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

示例

输入：s = “(ed(et(oc))el)”
输出：“leetcode”
解释：先反转子字符串 “oc” ，接着反转 “etco” ，然后反转整个字符串。

输入：s = “(u(love)i)”
输出：“iloveu”
解释：先反转子字符串 “love” ，然后反转整个字符串。

题解

本题要求按照从括号内到外的顺序进行处理。如字符串 (u(love)i)，首先处理内层括号，变为 (uevoli)，然后处理外层括号，变为 iloveu。

对于括号序列相关的题目，通用的解法是使用递归或栈。

1. 递归

遇到左括号则进入新的递归，处理括号内的内容。

• 时间复杂度：$O(n^2)$，其中 n 为字符串的长度。栈的最大深度为 O(n)，每一层处理的时间复杂度主要为反转的时间复杂度，为 O(n)，因此总时间复杂度为 $O(n^2)$。
• 空间复杂度：$O(n)$，其中 n 为字符串的长度。对于任意时刻，字符串中的任意一个字符至多只被栈中的一个位置包含一次。

class Solution {
    
public:
    int idx = 0;			// 全局变量，不同递归间的遍历索引一样
    string reverseParentheses(string s) {
    
        string ans;									// 当前递归层的字符串
        for(; idx < s.length(); ++idx){
    
            if(s[idx] == '('){
    						// 左括号，新的递归层
                ++idx;
                ans += reverseParentheses(s);		// 字符串拼接，返回的时候idx指向了右括号的位置
            }else if(s[idx] == ')'){
    
                reverse(ans.begin(), ans.end());	// 右括号，反转当前层的字符串
                break;
            }else{
    
                ans.push_back(s[idx]);				// 字母
            }
        }
        return ans;
    }
};

2. 栈 模拟递归

从左到右遍历该字符串，使用字符串 str 记录当前层所遍历到的小写英文字母。对于当前遍历的字符：

• 如果是左括号，将 str 入栈中，并将 str 置为空，进入下一层；
• 如果是右括号，则说明遍历完了当前层，需要将 str 反转，返回给上一层。具体地，将栈顶字符串弹出，然后将反转后的 str 拼接到栈顶字符串末尾，并将结果赋值给 str。
• 如果是小写英文字母，将其加到 str 末尾。

注意到我们仅在遇到右括号时才进行字符串处理，这样可以保证我们是按照从括号内到外的顺序处理字符串。

• 时间复杂度：$O(n^2)$，其中 n 为字符串的长度。栈的最大深度为 O(n)，每一层处理的时间复杂度主要为反转的时间复杂度，为 O(n)，因此总时间复杂度为 $O(n^2)$。
• 空间复杂度：$O(n)$，其中 n 为字符串的长度。对于任意时刻，字符串中的任意一个字符至多只被栈中的一个位置包含一次。
  

class Solution {
    
public:

    string reverseParentheses(string s) {
    
        string str;
        stack<string> strs;
        for(int idx = 0; idx < s.length(); ++idx){
    
            if(s[idx] == '('){
    
                strs.push(str);						// 入栈
                str = "";							// 重置
            }else if(s[idx] == ')'){
    
                reverse(str.begin(), str.end());	// 反转
                str = strs.top() + str;				// 拼接
                strs.pop();
            }else{
    
                str.push_back(s[idx]);
            }
        }
        return str;
    }
};

3. 预处理括号

将括号的反转理解为逆序地遍历括号:

• 第一步，我们向右移动到左括号，此时我们跳跃到该左括号对应的右括号（进入了更深一层）；
• 第二到第三步，我们在括号内部向左移动（完成了更深层的遍历）；
• 第四步，我们向左移动到左括号，此时我们跳跃到该左括号对应的右括号（返回到上一层）；
• 第五步，我们在括号外向右移动（继续遍历）。

那么总结规律就是：

假设我们沿着某个方向移动，此时遇到了括号，那么我们只需要首先跳跃到该括号对应的另一个括号所在处，然后改变移动方向即可。

这个方案同时适用于遍历时进入更深一层，以及完成当前层的遍历后返回到上一层的方案。

在实际代码中，我们需要预处理出每一个括号对应的另一个括号所在的位置，这一部分我们可以使用栈解决。当我们预处理完成后，即可在线性时间内完成遍历，遍历的字符串顺序即为反转后的字符串。

• 时间复杂度：$O(n)$，其中 n 为字符串的长度。预处理出括号的对应关系的序列的时间复杂度为 O(n)，遍历字符串的时间复杂度同样为 O(n)。
• 空间复杂度：$O(n)$，其中 n 为字符串的长度。栈的大小不会超过 n，以及我们需要 O(n) 的空间记录括号的对应关系。

class Solution {
    
public:
    string reverseParentheses(string s) {
    
        string ans;
        int n = s.length();
        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 l = st.top();
                pair[l] = i;
                pair[i] = l;
                st.pop();
            }
        }
        int idx = 0, step = 1;					// step 表示遍历的方向
        while(idx < n){
    
            if(s[idx] == '(' || s[idx] == ')'){
    	// 遇到括号
                idx = pair[idx];				// 索引跳转
                step = -step;					// 遍历方向反转
            }else{
    
                ans.push_back(s[idx]); 			// 加入字符
            }
            idx += step;						// 移动索引
        }
        return ans;
    }
};