[题解] csp-s2021 T2 括号序列

本文于 2023.03.26 大修（几乎重写）

本文首先发布于个人博客，博客园不定期更新。推荐去我的博客阅读本文，体验更佳。

因为 csp-s 考的太惨了，所以一直想着回头把前三题都AC了，结果一拖拖到现在才做完（

还有就是动态规划好难（wtcl）

题意

本题题意较复杂，建议直接去看原题（题目链接）。

总的来说，合法的括号序列一共分两类：

1. 包含型：\(()\)，\((A)\)，\((S)\)，\((AS)\)，\((SA)\)

2. 并列型： \(AB\) ，\(ASB\)

显然合法的括号序列两端必然分别是左右括号，而且合法的括号序列最小长度为2。

初步分析

数据范围可知这题大概需要一个 \(O(n^3)\) 的方法

这道题一看就像是区间DP。设状态 \(f[i][j]\) 表示 \([i,j]\) 这段区间内的数量，由于上文已经证明看出“合法的括号序列两端必然分别是左右括号”，所以需要先确保 \(i\) 对应位置可以为 (,即 a[i] == '(' || a[i] == '?'，对 \(j\) 也同理，不满足的话 \(f[i][j]\) 一律为 0。后文的讨论均基于 \(i,j\) 满足要求的情况。

按照刚刚上面的分类进行讨论，记 \(s[i][j]\) 表示 \([i:j]\) 能否完全由不超过 k 个连续的 * 或者 ? 组成，或者说 \(s[i][j]\) 表示 \(a[i][j]\) 能否构成题目中的 S。则可列出方程：

\[\left. \begin{array} { l } { (A):f [i] [j] += f[i+1][j-1] } \\ { (S):f[i][j] += 1, s[i+1][j-1]=true } \\ \end{array} \right. \]

（放在逗号右面表示只有当满足这个条件时才计算）

\((AS)\) 只要枚举一下 S 就行，\(p\) 为 A 的右端点（包含）：

\[{ (AS):f[i][j] += \sum_{p=i+2}^{j-1}f[i][p],\space s[p+1][j-1]=true } \]

\((SA)\) 与 \((AS)\) 差不多，留作习题答案略。那么包含型的情况已经讨论完了。

下面是并列型的情况。在计算 \(ASB\) 的贡献的时候，如果像我们刚刚那样设计状态就会列出错误的方程：

\[f[i][j]+=\sum_{p=i+1}^{j-2}\sum_{q=p+1}^{j-1} f[i][p]\times f[q][j],\space s[p+1][q-1]=true \]

这个式子即枚举 \(A\) 的右端点 \(p\) 和 \(B\) 的左端点 \(q\)（均包含）来间接枚举 \(S=a[p+1:q-1]\)，从而转移 \(ASB\)，这里 S 能取空所以可以连 AB 的情况一起处理。

但是这样的转移方程为什么是错的呢，我们看下面这样的括号序列：

()()??()

有以下几种情况：

cnt	A	S	B	ASB
1	()	null	()()()	()()()()
2	()	null	()**()	()()**()
3	()()	null	()()	()()()()
4	()()	null	**()	()()**()
5	()()	**	()	()()**()
6	()()()	null	()	()()()()

显然算重了（由于在计算子区间 \(A\) 和 \(B\) 的并列型情况时还会有重复，所以按这种错误方法算出的情况数不止上述 6 种）。

去重

如果每次在左边的 \(A\) 只枚举包含型，不枚举并列型的结构，而 \(B\) 包含型与并列型都枚举，这样每种拆法就只会数一次了。后文将这种拆法表示为 \(FS?B\)（\(?\) 表示可有可无）。由于 \(FS?B\) 没法再拆成其他的并列型，所以显然不会重复，下面简要证明不会遗漏：

一种并列型的 \(A\) 总能表示为 \(A = F+S'?+B'\)，其中 \(F\) 为包含型，\(B'\) 任意，情况 \(A+S?+B = F+S'?+B'S?B\)，符合 \(FS?B\)，故能够被计数。

重新设计一下状态，用 \(f[i][j]\) 表示该区间内包含型序列的数量，\(g[i][j]\) 表示并列型序列的数量。

重新看一下原来的转移方程，你会发现 \((A)\)，\((S)\) 的转移方程不需要改，\((AS)\) 的转移方程只是把后面的 \(f[i][p]\) 改成 \(f[i][p]+g[i][p]\) 即可。

仿照原来的思路，\(ASB\) 的转移方程如下：

\[g[i][j] = \sum_{p=i+1}^{j-2}\sum_{q=p+1}^{j-1} f[i][p] \times (f[q][j]+g[q][j]),\space s[p+1][q-1] = true \]

代码如下（为了清晰直观，删去取模的过程）：

for(int p=i+1; p <= j-2; p++){
    for(int q=p+1; q <= j-1; q++){
        if(s[p+1][q-1] || q == p+1) g[i][j] += (ULL)f[i][p] * (f[q][j] + g[q][j]);
        else break;
    }
}

按这个思路写对了应该就能拿到 65 pts 了，现在离 AC 还差一个优化。

优化

复杂度瓶颈在 \(ASB\) 的 \(O(n^4)\) 上，所以观察 \(ASB\) 的式子，此时先把 \(i\) 和 \(j\) 当做定值。

后面的 \(f[i][p]\) 的值与 \(q\) 无关，因此我们可以把 \(f[i][p]\) 从最内层的求和里提出来。

\[\sum_{p=i+1}^{j-2}f[i][p]\times\sum_{q=p+1}^{j-1}(f[q][j]+g[q][j]),\space s[p+1][q-1] = true \]

只关注内层的循环，这时如何优化就明显一些了——前缀和。

我们设一个新数组 \(h\)：

\[h[p]=\sum_{t=i+2}^{p}f[t][j]+g[t][j] \]

若忽略 \(s\) 的条件，最内层循环等于 \(h[j-1] - h[p]\)。

再考虑 \(s\)，由于最内层循环在递增的是 \(p\) 而 \(q\) 并不变化——作为条件的区间 \(s\) 是左端点不动向右延伸的——我们可以预处理出每一个位置往后延伸的 * 或者 ? 的最长的长度，记为 \(b[i]\)，则从 \(p+1\) 点最远能延伸到的下标为 \(p+1+b[i]\)。所以我们就可以在每次循环 \(i\) 的时候预处理 \(h\) 数组的值，用 \(h[min(j, p+b[p+1]+1)] - h[p]\) 代替原来最内层的求和了。

因为 \(l\) 递增，所以不用担心 \(f[q][j]\)、\(f[q][j]\) 还没有求（这两个区间肯定比正在求的小）。

（其实建议预处理时直接处理出向后延伸到的最大下标，应该会方便一点，但我懒得改了）

最终代码（代码丑，请见谅）：

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 550;
const int MOD = 1000000007;

typedef unsigned long long ULL;

int inline add(int a, int b){
    return (a%MOD + b%MOD) % MOD;
}

int n, k;
char a[maxn];
int f[maxn][maxn]; // 包含型，后用 F 代替
int g[maxn][maxn]; // 并列型，后用 G 代替
bool s[maxn][maxn]; // a[i:j] 能否构成连续个数小于 k 的 *
int h[maxn], b[maxn];

int main(){

    scanf("%d%d", &n, &k);
    scanf("%s", a+1);

    for(int i=1; i <= n; i++){
        int j;
        for(j=i; j <= n && j-i+1 <= k; j++){
            if(a[j] == '*' || a[j] == '?') s[i][j] = true;
            else break;
        }
        b[i] = j-i;
    }

    for(int l=2; l <= n; l++){
        for(int i=1; i+l-1 <= n; i++){
            int j = i+l-1;

            // 合法的括号序列两端必然分别是左右括号
            if(a[i] != '(' && a[i] != '?' || a[j] != ')' && a[j] != '?') continue;

            if(i+1 == j){ // 单独一对括号 ()
                f[i][j] = 1;
                continue;
            }

            if(s[i+1][j-1]) f[i][j] += 1; // (S)

            f[i][j] = add(f[i][j], add(f[i+1][j-1], g[i+1][j-1])); // (F) 或 (G), 对应 (A)

            for(int p=i+1; p < j-1; p++){ // (SF) 或 (SG), 对应 (SA)
                if(s[i+1][p]) f[i][j] = add(f[i][j], add(f[p+1][j-1], g[p+1][j-1])); 
                else break;
            }

            for(int p=j-1; p > i+1; p--){ // (FS) 或 (GS), 对应 (AS)
                if(s[p][j-1]) f[i][j] = add(f[i][j], add(f[i+1][p-1], g[i+1][p-1])); 
                else break;
            }

            // AB 或者 ASB

            h[i+1] = 0; // 前缀和优化
            for(int p=i+2; p <= j; p++){ 
                h[p] = add(h[p-1], add(f[p][j], g[p][j]));
            }

            for(int p=i+1; p <= j-2; p++){
                // 一定要注意加一个MOD, 我之前没写查了半天
                g[i][j] = add(g[i][j], (ULL)f[i][p] * ((ULL)MOD + h[min(j, p+b[p+1]+1)] - h[p]) % MOD); 
            }
        }
    }

    printf("%d", add(f[1][n], g[1][n]));

    return 0;
}