P7914 [CSP-S 2021] 括号序列 （区间 dp）

P7914 [CSP-S 2021] 括号序列

看起来非常复杂的括号题，看到数据范围，大概确定是区间 dp，所以我们考虑怎么定义状态。

条件非常多，所以二维的状态肯定表示不了，考虑多加一维来定义不同的状态。

$d{p}_{i,j,0}$：区间形式是 ***...*** 的方案数。

$d{p}_{i,j,1}$：区间形式是 (...) 的方案数。（最外层括号相互匹配）

$d{p}_{i,j,2}$：区间形式是 (...)...(...)*** 的方案数。

$d{p}_{i,j,3}$：区间形式是 (...)...(...) 的方案数。（特别的，我们把 $d{p}_{i,j,1}$ 也归为这一状态，为了方便）

$d{p}_{i,j,4}$：区间形式是 ***(...)...(...) 的方案数。

我们发现这样就表示出所有种类了，种类之间已经可以相互转移。

转移非常好推：

$d{p}_{i,j,0}$ 特判一下。

$d{p}_{i,j,1}=d{p}_{i+1,j-1,0}+d{p}_{i+1,j-1,2}+d{p}_{i+1,j-1,3}+d{p}_{i+1,j-1,4}$。条件就是 $i$ 和 $j$ 能相互匹配。

$d{p}_{i,j,2}=\sum _{k=i}^{j-1}d{p}_{i,k,3}\times d{p}_{k+1,j,0}$

$d{p}_{i,j,3}=\sum _{k=i}^{j-1}(d{p}_{i,k,2}+d{p}_{i,k,3})\times d{p}_{k+1,j,0}+d{p}_{i,j,1}$

$d{p}_{i,j,4}=\sum _{k=i}^{j-1}d{p}_{i,k,0}\times d{p}_{k+1,j,3}$

根据形式之间拼接来转移。

答案根据题目条件，即为 $d{p}_{1,n,3}$。

总结：遇到此类复杂的题目，就是要先设出状态，状态可能不会太简单，要敢设。方案数问题就要找到上一个阶段与目前阶段的转移，上面这题就是上一阶段拼接成现在的阶段。

#include <bits/stdc++.h>
typedef long long ll;
int read() {
	int x = 0, f = 1;
	char c = getchar();
	while(!isdigit(c)) {
		if(c == '-') f = -1;
		c = getchar();
	}
	while(isdigit(c)) {
		x = (x << 3) + (x << 1) + (c - '0');
		c = getchar();
	}
	return x * f;
}
int n, m, k, mod = 1000000007;
ll dp[510][510][7];
char s[510];
bool comp(int i, int j) {
	return (s[i] == '?' || s[i] == '(') && (s[j] == ')' || s[j] == '?');
}
void Solve() {
	n = read(), k = read();
	std::cin >> s + 1;
	for(int i = 1; i <= n; i++) {
		dp[i][i - 1][0] = 1;
	}
	for(int l = 1; l <= n; l++) {
		for(int i = 1, j = i + l - 1; j <= n; i++, j++) {
			if(l <= k) dp[i][j][0] = dp[i][j - 1][0] && (s[j] == '*' || s[j] == '?');
			if(l >= 2) {
				if(comp(i, j)) dp[i][j][1] = (dp[i][j][1] + dp[i + 1][j - 1][0] + dp[i + 1][j - 1][2] + dp[i + 1][j - 1][3] + dp[i + 1][j - 1][4]) % mod;
				for(int k = i; k < j; k++) {
					dp[i][j][2] = (dp[i][j][2] + dp[i][k][3] * dp[k + 1][j][0]) % mod;
					dp[i][j][3] = (dp[i][j][3] + (dp[i][k][2] + dp[i][k][3]) * dp[k + 1][j][1]) % mod;
					dp[i][j][4] = (dp[i][j][4] + dp[i][k][0] * dp[k + 1][j][3]) % mod; 
				}
			}
			dp[i][j][3] = (dp[i][j][3] + dp[i][j][1]) % mod;
		}
	}
	std::cout << dp[1][n][3] << "\n";
}

int main() {
	
	Solve();

	return 0;
}