1190. Reverse Substrings Between Each Pair of Parentheses

Description

You are given a string s that consists of lower case English letters and brackets.

Reverse the strings in each pair of matching parentheses, starting from the innermost one.

Your result should not contain any brackets.

Example 1:

Input: s = "(abcd)"
Output: "dcba"

Example 2:

Input: s = "(u(love)i)"
Output: "iloveu"
Explanation: The substring "love" is reversed first, then the whole string is reversed.

Example 3:

Input: s = "(ed(et(oc))el)"
Output: "leetcode"
Explanation: First, we reverse the substring "oc", then "etco", and finally, the whole string.

Constraints:

1 <= s.length <= 2000
s only contains lower case English characters and parentheses.
It is guaranteed that all parentheses are balanced.

Solutions

Solution 1: Simulation

Thinking

Parentheses reverse inside-out. A stack pops until the matching '(' on ')' and pushes the characters back reversed. Each layer may move \(O(n)\) characters, worst-case \(O(n^2)\), which is acceptable for \(n\le 2000\).

We can directly use a stack to simulate the reversal process.

The time complexity is \(O(n^2)\), and the space complexity is \(O(n)\), where \(n\) is the length of the string \(s\).

Python3JavaC++GoTypeScriptJavaScript

class Solution:
    def reverseParentheses(self, s: str) -> str:
        stk = []
        for c in s:
            if c == ")":
                t = []
                while stk[-1] != "(":
                    t.append(stk.pop())
                stk.pop()
                stk.extend(t)
            else:
                stk.append(c)
        return "".join(stk)

class Solution {
    public String reverseParentheses(String s) {
        StringBuilder stk = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (c == ')') {
                StringBuilder t = new StringBuilder();
                while (stk.charAt(stk.length() - 1) != '(') {
                    t.append(stk.charAt(stk.length() - 1));
                    stk.deleteCharAt(stk.length() - 1);
                }
                stk.deleteCharAt(stk.length() - 1);
                stk.append(t);
            } else {
                stk.append(c);
            }
        }
        return stk.toString();
    }
}

class Solution {
public:
    string reverseParentheses(string s) {
        string stk;
        for (char& c : s) {
            if (c == ')') {
                string t;
                while (stk.back() != '(') {
                    t.push_back(stk.back());
                    stk.pop_back();
                }
                stk.pop_back();
                stk += t;
            } else {
                stk.push_back(c);
            }
        }
        return stk;
    }
};

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)
}

function reverseParentheses(s: string): string {
    const stk: string[] = [];
    for (const c of s) {
        if (c === ')') {
            const t: string[] = [];
            while (stk.at(-1)! !== '(') {
                t.push(stk.pop()!);
            }
            stk.pop();
            stk.push(...t);
        } else {
            stk.push(c);
        }
    }
    return stk.join('');
}

/**
 * @param {string} s
 * @return {string}
 */
var reverseParentheses = function (s) {
    const stk = [];
    for (const c of s) {
        if (c === ')') {
            const t = [];
            while (stk.at(-1) !== '(') {
                t.push(stk.pop());
            }
            stk.pop();
            stk.push(...t);
        } else {
            stk.push(c);
        }
    }
    return stk.join('');
};

Solution 2: Brain Teaser

Thinking

Method 1 reshuffles characters on every pair. A pair is a jump to the match plus a direction flip: precompute counterparts, and on a parenthesis jump and negate the step, writing only letters. One linear pass suffices.

We observe that, when traversing the string, each time we encounter ( or ), we jump to the corresponding ) or ( and then reverse the direction of traversal to continue.

Therefore, we can use an array \(d\) to record the position of the corresponding other bracket for each ( or ), i.e., \(d[i]\) represents the position of the other bracket corresponding to the bracket at position \(i\). We can directly use a stack to compute the array \(d\).

Then, we traverse the string from left to right. When encountering ( or ), we jump to the corresponding position according to the array \(d\), then reverse the direction and continue traversing until the entire string is traversed.

The time complexity is \(O(n)\), and the space complexity is \(O(n)\), where \(n\) is the length of the string \(s\).