CSP-S 2021 括号序列

CSP-S 2021 括号序列

这道题考场杀我 $2.5h$，写了两个错误算法，最后写了一个 $O(n^4)$，然后优化成 $O(n^3)$ 了。

题意

一开始读错题了，写了一个多小时的错解。当时以为只要括号都匹配，* 在哪里无所谓，只要连续的不超过 $k$ 就可以。

所以请务必好好读题，接下来解释一下题意，并且引出解题所需的定义:

如果有一个合法序列，这个序列左右两个端点是一对互相匹配的括号，将整个序列括起来，我们称之为 "完全合法序列"。也就是题目中，第三种情况的合法序列。

那么本题中合法情况可以这样描述:

由若干完全合法序列组成，相邻的完全合法序列之间可以有不超过 $k$ 个 * 分隔。

那么根据本题的要求，合法的序列的左端或右端加上不超过 $k$ 个 *，然后在外面加一对括号，就得到了一个完全合法序列。(特别注意，左右不能同时加，但是可以都不加)

特别地，在不超过 $k$ 个 * 外直接加括号也是完全合法序列。

$O(n^4)$ DP

这里 $k$ 作为循环枚举的变量，所以用 $m$ 表示题目中要求最多的连续的 * 的数量。

我们设计状态 $f_{Len, i}$ 表示以 $i$ 为左端点，长度为 $Len$ 的区间为完全合法序列的方案数，$g_{Len, i}$ 表示以 $i$ 为左端点，长度为 $Len$ 的区间为合法序列的方案数。

首先发现任何合法的序列，其左右两端一定分别是 ( 和 )，所以当输入序列左端点是 * 或 ) 或右端点是 * 或 ( 时，两个值都为 $0$。

两端点合法后，考虑转移:

$$f_{Len, i} = g_{Len - 2, i + 1} + \sum_{j = 1}^{min(Len - 2, m)} g_{Len - 2 - j, i + 1 + j} + \sum_{k = 1}^{min(Len - 3, m)}g_{Len - 2 - k, i + 1}$$

第一个转移表示直接在合法序列外加括号，第二个和第三个表示在合法序列的左边或右边加若干 * 后再加括号。

其中 $j$ 枚举过程中需要考虑区间 $[i + 1, i + j]$ 必须都是 * 或 ?，否则直接 break。$k$ 也是一样的，枚举过程中判断当前位置是否可以变成 *。

至于为什么 $k \leq min(Len - 3, m)$，因为对于 $j = Len - 2$ 的情况，表示的是直接在连续的 * 外面加括号，如果 $k = Len - 2$ 再统计一次，就会重复统计。

接下来是 $g$ 的转移:

$$g_{Len, i} = \sum_{j = 0}^{Len - 2} (g_{j, i} * \sum_{k = 0}^{min(Len - j - 2, m)} f_{Len - j - k, i + j + k})$$

这里的转移表示先选一个长度为 $j$ 的合法序列 $[i, i + j - 1]$，然后在它后面加 $k$ 个 *，后面再接一个长度 $Len - j - k$ 的完全合法序列，组成一个新的合法序列。

当然，这里枚举 $k$ 的时候也要判断对应位置是否能赋成 *，否则 break。

枚举边界两个 $-2$ 是因为完全合法序列最短也要 $2$，所以要提前留至少两个长度给最后的完全合法序列。

答案便是 $g_{n, 1}$。

两个 DP 状态都是 $O(n^2)$，$f$ 的转移是 $O(n)$，$g$ 的转移是 $O(n^2)$，总复杂度 $O(n^4)$。

复杂度里面有一个 $n$ 是和连续的 * 的数量有关的，所以随机数据下 $O(n^4)$ 跑 $500$ 飞快。

优化到 $O(n^3)$

发现算法的瓶颈在于转移 $g$ 的时候，枚举中间的 * 的数量。

这时候，增加一个状态 $g_{Len, i, 0}$ 表示的信息和之前的 $g$ 相同，加一个 $g_{Len, i, 1}$ 表示这个区间内，除去右端的 $(0, m]$ 个 *，左边留下的是非空的合法序列的方案数。

这个状态不是一般的好求

$$g_{Len, i, 1} = \sum_{j = 1}^{min(Len - 2, m)} g_{Len - j, i, 0}$$

转移意义为在合法序列后加 $j$ 个 *。

这个 $j$ 枚举时仍要判断对应位置是否能取 *，否则 break。

然后就可以把 $g_{Len, i, 0}$ 的转移优化到 $O(n)$。

$$g_{Len, i, 0} = \sum_{j = 0}^{Len - 2} ((g_{j, i, 0} + g_{j, i, 1}) * f_{Len - j, i + j}))$$

转移表示合法序列还是合法序列后加 $(0, m]$ 个 *，这些情况后面加完全和法序列，一定能得到合法序列。

总复杂度优化到了 $O(n^3)$。

而且这时 $f$ 的转移也简化了。

$$f_{Len, i} = g_{Len - 2, i + 1, 0} + g_{Len - 2, i + 1, 1} + \sum_{j = 1}^{min(Len - 2, m)} g_{Len - 2 - j, i + 1 + j, 0}$$

接下来是去掉缺省源的考场代码:

unsigned long long Mod(1000000007);
unsigned long long f[505][505], g[505][505][2];
unsigned n, m;
unsigned A, B, C, D;
unsigned Cnt(0), Ans(0), Tmp(0);
char a[505];
signed main() {
  n = RD(), m = RD();
  scanf("%s", a + 1);
  for (unsigned i(n); i; --i) g[0][i][0] = f[0][i] = 1;
  for (unsigned Len(2); Len <= n; ++Len) {
    for (unsigned i(n - Len + 1); i; --i) {
      for (unsigned len(1); len < Len && len <= m; ++len) {
        if((a[i + Len - len] == '(') || (a[i + Len - len] == ')')) break;
        g[Len][i][1] += g[Len - len][i][0];
        if(g[Len][i][1] >= Mod) g[Len][i][1] -= Mod;
      }
      if((a[i] == '*') || (a[i] == ')') || (a[i + Len - 1] == '*') || (a[i + Len - 1] == '(')) {
        continue;
      }
      unsigned Tol(min(Len - 2, m));
      f[Len][i] = g[Len - 2][i + 1][0] + g[Len - 2][i + 1][1];
      if(f[Len][i] >= Mod) f[Len][i] -= Mod; 
      for (unsigned len(1); len <= m && len + 2 <= Len; ++len) {
        if((a[i + len] == '(') || (a[i + len] == ')')) break;
        f[Len][i] += g[Len - 2 - len][i + len + 1][0]; 
        if(f[Len][i] >= Mod) f[Len][i] -= Mod; 
      }
      g[Len][i][0] = f[Len][i];
      for (unsigned len(2); len + 2 <= Len; ++len) {
        g[Len][i][0] = (g[Len][i][0] + g[len][i][1] * f[Len - len][i + len]) % Mod;
      }
      for (unsigned len(2); len + 2 <= Len; ++len) {
        g[Len][i][0] = (g[Len][i][0] + g[len][i][0] * f[Len - len][i + len]) % Mod;
      }
    }
  }
  printf("%llu\n", g[n][1][0]);
	return 0;
}