【栈 运算系统】P3719 [AHOI2017初中组] rexp|普及+

闻缺陷则喜何志丹2026-09-06 20:04

本文涉及知识点

递归 括号匹配

P3719 AHOI2017初中组 rexp

题目背景

为了解决形形色色的字符串匹配问题，正则表达式是一个强有力的工具。正则表达式通过定义一套符号体系，能够表示出需要查找的字符串所具有的性质。如 a|aa 能匹配 a 或 aa，(a|b)c 能匹配 ac 或 bc。

题目描述

完整的正则表达式过于复杂，在这里我们只考虑由 (、)、| 和 a 组成的正则表达式。运算遵循下列法则：

  1. 有括号时，我们总是先算括号内的部分；

  2. 当两个字符串（或由括号定义的子串）间没有符号时，我们总把它们连起来作为一个整体；

  3. | 是或连接符，表示两边的字符串任取其一，若同一层里有多个或连接符，可以看作在这些或连接符所分开的若干字符串里任取其一。

例如，(aaa)aa|aa|(a(aa)a)、(aaaaa)|(aa)|aaaa 和 aaaaa|aaaa|aa 是等价的，它们都能匹配长度为 2 , 4 2,4 2,4 或 5 5 5 的全 a 字符串。

下面给定一个简化正则表达式，试编程计算它最多能匹配多长的全 a 字符串。

输入格式

输入一行一个合法的简化正则表达式。

输出格式

一行一个整数，表示能匹配的最长全 a 字符串长度。

输入输出样例 #1

输入 #1

复制代码 
(aaa)aa|aa|(a(aa)a)

输出 #1

复制代码 
5

输入输出样例 #2

输入 #2

复制代码 
((a|aaa)|aa)|a

输出 #2

复制代码 
3

输入输出样例 #3

输入 #3

复制代码 
(a(aa|aaa)a|(a|aa))aa

输出 #3

复制代码 
7

说明/提示

【数据范围】

对于 20 % 20\% 20% 数据，表达式长度不超过 100 100 100，且不存在括号。

对于 40 % 40\% 40% 数据，表达式长度不超过 100 100 100。

对于 70 % 70\% 70% 数据，表达式长度不超过 2 × 10 3 2 \times 10^3 2×103。

对于 100 % 100\% 100% 的数据，表达式长度不超过 10 5 10^5 105。

保证表达式合法（即 | 两端和括号内运算结果均非空字符串）。

递归+ 括号匹配

本题有三种运算符，小括号优先级最高，法则二（简称加法），或连接第三。

连接性：从左向右，从右向左皆可。

如果sleft...r有不在括号内的或连接符，用这些或连接拆分字符串，求各部分的最大值。

如果没有括号外的或连接符，利用括号拆分，各部分求和。

如果两者都没有，返回a的数量。

Do2(left,r) ,sleft...r中最长字符串最多a的数量。

如果r < left，返回0。

indexs记录括号外|的下标。v记录括号边界。

i = left to r {

如果si是左括号 {如果0== sum,将i增加到v。sum++;}

如果si是右括号{sum--，如果0== sum,v.Add(i)}

如果si是或连接符，且0== sum，则indexs.Add(i);

}

代码

核心代码

cpp 复制代码 
#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t);
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	scanf("%d", &n);
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int N = 1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	template<class T>
	void write(T x) {
		int num[28], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
		AuotToFile();
	}
	void writestr(const char* sz) {
		strcpy(m_p, sz);
		m_p += strlen(sz);
		AuotToFile();
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
		AuotToFile();
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
		m_p = puffer;
	}
	~COutBuff() {
		ToFile();
	}
private:
	inline void AuotToFile() {
		if (m_p - puffer > N - 100) {
			ToFile();
		}
	}
	char  puffer[N], * m_p;
};

template<int N = 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {}
	inline CInBuff<N>& operator>>(char& ch) {
		FileToBuf();
		ch = *S++;
		return *this;
	}
	inline CInBuff<N>& operator>>(int& val) {
		FileToBuf();
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行		
		return *this;
	}
	inline CInBuff& operator>>(long long& val) {
		FileToBuf();
		long long x(0); int f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行
		return *this;
	}
	template<class T1,class T2>
	inline CInBuff& operator>>(pair<T1,T2>& val) {
		*this >> val.first >> val.second;
		return *this;
	}
	template<class T1, class T2,class T3>
	inline CInBuff& operator>>(tuple<T1, T2,T3>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val);
		return *this;
	}
	template<class T1, class T2, class T3,class T4>
	inline CInBuff& operator>>(tuple<T1, T2, T3,T4>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val) >> get<3>(val);
		return *this;
	}
	template<class T = int>
	inline CInBuff& operator>>(vector<T>& val) {
		int n;
		*this >> n;
		val.resize(n);
		for (int i = 0; i < n; i++) {
			*this >> val[i];
		}
		return *this;
	}
	template<class T = int>
	vector<T> Read(int n) {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) {
			*this >> ret[i];
		}
		return ret;
	}
private:
	inline void FileToBuf() {
		const int canRead = m_iWritePos - (S - buffer);
		if (canRead >= 100) { return; }
		if (m_bFinish) { return; }
		for(int i = 0 ;i < canRead;i++)
		{
			buffer[i] = S[i];//memcpy出错			
		}
		m_iWritePos = canRead;
		buffer[m_iWritePos] = 0;
		S = buffer;
		int readCnt = fread(buffer + m_iWritePos, 1, N - m_iWritePos, stdin);
		if (readCnt <= 0) { m_bFinish = true; return; }
		m_iWritePos += readCnt;
		buffer[m_iWritePos] = 0;
		S = buffer;
	}
	int m_iWritePos = 0; bool m_bFinish = false;
	char buffer[N + 10], * S = buffer;
};

class Solution {
public:
	int Ans(const string& s) {
		const int N = s.size();
		vector<vector<int>> levesOr(N);//leves[i]记录被0层括号包括的或的下标
		vector < vector<pair<int, int>>> leveRanges(N);//leveRanges[i]记录第i层的左括号、对应的右括号下标
		int sum = 0;
		for (int i = 0; i < N; i++) {
			if ('|' == s[i]) {
				levesOr[sum].emplace_back(i);
			}
			if ('(' == s[i]) {
				leveRanges[sum].emplace_back(i, -1);
			}
			if ('(' == s[i]) { sum++; }
			if (')' == s[i]) { sum--; }
			if (')' == s[i]) {
				leveRanges[sum].back().second = i;
			}
		}
		map<int, int> mRight;//key:左
		vector<int> vRight(N);//
		function<int(int, int, int)> Do = [&](int left, int r, int leve) {
			if (r < left) { return 0; }
			auto it1 = lower_bound(levesOr[leve].begin(), levesOr[leve].end(), left);
			if ((levesOr[leve].end() != it1) && (*it1 <= r)) {//存在或连接符
				int ans = 0, pre = left;
				for (; (levesOr[leve].end() != it1) && (*it1 <= r); ++it1) {
					ans = max(ans, Do(pre, *it1 - 1, leve));
					pre = *it1 + 1;
				}
				ans = max(ans, Do(pre, r, leve));
				return ans;
			}
			auto it2 = lower_bound(leveRanges[leve].begin(), leveRanges[leve].end(), left, [&](const auto& pr, int i) {return pr.first < i; });
			if ((leveRanges[leve].end() != it2) && (it2->first <= r)) {
				int ans = 0, pre = left;
				for (; (leveRanges[leve].end() != it2) && (it2->first <= r); ++it2) {
					ans += Do(pre, it2->first - 1, leve);
					ans += Do(it2->first + 1, it2->second - 1, leve + 1);
					pre = it2->second + 1;
				}
				ans += Do(pre, r, leve);
				return ans;
			}
			return r - left + 1;
		};
		return Do(0, N - 1, 0);
	}
};

int main() {	
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	string s;
	cin >> s;
#ifdef _DEBUG		
	//printf("N=%d,", N);
	//Out(mat, ",mat=");
	//Out(pos, ",pos=");
	/*Out(edge, "edge=");
	Out(que, "que=");*/
#endif // DEBUG	
	auto res = Solution().Ans(s);
	cout << res;
	return 0;
}

单元测试

cpp 复制代码 
string s;
		TEST_METHOD(TestMethod11)
		{			
			Solution slu;
			auto res = slu.Ans("aaa");
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod12)
		{
			Solution slu;
			auto res = slu.Ans("aaaa|a|aa");
			AssertEx(4, res);
		}
		TEST_METHOD(TestMethod13)
		{
			Solution slu;
			auto res = slu.Ans("aa|a|aaaa");
			AssertEx(4, res);
		}
		TEST_METHOD(TestMethod14)
		{
			Solution slu;
			auto res = slu.Ans("aa|aaaaa|aa");
			AssertEx(5, res);
		}
		TEST_METHOD(TestMethod15)
		{
			Solution slu;
			auto res = slu.Ans("aa(aaaaa)aa");
			AssertEx(9, res);
		}
		TEST_METHOD(TestMethod16)
		{
			Solution slu;
			auto res = slu.Ans("(aaa(aaaa))a(a)");
			AssertEx(9, res);
		}
		TEST_METHOD(TestMethod17)
		{
			Solution slu;
			auto res = slu.Ans("(aaa(aaaa))a(a)");
			AssertEx(9, res);
		}
		TEST_METHOD(TestMethod18)
		{
			Solution slu;
			auto res = slu.Ans("(aaa)aa|aa|(a(aa)a)");
			AssertEx(5, res);
		}
		TEST_METHOD(TestMethod19)
		{
			Solution slu;
			auto res = slu.Ans("((a|aaa)|aa)|a");
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod20)
		{
			Solution slu;
			auto res = slu.Ans("(a(aa|aaa)a|(a|aa))aa");
			AssertEx(7, res);
		}

优化

可以用表达式的通用解法，栈。法则二是高级运算，高级运算马上运算，或是低级运算，低级运行遇到反括号或结束时运算。有个更简单的方法。

Do函数的r，改成自动，即遇到)和|结束。left改成所有函数共用，逻辑如下：

ans =0；

当left < N {

ch = sleft++

ch是a,ans++

ch是)，return ans。

ch是( ans +=Do()

cha是|，return max(ans,Do())

}

return ans;

代码

cpp 复制代码 
class Solution {
		public:
			int Ans(const string& s) {
				const int N = s.size();
				int left = 0;
				function<int()> Do = [&]() {
					int ans = 0;
					while (left < N) {
						const char ch = s[left++];
						if ('a' == ch) { ans++; }
						else if (')' == ch) { return ans; }
						else if ('(' == ch) { ans += Do(); }
						else { return max(ans ,Do()); }
					}
					return ans;
				};
				return Do();
			}
		};

扩展阅读

计算几何为骨，排样优化为魂
作品：亲士CAD工具箱
经典文章推荐：二维排样
万物皆数学
查阅鄙人的博文，请点击博文下载学院导航
活到老，学到老。明朝中后期，大约50%的进士能当上堂官(副部及更高)；能当上堂官的举人只有十余人。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者 操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法用**C++**实现。

相关推荐
疯狂打码的少年1 小时前
【数据库技术】多值依赖与第四范式（4NF）
数据库·笔记·算法
子文雨1 小时前
基于 uC3845 与 ATtiny13 双芯片架构的 8.4V/2.5Ah 锂电池智能充电器设计
单片机·嵌入式硬件·算法
bnmoel1 小时前
C++ 基础入门篇（一）：命名空间，输入&输出，缺省参数，函数重载
c++·函数重载·语法·命名空间·缺省参数
青山木2 小时前
Hot 100 --- 数组中的第K个最大元素
java·数据结构·算法·排序算法
玛卡巴卡ldf2 小时前
【AICoding】笔试提示词设计思路
java·算法·ai编程
明月_清风2 小时前
位图与布隆过滤器：海量数据下的"存在性判断"艺术
前端·后端·算法
Rnan-prince2 小时前
堆与TopK · 从零到通透 —— 9 节全系列复盘
python·算法
明月_清风2 小时前
Hash 表从入门到精通：Go 实战与工程细节
前端·后端·算法
Zixhy2 小时前
多点巡检机器人项目技术总结
linux·c++·机器人·自动驾驶
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03历年考研数学一、数学二、数学三真题试卷及答案PDF04蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接05ZCode 周末送额度活动开启：3 亿 Token 免费领取062026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？07微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路10VSCode+CodeX扩展，无法启动