题解 [NOIP2022] T1 种花

题解 P8865 [NOIP2022] 种花

$\text{Update:}$
$2022.12.04:$ 改进了文章中难（guǐ）懂（yì）的函数；
$2022.12.07:$ 更改了题解代码中打错的变量名；
$2022.12.07:$ 更新了同步官方数据后的评测记录。

简要题意

给出一个 $n\times m$ 的网格图，求其中有多少种 $\text{C-}$ 形种花方案，多少种 $\text{F-}$ 形种花方案。其中 $\text{C}$ 与 $\text{F}$ 两横可以不一样长，但两横之间必须有空行，$\text{F}$ 最后一横的下方的竖必须出头。

拿到题先看数据范围：

对于所有数据，保证：$1\le T\le 5$，$1\le n,m\le 10^3$

所以本题考虑 $\mathcal{O}(T{n}^2)$ 算法。

注：本题解的代码中所有的 $k$ 均与题目描述中的 $a$ 含义相同，即是否为土坑。

$\text{C-}$ 形种花方案的处理

约定：每个 $\text{C-}$ 形方案左上角的那一个点为该方案的顶点。

我们将 $right[i][j]$ 定义为点 $(i,j)$ 右侧连续 $0$ 的个数。（后面会用到）
那么可以在 $\mathcal{O}(n^2)$ 的复杂度完成这一操作：
$$right[i][j]=\{\begin{array}{ll}right[i][j+1]+1& a[i][j]=a[i][j+1]=0\\ 0& \text{Otherwise.}\end{array}$$

for (int i = 1; i <= n; ++i) 
	for (int j = m - 1; j >= 1; --j) 
		if (! k[i][j] && ! k[i][j + 1]) 
		right[i][j] = right[i][j + 1] + 1;

若有这样一个 $3\times 3$ 的网格图：

那么 $\text{C-}$ 形 种花情况一共有如下四种：

显然，该情况的方案数为 $right[1][1]\times right[3][1]=2\times 2=4$。

那如果不止两行可以组成 $\text{C-}$ 形呢？

来看如下 $5\times 3$ 的网格图：

同理，以 $(1,1)$ 为顶点 的 $\text{C-}$ 形方案数为 $right[1][1]\times right[3][1]+right[1][1]\times right[4][1]+right[1][1]\times right[5][1]$

推广：以 $(i,j)$ 为顶点的 $\text{C-}$ 形方案数 $ansc[i][j]=right[i][j]\times \boxed{\sum _{k=i+2}^{a[k+1]=1}right[k][j]}$。

于是对于每一点，计算的时间复杂度为 $\mathcal{O}(n)$，总时间复杂度退化到了 $\mathcal{O}(n^3)$。

怎么处理呢？
我们不妨定义 $sumc[i][j]=\sum _{k=i}^{a[k+1]=1}right[k][j]$。

那么：
$$sumc[i][j]=\{\begin{array}{ll}sumc[i+1][j]+right[i][j]& a[i][j]=0\\ 0& \text{Otherwise.}\end{array}$$

故可以提前用 $\mathcal{O}(n^2)$ 的复杂度计算 $sumc[i][j]$ :

for (int j = 1; j <= m; ++j)
	for (int i = n; i >= 1; --i) 
		if (! k[i][j]) {
		sumc[i][j] = sumc[i + 1][j] + right[i][j] * 1ll;

所以 $ansc[i][j]=right[i][j]\times sumc[i+2][j]$。单点计算复杂度提升到 $\mathcal{O}(1)$。

故 $\text{C-}$ 形总方案数：
$$vc=\sum _{i=1}^n\sum _{j=1}^{m}right[i][j]\times sumc[i+2][j].$$

for (int i = 1; i <= n; ++i) {
	for (int j = 1; j <= m; ++j) {
		if (k[i + 1][j]) continue;
		vc = (vc + right[i][j] * down[i + 2][j]) % mod;
	}
}

$\text{C-}$ 形方案计算完结。

$\text{C-}$ 形方案 std:

for (int i = 1; i <= n; ++i)
	for (int j = m - 1; j >= 1; --j)
		if (!k[i][j] && !k[i][j + 1])
		right[i][j] = right[i][j + 1] + 1;
for (int j = 1; j <= m; ++j)
	for (int i = n; i >= 1; --i)
		if (!k[i][j]) 
		sumc[i][j] = sumc[i + 1][j] + right[i][j] * 1ll;
for (int i = 1; i <= n; ++i) {
	for (int j = 1; j <= m; ++j) {
		if (k[i + 1][j]) continue;
		vc = (vc + right[i][j] * sumc[i + 2][j]) % mod;
	}
}

$\text{F-}$ 形种花方案的处理

约定：每个 $\text{F-}$ 形方案左上角的那一个点为该方案的顶点。

$\text{F-}$ 形与 $\text{C-}$ 形大同小异，只需要多处理一下出头的方案数。

这里，我们需要引进一个数组 $down$，$down[i][j]$ 表示 $(i,j)$ 的下方有多少个连续的 $0$。（可以参考 $right[i][j]$ 的定义规则）
跟 $right$ 数组一样，先用 $\mathcal{O}(n^2)$ 的复杂度预处理出 $down$ 数组：
$$down[i][j]=\{\begin{array}{ll}down[i+1][j]+1& a[i+1][j]=a[i][j]=0\\ 0& \text{Otherwise.}\end{array}$$

for (int j = 1; j <= m; ++j)
	for (int i = n - 1; i >= 1; --i)
		if (! k[i][j] && ! k[i + 1][j])
		down[i][j] = down[i + 1][j] + 1;

仿照 $\text{C-}$ 形种花方案来探讨，若有如下 $5\times 3$ 的网格图：

那么共有如下 $8$ 种情况：

显然，对于这顶点为 $(1,1)$ 的$\text{F-}$ 形种花方案为：
$sumf[1][1]=right[1][1]\times right[3][1]\times down[3][1]$。
因为对于 $\text{F-}$ 形的第二横可以在不同横行，所以对于同一个顶点来说最坏运算 $n$ 次。
同 $\text{C-}$ 形的讨论我们可以得知这样计算的时间复杂度同样退化到了 $\mathcal{O}(n^3)$。
同 $\text{C-}$ 形的方法处理：
定义 $sumf[i][j]=\sum _{k=i}^{a[k+1]=1}right[k][j]\times down[k][j]$。

那么：
$$sumf[i][j]=\{\begin{array}{ll}sumf[i+1][j]+right[i][j]\times down[i][j]& a[i][j]=0\\ 0& \text{Otherwise.}\end{array}$$

故同样可以提前用 $\mathcal{O}(n^2)$ 的复杂度计算 $sumf[i][j]$ :

for (int j = 1; j <= m; ++j) 
	for (int i = n - 1; i >= 1; --i) 
		if (!k[i][j]) 
		sumf[i][j] = sumf[i + 1][j] + right[i][j] * 1ll * down[i][j];

故 $\text{F-}$ 形总方案数：
$$fc=\sum _{i=1}^n\sum _{j=1}^{m}right[i][j]\times sumf[i+2][j].$$

for (int i = 1; i <= n; ++i) {
	for (int j = 1; j <= m; ++j) {
		if (k[i + 1][j]) continue;
		vf = (vf + right[i][j] * sumf[i + 2][j]) % mod;
	}
}

$\text{F-}$ 形种花方案推倒及计算也到此结束。

$\text{F-}$ 形方案 std:

在 $\text{C-}$ 形计算时处理过的数组处理代码不再展示（如 $right$ 等）。

for (int j = 1; j <= m; ++j)
	for (int i = n - 1; i >= 1; --i)
		if (! k[i][j] && ! k[i + 1][j])
		down[i][j] = down[i + 1][j] + 1;
for (int j = 1; j <= m; ++j) 
	for (int i = n; i >= 1; --i) 
		if (!k[i][j])
		sumf[i][j] = sumf[i + 1][j] + right[i][j] * 1ll * down[i][j];
for (int i = 1; i <= n; ++i) {
	for (int j = 1; j <= m; ++j) {
		if (k[i + 1][j]) continue;
		vf = (vf + right[i][j] * sumf[i + 2][j]) % mod;
	}
}

至此，本题已解答完毕，总时间复杂度为 $\mathcal{O}(T{n}^2)$。

$\text{std:}$

使用 $right$ 来定义变量名会引起歧义，故代码中统一使用 $Right$ 替代。

#include 

using namespace std;

template <class type>
void read(type& x) {
    type s = 0;
    int w = 1;
    char c = getchar();
    while (c < '0' || c > '9') {
        if (c == '-') w = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9') {
        s = (s << 3) + (s << 1) + (c ^ 48);
        c = getchar();
    }
    x = s * w;
}

const int N = 1e3 + 10;
const int mod = 998244353;
int t, id, n, m, c, f;
bool k[N][N];
int down[N][N];
int Right[N][N];
long long sumc[N][N], sumf[N][N], vc, vf;
int main() {
    //  freopen("plant.in", "r", stdin);
    //  freopen("plant.out", "w", stdout);
    read(t), read(id);
    while (t--) {
        read(n), read(m), read(c), read(f);
        vc = vf = 0;
        memset(Right, 0, sizeof(Right));
        memset(sumc, 0, sizeof(sumc));
        memset(sumf, 0, sizeof(sumf));
        memset(down, 0, sizeof(down));
        //一定记得memset，考场上就这样挂掉了
        memset(k, 0, sizeof(k));
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                char c; cin >> c;
                k[i][j] = c ^ 48;
            }
        }
        for (int i = 1; i <= n; ++i)
            for (int j = m - 1; j >= 1; --j)
                if (!k[i][j] && !k[i][j + 1])
                Right[i][j] = Right[i][j + 1] + 1;
        for (int j = 1; j <= m; ++j)
            for (int i = n; i >= 1; --i)
                if (!k[i][j]) 
                sumc[i][j] = sumc[i + 1][j] + Right[i][j] * 1ll;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                if (k[i + 1][j]) continue;
                vc = (vc + Right[i][j] * sumc[i + 2][j]) % mod;
            }
        }
        for (int j = 1; j <= m; ++j)
            for (int i = n - 1; i >= 1; --i)
                if (! k[i][j] && ! k[i + 1][j])
                down[i][j] = down[i + 1][j] + 1;
        for (int j = 1; j <= m; ++j) 
            for (int i = n; i >= 1; --i) 
                if (!k[i][j])
                sumf[i][j] = sumf[i + 1][j] + Right[i][j] * 1ll * down[i][j];
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                if (k[i + 1][j]) continue;
                vf = (vf + Right[i][j] * sumf[i + 2][j]) % mod;
            }
        }
        printf("%lld %lld\n", c * vc, f * vf);
    }
    return 0;
}

总的来说速度还行，与预期差别不大：

---

完结撒花~~~

第一次给 NOIP 写题解，有问题欢迎留言评论，有帮助记得点赞哦~