蓝桥杯-正则问题

考虑一种简单的正则表达式：
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。

例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是： xxxxxx，长度是6。

输入

一个由x()|组成的正则表达式。输入长度不超过100，保证合法。

输出

这个正则表达式能接受的最长字符串的长度。

例如，
输入：
((xx|xxx)x|(x|xx))xx

程序应该输出：
6

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

代码如下：

#include<iostream>
#include<cstring>

using namespace std;

void f(string str); //递归函数，核心算法
int n;              //全局变量，记录str的长度
int total=0;        //记录最终的结果


int main()
{
    string str;     //输入str
    cin>>str;
    n=str.size();

    f(str);         //进入函数
    cout<<total<<endl;      //输出最终只值
    return 0;
}
void f(string str)
{
    int flag=0;         //flag记录是否还有（）存在
    int i;              //i j k 分别记录某一次消除时的 ( | )的下标
    int j;
    int k;
    
    for(i=0;i<n;i++)        //求解i j k 的值
    {
        if(str[i]=='(')
        {
            for(j=i+1;j<n;j++)
            {
                if(str[j]=='(')
                {
                    break;
                }
                if(str[j]==')')
                {
                    flag=1;
                }
                if(str[j]=='|')
                {
                    k=j;
                }
                if(flag)
                {
                    break;
                }
            }
        }
        if(flag)
        {
            break;
        }
    }

    if(!flag)           //如果flag=1，说明已经没有了（｜）部分，退出
    {
        
        for(int m=0;m<n;m++)
        {
            if(str[m]=='x')
            {
                total++;
            }
        }
        return;
    }
    
    if(k-i>=j-k)        //对（｜）进行操作，将x数目较小的一部分连同（｜）都变为' '
    {
        for(int tmp=k;tmp<=j;tmp++)
        {
            str[tmp]='-';
        }
        str[i]='-';
    }
    else
    {
        for(int tmp=i;tmp<=k;tmp++)
        {
            str[tmp]='-';
        }
        str[j]='-';
    }

    

    
    f(str);         //递归对已经修改过的字符串再次进行处理
}