传送门

首先这个题目显然就是先求出所有的 \(border\)，问题转化成一个可行性背包的问题

一个方法就是同余类最短路，裸跑 \(30\) 分，加优化 \(50\) 分

首先有个性质

\(border\) 分成的等差数列的个数不超过 \(log\)

和回文树的性质的证明类似瞎画图一下就行了

我们注意到可以一个一个等差数列的更新最短路

要做到这个，必须能从之前的等差数列的模数 \(n\) 转移到当前等差数列的 \(x\)

假设模 \(n\) 的最短路为 \(f\)，模 \(x\) 的为 \(g\)

只需要 \(f_i\) 更新 \(g_{f_i~mod~x}\) 之后 \(g\) 自己通过添加 \(n\) 更新即可

现在考虑 \(g\) 每次 \(+n\) 更新

注意到把每次 \(+n\) 的下标弄出来，一定是若干个环，环之间独立

显然每个的最小值不会再次更新，那么找到这个点就变成了链，然后一个个向后 \(+n\) 更新即可

再考虑每个等差数列的内部更新，模数我们选择首项 \(x\)，这样才比较可做

设公差为 \(d\)，长度为 \(len\)

同样的，把每次 \(+d\) 的下标弄出来，还是若干个独立的环

找到最小值的位置编号 \(0\) 对变成的链向后一一编号

那么对于第 \(i\) 个点，可以从 \(j\) 加上 \(x+d\times(i-j)\) 转移，这样的 \(j\) 必须满足 \(i-j<len\)

这个东西显然可以单调队列优化一波

然后就可能可以通过这一题了

关于被hack这件事情，卡卡常就好了

# include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn(5e5 + 5);

int test, n, nxt[maxn], len[maxn], cnt, vis[maxn], idx, id[maxn];

ll w, ans, f[maxn], g[maxn], inf, que[maxn];

char s[maxn];

queue <int> q;

inline void Calc(int lst, int u, int d, int num) {

	int i, j, k, mnp, hd, tl;

	for (i = 0; i < lst; ++i) g[i] = f[i];

	for (i = 0; i < u; ++i) f[i] = inf;

	for (i = 0; i < lst; ++i) if (g[i] != inf) f[g[i] % u] = min(f[g[i] % u], g[i]);

	++idx;

	for (i = 0; i < u; ++i)

		if (vis[i] != idx) {

			mnp = i, vis[i] = idx;

			for (j = (i + lst) % u; j ^ i; j = (j + lst) % u) {

				if (f[j] < f[mnp]) mnp = j;

				vis[j] = idx;

			}

			for (k = mnp, j = (mnp + lst) % u; j ^ mnp; k = j, j = (j + lst) % u)

				f[j] = min(f[j], f[k] + lst);

		}

	++idx;

	for (i = 0; i < u; ++i)

		if (vis[i] != idx) {

			mnp = i, vis[i] = idx, hd = 0, tl = -1;

			for (j = (i + d) % u; j ^ i; j = (j + d) % u) {

				if (f[j] < f[mnp]) mnp = j;

				vis[j] = idx;

			}

			que[0] = f[mnp], id[++tl] = 0;

			for (k = 1, j = (mnp + d) % u; j ^ mnp; j = (j + d) % u, ++k) {

				while (hd <= tl && k - id[hd] >= num) ++hd;

				if (hd <= tl) f[j] = min(f[j], que[hd] + u + (ll)(k - id[hd]) * d);

				while (hd <= tl && que[tl] - (ll)id[tl] * d > f[j] - (ll)k * d) --tl;

				que[++tl] = f[j], id[tl] = k;

			}

		}

}

inline void Solve() {

	int i, j, u, d, lst;

	scanf("%d%lld", &n, &w), ans = 0;

	scanf(" %s", s + 1);

	for (i = 2, j = 0; i <= n; ++i) {

		while (j && s[i] != s[j + 1]) j = nxt[j];

		j += s[i] == s[j + 1], nxt[i] = j;

	}

	cnt = 0, j = n;

	while (j) len[++cnt] = n - nxt[j], j = nxt[j];

	sort(len + 1, len + cnt + 1), --cnt;

	memset(f, 63, sizeof(f)), inf = f[0];

	f[n % len[1]] = n, u = lst = n;

	reverse(len + 1, len + cnt + 1);

	for (i = 1; i < cnt; i = j) {

		d = len[i] - len[i + 1], j = i + 1;

		while (j <= cnt && len[j - 1] - len[j] == d) ++j;

		u = len[j - 1], Calc(lst, u, d, j - i), lst = u;

	}

	if (cnt) u = len[cnt], Calc(lst, u, 0, 1);

	for (i = 0; i < u; ++i) if (f[i] <= w) ans += (w - f[i]) / u + 1;

	printf("%lld\n", ans);

}

int main() {

	scanf("%d", &test);

	while (test) --test, Solve();

	return 0;

}