[LOJ118]正则表达式

题目

传送门 to LOJ

思路

第一个想法：哈，好像是实用性代码。看一眼题：啊哈？无限次匹配？再看一下，发现没有数据组数的范围，人懵了……

一开始有一个想法，存一下正则表达式中每个计算单元能不能表示 $n^2$ 个子串。这个做法极其麻烦且复杂度可能高达 $\mathcal{O}(n^4)$，我直接哭出声。

好吧完全没学会，然后康了一下 $\mathsf{L}\mathsf{u}\mathsf{c}\mathsf{k}\mathsf{y}\_\mathsf{G}\mathsf{l}\mathsf{a}\mathsf{s}\mathsf{s}$ 给的学习之尿资料：沃德马鸭！这么强大的么！直接建立 $\mathtt{a}\mathtt{u}\mathtt{t}\mathtt{o}\mathtt{m}\mathtt{a}\mathtt{t}\mathtt{o}\mathtt{n}$！虽然完全没有代码，也没提及代码实现，但我觉得我学废了！

后来修修补补，勉强过掉了。但是没完！谁叫我手贱，想看看最优解，结果一看：

$$\begin{gathered} \mathsf{O}\mathsf{n}\mathsf{e}\mathsf{I}\mathsf{n}\mathsf{D}\mathsf{a}\mathsf{r}\mathsf{k}478ms \\ \mathsf{V}\mathsf{a}\mathsf{s}\mathsf{i}\mathsf{l}\mathsf{e}\mathsf{s}12ms \end{gathered}$$

王德发？悄悄点进去看看代码：

#include <bits/stdc++.h>
#include <regex.h>
using namespace std;
const int N = 110;
char s[N], t[N];
int main() {
    regex_t r;
    regmatch_t m;
    while (scanf("%s%s", s, t) != EOF) {
        regcomp(&r, s, 1);
        puts(regexec(&r, t, 1, &m, 0) || m.rm_eo - m.rm_so < (int)strlen(t) ? "No" : "Yes");
        regfree(&r);
    }
    return 0;
}

[抽水马桶脏话]！原来 $\mathrm{S}\mathrm{T}\mathrm{L}$ 已经实现了正则表达式吗！更重要的是，开 $O2$ 时 $\mathrm{S}\mathrm{T}\mathrm{L}$ 快到飞起啊！它是怎么实现的？

又查了一下，发现也差不多。只不过它的建边确实有优化。因为整个图中，几乎所有边都是 “空串边”（即从这条边上走过，并不进行任何匹配），所以只需要连接这种边。然后匹配相当于匹配点权。

但是它咋实现的正闭包啊？没看到。我猜大概就是单向链接，先走到这个字符串，走完之后走到 $+$ 号，此时有一条边连向该字符串起点，可以从头再来，也可以转身离开。直接把原字符串的每个字符拿来当成点，一方面便于证复杂度，另一方面很直观（才怪咧，就是个点权的事儿嘛）。

时间复杂度应该是最坏 $\mathcal{O}(|S||T|)$ 的，即模板正则表达式与待匹配字符串的长度之积。不过空间复杂度可以是 $\mathcal{O}(|S|+|T|)$ 的，这也是 $\mathrm{S}\mathrm{T}\mathrm{L}$ 与我不同的地方。

还是没法解释为啥模板库快那么多啊。真是[炎翼鸟话]。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int_;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 105;
const int MaxM = MaxN<<1;

int cntNode;
vector<int> ch[MaxM][27];
void addEdge(int a,int c,int b){
	if(a != b) ch[a][c].push_back(b);
}

bool vis[MaxM][MaxN];
struct Automaton{
	int from, to;
	void init(char c){
		from = ++ cntNode;
		to = ++ cntNode;
		addEdge(from,c-'a',to);
	}
	void dfs(const char str[],int t,int n,int x){
		if(vis[x][t]) return ;
		vis[x][t] = true;
		for(int y : ch[x][26])
			dfs(str,t,n,y);
		if((++ t) > n) return ; // enough
		for(int y : ch[x][str[t]-'a'])
			dfs(str,t,n,y);
	}
	bool decide(const char str[],int n){
		rep(i,1,cntNode)
			memset(vis[i],0,n+1);
		dfs(str,0,n,from);
		return vis[to][n];
	}
};
Automaton mac[MaxN];
int r[MaxN]; // right point

char str[MaxN];
void calculate(int a,int b){
	char c = (r[a] == b-1) ? '&' : str[b-1];
	if(c == '+') addEdge(mac[a].to,26,mac[a].from);
	if(c == '*'){
		addEdge(mac[a].to,26,mac[a].from);
		mac[a].to = mac[a].from;
	}
	if(c == '&'){
		addEdge(mac[a].to,26,mac[b].from);
		mac[a].to = mac[b].to;
	}
	if(c == '|'){
		addEdge(cntNode+1,26,mac[a].from);
		addEdge(cntNode+1,26,mac[b].from);
		mac[a].from = ++ cntNode;
		addEdge(mac[b].to,26,mac[a].to);
	}
	if(r[b]) r[a] = r[b]; // automatically 
}

vector<int> num;
int getPrio(char c){
	if(c == '(') return -2; // never to do
	if(c == ')') return 2; // always to do
	if(c == '&') return 0;
	if(c == '|') return -1;
	return 1; // a+ or a*
}
void checkStack(char c){
	int len = num.size();
	while(len >= 2)
		if(r[num[len-2]] == num[len-1]-1){
			if(getPrio('&') <= getPrio(c)) break;
			calculate(num[len-2],num[len-1]);
			-- len; num.pop_back();
		}
		else{
			if(getPrio(str[num[len-1]-1])
				<= getPrio(c)) break;
			calculate(num[len-2],num[len-1]);
			-- len; num.pop_back();
		}
}
void build(){
	rep(i,1,cntNode) rep(j,0,26)
		ch[i][j].clear();
	cntNode = 0; // clear
	int n = strlen(str+1);
	num.clear(); // empty
	for(int i=1; i<=n; ++i){
		char c = str[i];
		if(c == ')'){
			int len = num.size();
			while(len >= 2){
				if(r[num[len-2]] != num[len-1]-1)
					if(str[num[len-1]-1] == '(')
						break; // matched
				calculate(num[len-2],num[len-1]);
				-- len; num.pop_back();
			}
			-- num[len-1]; // eat '('
			mac[num[len-1]] = mac[num[len-1]+1];
			r[num[len-1]] = r[num[len-1]+1]+1;
			continue; // taken as a whole
		}
		if(c == '+' || c == '*'){
			r[i+1] = 0; // not exist now
			calculate(num.back(),i+1);
			++ r[num.back()]; // eat it
			continue; // top priority
		}
		if(c < 'a' || 'z' < c){
			checkStack(c); continue;
		}
		mac[i].init(c); r[i] = i;
		if(num.empty()){
			num.push_back(i);
			continue; // skip
		}
		num.push_back(i);
	}
	int len = num.size();
	while(len >= 2){
		calculate(num[len-2],num[len-1]);
		-- len; num.pop_back();
	}
}

int main(){
	while(scanf("%s",str+1) != EOF){
		build(), scanf("%s",str+1);
		if(mac[num.back()].decide(str,strlen(str+1)))
			puts("Yes");
		else puts("No");
	}
	return 0;
}