[LOJ3123] CTSC2019重复

Description

给定一个⻓为 n 的字符串 s , 问有多少个⻓为 m 的字符串 t 满足：

将 t 无限重复后，可以从中截出一个⻓度为 n 且字典序比 s 小的串。

m ≤ 2000 n ≤ 2000

Solution

正难则反，补集转换，用 \(26^m\) 减去“无法从中截出字典序比 s 小的串”的方案数。

方便表述，称字符串t具有特征 \(A\) 当且仅当无法从无限重复的t中截出一段长度为m且字典序比s小的字段即A为任意无限重复的t中长度为m的字典序都比s大。

考虑构造一个有限状态自动机能接受所有满足特征A的串，然后在上面计数，那么我们要统计对于每个节点开头走m条边后回到它自己的方案数（t串是无限长的）。

由于需要满足特征A，所以一个点的出边只有最大的边是有用的，因为满足A的字符串一定不会走更小的边，(要么比s大，要么目前和s一样，比s大对应的是已经接受了一个满足A的串，直接跳到根，和s一样说明要继续走下去)。

于是这就是一个只保留最大转移边的kmp自动机。

并且一个节点只有一条出边，还有许多边指向根，后者之间本质是一样的我们只要记个数即可（代码实现中是edge[i]，表示i点指向根的边数）。

现在考虑如何在上面dp，不难发现这个图很特殊是一个rho，图上的路径只有两种：

• 在环上走m步回到自己，只有当环的大小为m的约数时存在。
• 从自己走若步（比如j步）到根，再从根走m-j步回到自己。

前者直接找环算，后者设 \(f[i][u]\) 表示从根走i步到u的方案数， \(g[i][u]\) 为从u走i步到根的方案数，dp出来后枚举j即可。

\[f[i + 1][v] \leftarrow f[i][u] \\
f[i + 1][0] \leftarrow f[i][u]\times edge[u]\\
g[i + 1][u] \leftarrow g[i][v]
\]

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <fstream>

typedef long long LL;
typedef unsigned long long uLL;

#define SZ(x) ((int)x.size())
#define ALL(x) (x).begin(), (x).end()
#define MP(x, y) std::make_pair(x, y)
#define DE(x) cerr << x << endl;
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define GO cerr << "GO" << endl;

using namespace std;

inline void proc_status()
{
	ifstream t("/proc/self/status");
	cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>()) << endl;
}
inline int read()
{
	register int x = 0; register int f = 1; register char c;
	while (!isdigit(c = getchar())) if (c == '-') f = -1;
	while (x = (x << 1) + (x << 3) + (c xor 48), isdigit(c = getchar()));
	return x * f;
}
template<class T> inline void write(T x)
{
	static char stk[30]; static int top = 0;
	if (x < 0) { x = -x, putchar('-'); }
	while (stk[++top] = x % 10 xor 48, x /= 10, x);
	while (putchar(stk[top--]), top);
}
template<typename T> inline bool chkmin(T &a, T b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, T b) { return a < b ? a = b, 1 : 0; }

const int maxN = 2e3;
const int mod = 998244353;

namespace math
{
	void pls(int &x, int y)
	{
		x += y;
		if (x >= mod) x -= mod;
		if (x < 0) x += mod;
	}
	LL qpow(LL a, LL b)
	{
		LL ans(1);
		while (b)
		{
			if (b & 1)
				ans = ans * a % mod;
			a = a * a % mod;
			b >>= 1;
		}
		return ans;
	}
}
using math::pls;
using math::qpow;

int n, m; //n字符串长度，m走m步
char str[maxN + 2];
int fail[maxN + 2], ver[maxN + 2], edge[maxN + 2];

void insert()
{
	fail[1] = 0;
	for (int i = 2, j = 0; i <= n; ++i)
	{
		while (j and str[j + 1] != str[i]) j = fail[j];
		j += str[j + 1] == str[i];
		fail[i] = j;
	}
}

void build()
{
	for (int i = 0; i <= n; ++i)
	{
		for (int j = 25; j >= 0; --j)
		{
			int p = i;
			if (p == n) p = fail[p];
			while (p and str[p + 1] != j + 'a') p = fail[p];
			p += (str[p + 1] == (j + 'a'));
			if (p)
			{
				ver[i] = p;
				edge[i] = 25 - j;
				break;
			}
		}
	}
}

int size;
int f[maxN + 2][maxN + 2], g[maxN + 2][maxN + 2]; // f[i][u] : root -> u cost i ; g[i][u] : u -> root cost i

void DP()
{
	f[0][0] = 1;
	for (int i = 0; i < m; ++i)
		for (int j = 0; j <= n; ++j)
		{
			pls(f[i + 1][ver[j]], f[i][j]);
			pls(f[i + 1][0], 1ll * f[i][j] * edge[j] % mod);
		}
	for (int i = 0; i <= n; ++i)
		g[1][i] = edge[i];
	for (int i = 2; i <= m; ++i)
		for (int j = 0; j <= n; ++j)
			g[i][j] = g[i - 1][ver[j]];
}

int key;
bool vis[maxN + 2];

bool dfs(int u)
{
	if (!u) return 0;
	if (vis[u]) { key = u; return 1; }
	vis[u] = 1;
	if (dfs(ver[u])) { size++; return key != u; }
	return 0;
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("xhc.in", "r", stdin);
	freopen("xhc.out", "w", stdout);
#endif
	scanf("%d %s", &m, str + 1);
	n = strlen(str + 1);

	insert();
	build();
	DP();
	int ans = 0;
	dfs(1);
	if (m % size == 0)
		ans = size;
	for (int i = 0; i <= n; ++i)
	{
		int sum = 0;
		for (int j = 0; j <= m; ++j)
			pls(sum, 1ll * f[j][i] * g[m - j][i] % mod);
		pls(ans, sum);
	}
	cout << ((qpow(26, m) - ans) % mod + mod) % mod << endl;
	return 0;
}