Kattis - brackets

题目链接：点击打开链接

校赛热身赛题目，省赛打完了回头再弄懂了这个题目。

题目大意：给定一个括号串，最多翻转一个区间，问该括号串是否能平衡。

学校oj是用线段树就会超时，因为可能查询次数比较多，复杂度为o(n^2*log n)（其实实际运行时候常数时间很低的），用RMQ就能过，复杂度为o(n^2)，在Kattis上线段树和RMQ都能过。

大抵上这类关于括号匹配的区间查询问题，都能用模拟栈的方式来做。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=5100;
char s[N];
int lBalanced[N],rBalanced[N];
int revBalanced[N];
int dp[N][20];
int mm[N];
void initRMQ(int n)
{
    mm[0]=-1;
    for(int i=1;i<=n;i++)
    {
        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
        dp[i][0]=revBalanced[i];
    }
    for(int j=1;j<=mm[n];j++)
        for(int i=1;i+(1<<j)-1<=n;i++)
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int rmq(int x,int y)
{
    int k=mm[y-x+1];
    return min(dp[x][k],dp[y-(1<<k)+1][k]);
}
inline int Q(int l,int r)
{
    return revBalanced[r]-revBalanced[l-1];
}
inline bool check(int L)
{
    if(lBalanced[L]) return false;
    for(int i=1;i<=L;i++)
        if(lBalanced[i]<0) return false;
    return true;
}
int main()
{
    while(scanf("%s",s+1)!=EOF)
    {
        bool flag=false;
        int L=strlen(s+1);
        //这里说明原串长度为奇数，不可能通过翻转平衡
        if(L%2) goto L;
        revBalanced[0]=lBalanced[0]=rBalanced[L+1]=0;
        for(int i=1;i<=L;i++)
            if(s[i]=='(') lBalanced[i]=lBalanced[i-1]+1;
            else lBalanced[i]=lBalanced[i-1]-1;
        if(check(L)) {flag=true;goto L;}
        for(int i=L;i>=1;i--)
            if(s[i]==')') rBalanced[i]=rBalanced[i+1]+1;
            else rBalanced[i]=rBalanced[i+1]-1;
        for(int i=1;i<=L;i++)
            if(s[i]==')') revBalanced[i]=revBalanced[i-1]+1;
            else revBalanced[i]=revBalanced[i-1]-1;
        initRMQ(L);
        //这里查找翻转区间
        for(int i=1;i<=L;i++)
        {
            if(lBalanced[i-1]<0) break;
            for(int j=L;j>=i;j--)
            {
                if(rBalanced[j+1]<0) break;
                //只有满足这个式子,才可能满足平衡的条件
                //这里必须要用RMQ，用线段树会超时，应该是查询次数太多了，RMQ是o(1),线段树是o(log n)
                if(lBalanced[i-1]+Q(i,j)==rBalanced[j+1])
                {
                    if(rmq(i,j)-revBalanced[i-1]+lBalanced[i-1]>=0)
                    {
                        flag=true;
                        goto L;
                    }
                }
            }
        }
        L:;
        if(flag) puts("possible");
        else puts("impossible");
    }
    return 0;
}