有效的括号

问题

给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。

有效字符串需满足:

  • 左括号必须用相同类型的右括号闭合。
  • 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例:

输入: "()"
输出: true

输入: "(]"
输出: false

输入: "([)]"
输出: false

输入: "{[]}"
输出: true
分析

一个不完善的方案

类似于编译器对程序中出现的括号的匹配性进行检查。

很容易想出一个简单的方法来解决这个问题:

  • 从表达式的左侧开始,每次只处理一个括号。
  • 假设我们遇到一个开括号(即 (),表达式是否无效取决于在该表达式的其余部分的某处是否有相匹配的闭括号(即 ))。此时,我们只是增加计数器的值保持跟踪现在为止开括号的数目。left += 1
  • 如果我们遇到一个闭括号,这可能意味着这样两种情况:
    • 此闭括号没有与与之对应的开括号,在这种情况下,我们的表达式无效。当 left == 0,也就是没有未配对的左括号可用时就是这种情况。
    • 我们有一些未配对的开括号可以与该闭括号配对。当 left > 0,也就是有未配对的左括号可用时就是这种情况。
  • 如果我们在 left == 0 时遇到一个闭括号(例如 )),那么当前的表达式无效。否则,我们会减少 left 的值,也就是减少了可用的未配对的左括号的数量。
  • 继续处理字符串,直到处理完所有括号。
  • 如果最后我们仍然有未配对的左括号,这意味着表达式无效。

代码的实现也很简单:

bool isValid(char* s) {
    int a[3] = {0};
    
    while (*s != '\0') {
        switch (*s) {
            case '(':
                a[0]++;
                break;
            case '[':
                a[1]++;
                break;
            case '{':
                a[2]++;
                break;
            case ')':
                a[0]--;
                break;
            case ']':
                a[1]--;
                break;
            case '}':
                a[2]--;
                break;
            default:
                break;
        }
        if (a[0] < 0 || a[1] < 0 || a[2] < 0) {
            return false;
        }
        s++;
       
    }
    if (a[0] != 0 || a[1] != 0 || a[2] != 0) {
        return false;
    }
    
    return true;
}

但是,这只对简单的括号有效,比如出现的是同一种类型的括号。

当多种类型的括号同时出现时,该方法仅记录了最后的结果,而没有记录过程,会导致诸如([)]类型的表达为true

因为这时括号的相对位置起到了重要作用,而简单计数方法就无法应对这种情况了。

使用栈解决问题

这让我想到了实现算术运算时的一个案例。如2 + 5 * 3,计算时应该先运算乘法而不是加法。先计算的不是前面的而是后面的。

于是,后进先出的结构栈的概念便派上用场了。

具体过程如下:

  • 初始化栈 S。
  • 一次处理表达式的每个括号。
  • 如果遇到开括号,我们只需将其推到栈上即可。这意味着我们将稍后处理它,让我们简单地转到前面的 子表达式。
  • 如果遇到一个闭括号,那么我们检查栈顶的元素。如果栈顶的元素是一个 相同类型的 左括号,那么我们将它从栈中弹出并继续处理。否则,这意味着表达式无效。
  • 如果到最后剩下的栈中仍然有元素,那么这意味着表达式无效。
代码

bool isValid(char* s) {
    int len = strlen(s);
    char *stack = NULL;
    int cur = 0;
    
    if (len % 2) {
        return false;
    }
    stack = (char *)calloc(1, len + 1);
    if (!stack) {
        printf("calloc error: %m\n");
        return false;
    }
    
    while (*s != NULL) {
        if (*s == '(' || *s == '[' || *s == '{') {
            stack[cur] = *s;
            cur++;
        } else if (cur < 1) {
            free(stack);
            return false;
        } else if (*s == ')') {
            if (stack[cur-1] == '(') {
                stack[cur-1] = '\0';
                cur--;
            } else {
                free(stack);
                return false;
            }
        } else if (*s == ']') {
            if (stack[cur-1] == '[') {
                stack[cur-1] = '\0';
                cur--;
            } else {
                free(stack);
                return false;
            }
        } else if (*s == '}') {
            if (stack[cur-1] == '{') {
                stack[cur-1] = '\0';
                cur--;
            } else {
                free(stack);
                return false;
            }
        }
        s++;
    }
    if (stack[0] != '\0') {
        return false;
    }
    free(stack);
    return true;
}
<think>首先,用户的问题是关于“最长有效括号”问题的解决方案或算法,特别是使用动态规划和的方法。用户提到了“动态规划”和“”,所以我会基于这些方法进行回答。我需要参考提供的引用内容:-引用[1]:描述了使用的方法,通过下标计算最大括号对数。-引用[2]:讨论了动态规划方法,其中dp[i]表示以i结尾的连续有效子串的长度。-引用[3]:另一个的实现,使用了来跟踪下标。-引用[4]:尝试了的方法但未通过,展示了不正确的代码。我的回答应该结构清晰,帮助用户逐步解决问题。回答中需要遵守系统级指令:-所有行内数学表达式使用$...$格式。-独立公式使用$$...$$格式并单独成段。-LaTeX语法正确。-使用中文回答。-生成相关问题。-在引用段落末尾自然地添加引用标识,如[^1]。回答结构:1.**简介问题**:解释“最长有效括号”问题是什么。2.**方法**:详细解释方法的实现步骤。3.**动态规划方法**:详细解释动态规划方法的实现步骤。4.**算法实现**:提供代码示例。5.**生成相关问题**:在最后添加相关问题。在回答中,我会自然地引用提供的引用内容,添加引用标识。**步骤1:简介问题**-问题描述:给定一个只包含'('和')'的字符串,找到最长有效括号子串的长度。有效括号子串指的是括号正确匹配的子串。-例如,字符串"(()())"的最长有效括号子串长度是6。**步骤2:方法**-参考引用[1]和[3],方法使用一个来存储下标。-核心思想:使用记录左括号的下标。当遇到右括号时,弹出顶的左括号下标,计算当前有效子串长度。-关键点:初始时压入-1或一个无效下标,以处理边界情况。-公式:如果使用下标,当前长度是$i-\text{sta.top()}$,其中i是当前下标。-伪代码或代码示例:基于引用[1]或[3]。**步骤3:动态规划方法**-参考引用[2],动态规划使用dp数组,其中dp[i]表示以第i个字符结尾的最长有效括号子串的长度。-核心思想:当s[i]是')'时,考虑s[i-1]:-如果s[i-1]是'(',则dp[i]=dp[i-2]+2(如果i-2>=0)。-如果s[i-1]是')',则检查s[i-dp[i-1]-1]是否为'(',如果是,则dp[i]=dp[i-1]+2+dp[i-dp[i-1]-2](注意边界)。-公式:独立公式使用$$...$$,例如:$$\text{dp}[i]=\begin{cases}0&\text{if}s[i]='('\\\text{dp}[i-2]+2&\text{if}s[i]=')'\text{and}s[i-1]='('\\\text{dp}[i-1]+2+\text{dp}[i-\text{dp}[i-1]-2]&\text{if}s[i]=')'\text{and}s[i-1]=')'\text{and}s[i-\text{dp}[i-1]-1]='('\end{cases}$$需要调整以确保边界正确。-伪代码或代码示例。**步骤4:算法实现**-提供C++或Python代码示例。用户提供的引用中有C++代码,我可以基于引用[1]或[2]给出简洁的代码。-方法代码:类似引用[1]。-动态规划方法代码:类似引用[2]。**步骤5:生成相关问题**-在最后添加相关问题,如:1.方法和动态规划方法的时间复杂度分别是多少?2.这两种方法的空间复杂度如何?3.是否有其他方法解决这个问题?4.在实际应用中,哪种方法更优?**引用处理**:-在回答中,当引用特定段落时,添加引用标识。例如,当提到方法时,说“如引用[1]所示”[^1]。-引用标识要自然地添加到段落末尾。**语言**:全程使用中文。**LaTeX使用**:-行内:如$dp[i]$。-独立:如上面的动态规划公式,单独成段。现在,构建回答大纲:1.**介绍问题**:解释最长有效括号问题。2.**方法**:-原理:使用存储下标。-步骤:初始化,遍历字符串,处理左右括号。-时间复杂度:$O(n)$。-空间复杂度:$O(n)$。-代码示例:基于引用[1]。3.**动态规划方法**:-原理:定义dp数组。-状态转移方程:详细解释。-时间复杂度:$O(n)$。-空间复杂度:$O(n)$。-代码示例:基于引用[2]。4.**比较方法**:简要比较两种方法。5.**相关问题**:列出几个相关问题。最后,添加相关问题。</think>### 最长有效括号问题解决方案 “最长有效括号”问题要求在一个仅包含字符'('和')'的字符串中,找到最长有效括号子串的长度。有效括号子串是指括号正确匹配的子串,例如字符串"(()())"的最长有效子串长度为6。下面我将详细介绍两种主流算法实现:方法和动态规划方法,并附上代码示例。参考了LeetCode相关题解[^1][^2][^3][^4]。 #### 1. **方法** 方法的核心思想是使用存储下标,通过匹配括号对并计算下标差来更新最大长度。时间复杂度为$O(n)$,空间复杂度为$O(n)$。 **算法步骤**: 1. 初始化,压入一个无效下标(如-1),用于处理边界情况。 2. 遍历字符串每个字符: - 遇到左括号'('时,将其下标压入。 - 遇到右括号')'时,弹出顶元素: - 若为空,表示当前右括号无法匹配,压入当前下标作为新起点。 - 若非空,计算当前有效子串长度:$i - \text{sta.top()}$,并更新最大值。 3. 遍历结束后,返回最大长度。 **代码实现(基于C++)**: ```cpp #include <stack> #include <algorithm> using namespace std; int longestValidParentheses(string s) { stack<int> sta; sta.push(-1); // 初始无效下标,处理边界[^1] int maxLen = 0; for (int i = 0; i < s.size(); i++) { if (s[i] == '(') { sta.push(i); // 左括号下标入 } else { sta.pop(); // 匹配成功,弹出顶 if (sta.empty()) { sta.push(i); // 空,压入新起点 } else { maxLen = max(maxLen, i - sta.top()); // 更新长度 } } } return maxLen; } ``` 此方法简洁高效,通过下标差直接计算长度[^1][^3]。 #### 2. **动态规划方法** 动态规划方法定义dp数组,其中$dp[i]$表示以索引$i$结尾的最长有效括号子串长度。时间复杂度为$O(n)$,空间复杂度为$O(n)$。关键点在于状态转移方程: **状态转移方程**: - 当$s[i] = '('$时,$dp[i] = 0$(无法以左括号结尾)。 - 当$s[i] = ')'$时: - 若$s[i-1] = '('$,则$dp[i] = dp[i-2] + 2$(匹配相邻左括号)。 - 若$s[i-1] = ')'$,且$s[i - dp[i-1] - 1] = '('$,则: $$ dp[i] = dp[i-1] + 2 + dp[i - dp[i-1] - 2] $$ 其中$i - dp[i-1] - 2$是匹配前的子串结尾索引。 **算法步骤**: 1. 初始化dp数组全为0。 2. 遍历字符串(从索引1开始): - 处理$s[i] = ')'$的两种情况。 - 更新dp[i]并记录全局最大值。 3. 返回最大值。 **代码实现(基于C++)**: ```cpp int longestValidParentheses(string s) { int n = s.size(); if (n == 0) return 0; vector<int> dp(n, 0); int maxLen = 0; for (int i = 1; i < n; i++) { if (s[i] == ')') { if (s[i-1] == '(') { // 相邻左括号匹配 dp[i] = (i >= 2 ? dp[i-2] : 0) + 2; } else if (i - dp[i-1] > 0 && s[i - dp[i-1] - 1] == '(') { // 嵌套匹配 int prevIndex = i - dp[i-1] - 2; dp[i] = dp[i-1] + 2 + (prevIndex >= 0 ? dp[prevIndex] : 0); } maxLen = max(maxLen, dp[i]); } } return maxLen; } ``` 此方法处理嵌套括号更灵活,如字符串"()(())"可正确计算[^2][^4]。 #### 方法比较 - **方法**:实现简单,易于理解,适合大多数场景。 - **动态规划**:能处理复杂嵌套,但状态转移需注意边界。 - **推荐**:方法在空间和代码简洁性上更优,动态规划在特定用例(如连续嵌套)可能更高效[^3][^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值