AT5697「AGC041F」Histogram Rooks

Address

AT5697

Algorithm 1

考慮每次取出區間中 $h$ 的最小值建出笛卡爾樹，令每個結點表示一個區間，從葉子結點往上 DP。

考慮對每個區間內的所有列分類，設當前處理的高度爲 $x$：

1. 在高度大於 $x$ 的某個位置存在一個 車，現在可以任意填放 車；
2. 在高度大於 $x$ 的所有位置都不存在 車，但這些位置都被其它 車 覆蓋；
3. 在高度大於 $x$ 的所有位置都不存在 車，且這些位置中存在至少一個位置沒有被其它 車 覆蓋。

設 $f_{s,i,j}$ 表示在結點 $s$ 有 $i$ 個 1 類列、$j$ 個 2 類列的方案數，兩個子區間的方案顯然可以直接合並。

依次考慮結點 $s$ 自身所包含的每個行連續段 車 的放置方案，設區間長度爲 $len$，容易得到如下轉移：

• 不放置任何 車：

$\begin{aligned}f'_{s,i + j,0} = f'_{s,i + j,0} + f_{s,i,j} \end{aligned}$

• 只在 1 類列放置 車：

$\begin{aligned} f'_{s,i,j} = f'_{s,i,j} + (2^i - 1)f_{s,i,j} \end{aligned}$

• 在 2 類列和 3 類列放置任意數量（至少爲 $1$）的 車，此時 1 類列可以任意放置 車：
  $\begin{aligned}f'_{s,i + x + y,j-x} = f'_{s,i + x + y,j-x} + 2^iC_j^xC_{len - i - j}^{y}f_{s,i,j}(0 \le x \le j, 0 \le y \le len - i -j, x + y > 0)\end{aligned}$

直接實現是 $\mathcal O(N^5)$ 的，考慮優化狀態。

注意到如果我們假定接下來填的每一行都至少有一個 車，那麼所有 2 類列都可以看做 1 類列，否則都可以看做 3 類列。

於是我們可以在狀態中額外記錄一維 $0/1$ 表示接下來填的每一行是否都至少有一個 車，就可以把 2 類列的數量併到 1 類列或者 3 類列中去。

類似地得到所有轉移，時間複雜度 $\mathcal O(N^3)$。

Code 1

#include <bits/stdc++.h>

const int N = 1e4 + 5;
const int mod = 998244353;
int len[N], c[N][N], ex[N], f[N][N], g[N][N], tf[N], tg[N], h[N];
int n, T, rt;

inline void add(int &x, int y)
{
	x += y;
	x >= mod ? x -= mod : 0;
}

inline void dec(int &x, int y)
{
	x -= y;
	x < 0 ? x += mod : 0;
}

inline void Update(int now, int x)
{
	for (int i = 0; i <= len[x] + len[now]; ++i)
		tf[i] = tg[i] = 0;
	for (int i = 0; i <= len[x]; ++i)
		for (int j = 0; j <= len[now]; ++j)
		{
			tf[i + j] = (1ll * f[x][i] * f[now][j] + tf[i + j]) % mod;
			tg[i + j] = (1ll * g[x][i] * g[now][j] + tg[i + j]) % mod;
		}
	len[now] += len[x];
	for (int i = 0; i <= len[now]; ++i)
		f[now][i] = tf[i], g[now][i] = tg[i];
}

inline int solve(int l, int r, int lst)
{
	if (l > r)
		return 0;
	
	int mid = l, now = ++T;
	for (int i = l + 1; i <= r; ++i)
		if (h[i] < h[mid])
			mid = i;

	int lc = solve(l, mid - 1, h[mid]),
		rc = solve(mid + 1, r, h[mid]);
	f[now][0] = g[now][0] = len[now] = 1;
	if (lc)	
		Update(now, lc);
	if (rc)
		Update(now, rc);
	int _len = len[now];
	for (int i = 1; i <= h[mid] - lst; ++i)
	{
		for (int j = 0; j <= _len; ++j)
			tf[j] = tg[j] = 0;
		if (i == 1)
		{
			int delta = 0;
			for (int j = l; j <= r; ++j)
				if (h[j] == h[mid])
					++delta;
			_len -= delta;
			for (int j = 0; j <= _len; ++j)
			{
				tf[j + delta] = (1ll * f[now][j] * (ex[j] - 1) + tf[j + delta]) % mod;
				tg[j] = (1ll * g[now][j] * (ex[j] - 1) + tg[j]) % mod;

				add(tf[j], g[now][j]);
				add(tg[j], g[now][j]);
				for (int a = 0; j + a <= _len; ++a)
					for (int b = 0; b <= delta; ++b)
						if (a + b > 0)
						{
							int tmp = 1ll * c[_len - j][a] * c[delta][b] % mod * ex[j] % mod;
							tf[j + a + delta] = (1ll * tmp * f[now][j] + tf[j + a + delta]) % mod;
							tg[j + a + b] = (1ll * tmp * g[now][j] + tg[j + a + b]) % mod;
						}
			}
			_len += delta;
		}
		else
		{
			for (int j = 0; j <= _len; ++j)
			{
				tf[j] = (1ll * f[now][j] * (ex[j] - 1) + tf[j]) % mod;
				tg[j] = (1ll * g[now][j] * (ex[j] - 1) + tg[j]) % mod;		

				add(tf[j], g[now][j]);
				add(tg[j], g[now][j]);

				for (int k = 1; j + k <= _len; ++k)
				{
					tf[j + k] = (1ll * f[now][j] * c[_len - j][k] % mod * ex[j] + tf[j + k]) % mod;
					tg[j + k] = (1ll * g[now][j] * c[_len - j][k] % mod * ex[j] + tg[j + k]) % mod;
				}
			}
		}
		for (int j = 0; j <= _len; ++j)
			f[now][j] = tf[j], g[now][j] = tg[j];
	}
	return now;
}

int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &h[i]);

	ex[0] = 1;
	for (int i = 1; i <= n; ++i)
		add(ex[i] = ex[i - 1], ex[i - 1]);
	c[0][0] = 1;
	for (int i = 1; i <= n; ++i)
	{
		c[i][0] = 1;
		for (int j = 1; j <= i; ++j)
			add(c[i][j] = c[i - 1][j - 1], c[i - 1][j]);
	}

	rt = solve(1, n, 0);
	printf("%d\n", f[rt][n]);
	return 0;
}

Algorithm 2

考慮容斥，即欽定若干個方格沒有被 車 覆蓋，求出此時的方案數，容斥係數爲 $(-1)^{方格個數}$。

注意到如果一個方格被欽定，方格所在的列一定沒有 車。

於是我們在狀態中記錄欽定沒有 車 的列的數量，設 $f_{s,i}$ 表示在結點 $s$ 共有 $i$ 列欽定沒有 車 的容斥係數乘上方案數的和。

兩個子區間的合併只需要考慮中間新增的那一列是否被欽定即可。

對於填每個行連續段的情況，我們同樣進行一些討論，設區間長度爲 $len$，共有 $i$ 列欽定沒有 車：

1. 若連續段中沒有選擇任何一個方格欽定沒有被 車 覆蓋，方案數爲 $2^{len - i}$；
2. 若連續段中選擇了一些方格欽定沒有被 車 覆蓋，連續段中不能再填 車，容斥係數和爲 $\sum \limits_{k = 1}^{i}(-1)^kC_{i}^{k} = -[i \neq 0]$。

因此轉移前的係數和爲 $2^{len - i} - [i \neq 0]$。

但這樣做是有一些問題的，因爲我們無法保證欽定的列中都有方格被選。

考慮再次容斥，我們欽定有 $j$ 列在第一次欽定後沒有方格被選，容斥係數爲 $(-1)^j$。

那麼只有第二種情況的係數和變爲了 $\sum \limits_{k = 1}^{i - j}(-1)^kC_{i}^{k} = -[i \neq j]$，總的係數和爲 $2^{len - i} - [i \neq j]$。

因此我們並不關心 $j$ 的取值，只需要在狀態中額外記錄一維表示 $i$ 是否等於 $j$ 即可。

時間複雜度 $\mathcal O(N^2)$。

Code 2

#include <bits/stdc++.h>

const int N = 1e4 + 5;
const int mod = 998244353;
int len[N], ex[N], f[N][N], g[N][N], h[N];
int n, T, rt;

inline int quick_pow(int x, int k)
{
	int res = 1;
	while (k)
	{
		if (k & 1)
			res = 1ll * res * x % mod;
		x = 1ll * x * x % mod;
		k >>= 1;
	}
	return res;
}

inline void add(int &x, int y)
{
	x += y;
	x >= mod ? x -= mod : 0;
}

inline void dec(int &x, int y)
{
	x -= y;
	x < 0 ? x += mod : 0;
}

inline int solve(int l, int r, int lst)
{
	if (l > r)
		return 0;
	
	int mid = l, now = ++T;
	for (int i = l + 1; i <= r; ++i)
		if (h[i] < h[mid])
			mid = i;

	int lc = solve(l, mid - 1, h[mid]),
		rc = solve(mid + 1, r, h[mid]);
	for (int i = 0; i <= len[lc]; ++i)
		for (int j = 0; j <= len[rc]; ++j)
		{
			int t = i + j;
			int a = 1ll * f[lc][i] * f[rc][j] % mod,
				b = (1ll * g[lc][i] * (f[rc][j] + g[rc][j]) + 1ll * f[lc][i] * g[rc][j]) % mod;
			add(f[now][t], a);
			add(g[now][t], b);
			dec(f[now][t + 1], a);
			add(g[now][t + 1], a);
		}
	len[now] = len[lc] + len[rc] + 1;
	for (int j = 0; j <= len[now]; ++j)
	{
		f[now][j] = 1ll * f[now][j] * quick_pow(ex[len[now] - j], h[mid] - lst) % mod;
		g[now][j] = 1ll * g[now][j] * quick_pow(ex[len[now] - j] - 1, h[mid] - lst) % mod;
	}
	return now;
}

int main()
{
	f[0][0] = 1;
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i)
		scanf("%d", &h[i]);

	ex[0] = 1;
	for (int i = 1; i <= n; ++i)
		add(ex[i] = ex[i - 1], ex[i - 1]);
	rt = solve(1, n, 0);

	int ans = 0;
	for (int i = 0; i <= n; ++i)
	{
		add(ans, f[rt][i]);
		add(ans, g[rt][i]);
	}
	printf("%d\n", ans);
	return 0;
}