基于堆栈的平衡括号问题

Question

这是一个问题： 如果可以通过将字符 + 和 1 插入到该序列中来获得正确的算术表达式，则该括号序列称为正则。例如，序列 (())()、() 和 (()(())) 是正则的，而 )(、(() 和 (()))( 则不是。我们称正则括号序列“RBS ”。

给定一个由 n 个字符 (, ) 和/或 ? 组成的序列 s。此序列中恰好有一个字符（也正好是一个字符）。

你必须替换每个字符？使用 ) 或 (（不同的字符 ? 可以用不同的括号替换）。您不能重新排序字符、删除它们、插入其他字符，并且每个 ? 都必须替换。

确定在这些替换之后是否有可能获得平衡序列。

前：

5
()
(?)
(??)
??()
)?(?

输出：

YES
NO
YES
YES
NO

这是我的代码：

#include <bits/stdc++.h>
using namespace std;

bool checkValidString(string s) {
    stack<char>st;
    for(int i=0;i<s.length();i++)
    {
        if(!st.empty() && (((st.top() == '(') && s[i] == '?') || ((st.top() == '?') && s[i] == ')') || st.top() == '(' && s[i] == ')'))
        {
            st.pop();
        }
        else
        {
            st.push(s[i]);
        }
    }
    if(st.empty())
    {
      return true;
    }
    int si = st.size();
    bool odd = false;
    if(si%2!=0)
    {
      odd = true;
    }
    while(!st.empty())
    {
        char c = st.top();
        if(c!='?')
        {
            return false;
        }
        st.pop();
    }
    if(odd)
    {
        return false;
    }
    return true;
}

int main() {
    // your code goes here
    int n;
    cin>>n;
    while(n--)
    {
        string s;
        cin>>s;
        bool ans = checkValidString(s);
        if(ans == 1)
        {
            cout<<"YES"<<endl;
        }
        else
        {
            cout<<"NO"<<endl;
        }
    }
    return 0;
}

但是它给出了错误的答案，你能帮助我哪里出错了吗？谢谢。

Answer 1

检查有效括号的逻辑无法解决此类问题。

示例：输入字符串 = (?)? 的测试用例将在您的情况下失败。但它是一个有效的字符串，因为它可以采用(()) 的形式。

那么现在，你如何处理这样的问题？

让我们弄清楚所有可能的输入字符串是什么样的。

测试用例：

1. 如果问号为奇数，则为无效字符串。
2. 如果左括号出现在右括号之前，并且它们之间有奇数个问号：

(???)? 或 ?(???) => 两者都是有效字符串，因为它们可以采用 ((())) 的形式。

1. 如果左括号出现在右括号之前，并且它们之间有偶数个问号：

(????) 或 ??(??)?? => 这类字符串始终有效。

4. 如果左括号出现右括号：

?)(? => 这个字符串也是有效的，因为它可以取自()()。

5. 我们唯一需要担心的是)是第一个位置还是(是最后一个位置：

)??( => 总是无效的字符串。

)?(? => 始终是无效字符串。

?)?( => 总是无效的字符串。

因此，问题被简化为 3 个主要条件：

1. 字符串的长度应该是偶数：要做到这一点，字符串中?的字符数应该是偶数。

2. 字符串不应以)开头。

3. 字符串不应以(结尾。

查看以下在 Codeforces 上具有 已接受 状态的代码：

#include <iostream>
#include <string>

int main(){
    
    int t;
    scanf("%d", &t);
    
    while(t--){
        
        std::string s;
        std::cin>>s;
        
        int len = s.length();
        int countQuestion = 0;
        
        for(int i=0;i<len;i++){
            
            if(s[i]=='?'){
                countQuestion++;
            }
        }    
        
        //Check 1: If question count is even?
        if(countQuestion & 1){
            
            printf("NO\n");
        }else{
            
            if(s[0] == ')' || s[len-1] == '('){
                printf("NO\n");
            }else{
                printf("YES\n");
            }
        }
    }
    
    return 0;
}

判决：

Answer 2

如果您想检查一串括号以查看它是否有效，您将在遍历字符串时保留一个开括号计数器。您将从 0 开始，为每个 ( 增加它，并为每个 ) 减少它。您需要检查以确保它永远不会变为负数并且以 0 结束。

如果将某些括号替换为问号，您可以想象做同样的事情，但是在每个位置您都可以计算出计数器所有可能的非负值。如果该组值曾经为空，那么有效的括号字符串是不可能的。如果该集合不包含 0，则不可能有有效的括号字符串。

事实证明（你可以通过归纳证明），可能值的集合总是包含两个数字 x 和 y 之间的每个 第二个 数字。

在?之后，[x,y] -> [x-1,y+1]，不包括数字

在 (, [x,y] -> [x+1,y+1] 之后

之后)，[x,y] -> [x-1,y-1]，不包括数字

因此，您可以通过遍历字符串，从 [0,0] 开始并根据上述规则修改每个字符的范围来测试 任何 括号和问号序列。确保它永远不会为空，并且在末尾包含 0。

bool checkValidString(string s) {
    int l=0, h=0;
    for(int i=0;i<s.length();i++) {
        switch(s[i]) {
            case '(':
            ++l;++h;
            break;

            case ')':
            if (h<=0) {
                return false;
            }
            --h;
            l += (l>0 ? -1:1);
            break;

            default:
            ++h;
            l += (l>0 ? -1:1);
            break;
        }
    }
    return l==0;
}