[CSP-S 2021] 括号序列

括号序列

题面

给定一个长度为 $n$ ，包含 $*$、$?$、$($、$)$ 的字符串。

其中， $?$ 处字符串缺失，可能是 $*$、$($、$)$ 中的任意一种。

定义超级括号序列如下：

• $()$ 和 $(S)$ 均为符合规范超级括号序列，其中 $S$ 表示由长度不超过 $k$ 的 $*$ 组成。

• 如果 $A$ 和 $B$ 为超级括号序列，那么 $AB$、$ASB$ 同样为符合规范的超级括号序列，其中 $AB$ 表示把 $A$ 和 $B$ 拼在一起形成的字符串。

• 如果 $A$ 为符合规范的超级括号序列，那么 $(A)$、$(SA)$、$(AS)$ 均为符合规范的超级括号序列。

• 所有符合规范的超级括号序列均可以由以上 $3$ 条规则得到。

求给出的字符串一共能对应多少种符合规范的超级括号序列。

给出 $n$、$k$ 和一个长度为 $n$ 的字符串，其中 $1\leq k\leq n\leq 500$ 。

分析

暴力

暴力分 $15$ 分应该是直接搜索？$O(3^n)$ ，期望能过前 $3$ 个点。

区间 $DP$

之后发现好像其他暴力不怎么会，注意到 $n$ 的范围只有 $500$ ，我们需要一个 $O(n^3)$ 的算法来解决这个问题。

考虑一个区间 $DP$ 。

设 $dp[l][r]$ 表示区间 $l$ 到 $r$ 的答案，之后，模拟上述的规则即可更新。

但之后你会发现你无法通过样例，思考这样 $dp$ 的正确性，发现我们算重了。

对于 $A$ ，我们也许会把它和后面一个匹配成功的 $BC$ 合并，但是我们也会将 $AB$ 合并，并在后面与 $C$ 合并，考虑给我们的状态多加一维。

设 $dp[l][r][0/1]$ 表示当前区间经历合并的方案数与没有经历合并的方案数，只让没有经历合并的方案和在它后面的经历过合并的方案合并，这样就能够避免这种情况。

一些细节

发现实现 $ASB$ 是最后一个难关，很容易会让复杂度退化到 $O(n^4)$ ，考虑设一个新的状态 $f[l][r]$ 表示该区间内 $SB$ 的方案数，之后可以与 $AB$ 的情况一起转移。

CODE

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=5e2+10,MOD=1e9+7;
inline int read()
{
	int s=0,w=1;
	char ch=getchar();
	while(ch<'0'||ch>'9') { if(ch=='-') w*=-1; ch=getchar(); }
	while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
	return s*w;	
}
int n,k;
int g[N][N],f[N][N],dp[N][N][2];
char arr[N];
inline bool check(int l,int r){
	if(arr[l]=='('&&arr[r]==')') return true;
	if(arr[l]=='('&&arr[r]=='?') return true;
	if(arr[l]=='?'&&arr[r]==')') return true;
	if(arr[l]=='?'&&arr[r]=='?') return true;
	return false;
}
signed main()
{
//	freopen("bracket.in","r",stdin);
//	freopen("bracket.out","w",stdout);
	n=read(),k=read();
	cin>>arr+1;
	for(int l=1;l<=n;l++){
		if(arr[l]!='('&&arr[l]!='?') continue;
		int cnt=0;
		for(int r=l+1;r<=n;r++){
			if(arr[r]==')'||arr[r]=='?') dp[l][r][0]=1;
			if(arr[r]!='*'&&arr[r]!='?') break;
			cnt++; if(cnt>k) break;
		}
	}
	for(register int len=2;len<=n;len++){ //枚举区间长度 
		for(register int l=1;l<=n-len+1;l++){ //枚举左端点 
			int r=l+len-1; //右端点
			int cnt=0;
			for(register int x=l;x<r;x++){
				if(arr[x]!='*'&&arr[x]!='?') break;
				cnt++; if(cnt>k) break;
				f[l][r]=(f[l][r]+(dp[x+1][r][0]+dp[x+1][r][1])%MOD)%MOD;
			}
			cnt=0;
			for(register int x=r;x>l;x--){
				if(arr[x]!='*'&&arr[x]!='?') break;
				cnt++; if(cnt>k) break;
				g[l][r]=(g[l][r]+(dp[l][x-1][0]+dp[l][x-1][1])%MOD)%MOD;
			}
			for(register int x=l;x<r;x++)
				dp[l][r][1]=(dp[l][r][1]+dp[l][x][0]*((f[x+1][r]+(dp[x+1][r][0]+dp[x+1][r][1])%MOD)%MOD)%MOD)%MOD;
			if(check(l,r)){ //端点可以为()
				dp[l][r][0]=((dp[l][r][0]+dp[l+1][r-1][0])%MOD+dp[l+1][r-1][1])%MOD;
				dp[l][r][0]=(dp[l][r][0]+f[l+1][r-1])%MOD;
				dp[l][r][0]=(dp[l][r][0]+g[l+1][r-1])%MOD;
			}
			
		}
	}
	printf("%lld\n",(dp[1][n][0]+dp[1][n][1])%MOD);
	return 0;
}