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

最新推荐文章于 2022-07-17 19:21:42 发布

Histranger_

最新推荐文章于 2022-07-17 19:21:42 发布

阅读量176

点赞数

分类专栏：我一个滑铲文章标签： leetcode 栈算法

本文链接：https://blog.youkuaiyun.com/Histranger_/article/details/117304888

版权

我一个滑铲专栏收录该内容

32 篇文章

订阅专栏

这篇博客讨论了如何解决1190题——反转每对括号间的子串问题。作者首先提供了两种解决方案，一种是使用栈的传统方法，时间复杂度为O(n^2)，另一种是预处理字符串并优化时间复杂度到O(n)。博主还分享了设备配置，一台具有32GB内存的Dell电脑，适合高效运行虚拟机。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

我的思路

使用栈 , 从前向后遍历，如果遇到 ) 就将栈中字符取出直到栈空或者遇到 ( ，如果遇到非 ) ，那么将其压栈。

AC代码如下：

class Solution {
public:
    string reverseParentheses(string s) {
        stack<char> sta;
        for (auto item : s){
            if (item == ')'){
                string rev = "";
                while (!sta.empty() && sta.top() != '('){
                    rev += sta.top();
                    sta.pop();
                }
                if (!sta.empty()){
                    sta.pop();
                }
                for (auto ch : rev){
                    sta.push(ch);
                }
            }else{
                sta.push(item);
            }
        } 
        string ret = "";
        while (!sta.empty()){
            ret += sta.top();
            sta.pop();
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

复杂度分析：

时间复杂度： $O(n^2)$ ，两层for。
空间复杂度： $O (n)$ ，使用了栈。

时间复杂度优化

我们可以 预处理 字符串 $s$ , 对于 $s$ 中每一对对应的 ( 和 ) ，求出他们的位置。
然后，从前往后遍历 $s$ , 如果遇到 ( 或者 ) 就 调转方向，遇到其他字符加入返回结果中。

AC代码如下：

class Solution {
public:
    string reverseParentheses(string s) {
        int n = s.size();
        vector<int> Pair(n);

        stack<int> sta;
        for (int i = 0; i < n; i ++){
            if (s[i] == '('){
                sta.push(i);
            }else if (s[i] == ')'){
                int j = sta.top();
                Pair[i] = j, Pair[j] = i;
                sta.pop();
            }
        }
        string ret = "";

        int step = 1, index = 0;
        while (index < n){
            if (s[index] == '(' || s[index] == ')'){
                index = Pair[index];
                step = -step;
            }else{
                ret.push_back(s[index]);
            }
            index += step;
        }


        return ret;
    }
};

复杂度分析:

时间复杂度： $O (n)$ ，需要两次遍历字符串，因此，复杂度是 $O (n)$ .
空间复杂度： $O (n)$ ，使用了栈和Pair数组。

2021/5/26 20:37

今天，在科工楼领到了设备，设备的性能不错：

Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz   2.90 GHz
32.0 GB (31.7 GB 可用)
Windows 10 专业版

Dell全家桶：主机+显示器。

32G内存，舒服了，开虚拟机终于不会卡了！