Atcoder Regular Contest 060 题解

ARC060C. Tak and Cards *1583

简单题。考虑一个非常非常常见的 Trick。把区间平均值为 $k$ 转化为区间和为 $0$ 只需要将每个数都减去 $k$ 即可。然后就是一个朴素的背包求和为 $0$ 方案数。注意处理负数下标就好了。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MAXN = 55; 
LL n, a, A[MAXN], DP[MAXN][5005], delta = 2500;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> a;
	for(LL i = 1; i <= n; i ++) 
	{
		cin >> A[i];
		A[i] -= a;
	}
	DP[0][delta] = 1;
	for(int i = 1; i <= n; i ++)
	{
		for(int j = 0; j <= 5000; j ++)
		{
			if(j >= A[i]) DP[i][j] = DP[i - 1][j] + DP[i - 1][j - A[i]];
			else DP[i][j] = DP[i - 1][j];
		}
	}
	cout << DP[n][delta] - 1 << '\n';
	return 0;
} 

ARC060D. Digit Sum *2261

非常神的题，但是我自己想到了。

根号分治。首先如果 $b\le \sqrt{n}$，那么直接暴力枚举求得数位和是否为 $s$。

如果 $b>\sqrt{n}$，我们注意到有一个结论，其最小的可能的进制就是 $\frac{n-s}{i}+1$。注意这里要保证 $n-s$ 是 $i$ 的倍数。记 $p=\frac{n-s}{i}+1$，最后还要判断一下 $f(p,n)$ 是否等于 $s$。然后我们就做完了。注意要特判一下，如果这里的 $p=1$，那么我们直接扔掉。不扔掉的话会死循环寄掉。

然后做完了，代码不长但根号分治一般都很神。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n, s;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> s;
	if(n < s)
	{
		cout << -1 << '\n';
		return 0;
	}
	for(LL i = 2; i <= (LL)sqrt(n); i ++)
	{
		LL sum = 0, nn = n;
		while(nn > 0)
		{
			sum += (nn % i);
			nn /= i;
		}
		if(sum == s) 
		{
			cout << i << '\n';
			return 0;
		}
	}
	LL minnum = 1e15 + 7;
	if(s == n) minnum = min(minnum, n + 1);
	for(LL i = 1; i <= sqrt(n); i ++)
	{
		if((n - s) % i != 0) continue;
		LL b = (n - s) / i + 1;
		if(b == 1) continue;
		LL sum = 0, nn = n;
		while(nn > 0)
		{
			sum += (nn % b);
			nn /= b;
		}
		if(sum == s) minnum = min(minnum, b);
	}
	if(minnum == 1e15 + 7) cout << -1 << '\n';
	else cout << minnum << '\n'; 
	return 0;
}

ARC060E. Tak and Hotels *2154

倍增优化动态规划，我应该还是第一次理解这个东西。朴素的暴力就是暴力枚举，这里不做过多讲解。

考虑正解，设 $f_{i,j}$ 为从 $i$ 跳 $2^j$ 步能跳到的最远点。然后每次 Query 的时候你都往上调，基本就类似最近公共祖先 LCA 的那种求法随便倍增。然后就做完了。注意一下处理 $f_{i,0}$ 的细节。还有数组空间别开小（我就因为这个赛时没过 E 题）

然后就做完了。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MAXN = 100005;
LL n, A[MAXN], L, Q, DP[MAXN][25];
LL Query(LL a, LL b)
{
	LL now = a, ans = 0;
	for(LL i = 24; i >= 0; i --)
		if(DP[now][i] < b) 
		{
			ans += (1 << i);
			now = DP[now][i];
		}
	return ans + 1;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n;
	for(LL i = 1; i <= n; i ++) cin >> A[i];
	cin >> L;
	memset(DP, 0x3f, sizeof(DP));
	for(LL i = 1; i <= n; i ++)
	{
		LL Pos = upper_bound(A + 1, A + n + 1, A[i] + L) - A - 1;
		DP[i][0] = Pos;
	}
	for(LL j = 1; j <= 24; j ++)
		for(LL i = 1; i <= n; i ++)
			DP[i][j] = DP[DP[i][j - 1]][j - 1];
	cin >> Q;
	while(Q --)
	{
		LL a, b;
		cin >> a >> b;
		if(a > b) swap(a, b);
		cout << Query(a, b) << '\n';
	}
	return 0;
}

ARC060F. Best Representation *2804

Subtask 1：$|s|\le 4000$

考虑一个 $O(n^2)$ 的做法。看到划分想到动态规划。这个应该是简单的，设 $f_i$ 表示前 $i$ 个能划分的最少子串个数。$g_i$ 表示划分成最少子串个数的方案数。但是我们需要一个 $Q_{i,j}$ 表示 $i$ 到 $j$ 的子串是否是好串。

注意到好串的定义就是之前题目里面的 Power Strings。然后就递推跑 KMP，应该是跑 $n$ 遍 KMP，每次跑 $i$ 到 $n$ 这个子串，预处理出 $Q_{i,j}$。动态规划的时间复杂度是 $O(n^2)$，跑 $n$ 遍 KMP 的时间复杂度也是 $O(n^2)$，所以总复杂度就是 $O(n^2)$，然后就做完了。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4005;
const int MOD = 1e9 + 7;
string s;
int n, KMP[MAXN], Q[MAXN][MAXN], f[MAXN], g[MAXN];
int main()
{
	cin >> s; n = s.length(); s = ' ' + s; 
	for(int i = 1; i <= n; i ++)
		for(int j = i; j <= n; j ++)
			Q[i][j] = 1;
	for(int i = 1; i <= n; i ++)
	{
		memset(KMP, 0, sizeof(KMP)); 
		int k = 0;
		for(int j = 2; j <= n - i + 1; j ++)
		{
			while(k > 0 && s[j + i - 1] != s[k + i]) k = KMP[k];
			if(s[j + i - 1] == s[k + i]) k ++;
			KMP[j] = k;
			if(j % (j - KMP[j]) == 0 && j / (j - KMP[j]) >= 2) Q[i][i + j - 1] = 0;
		}
	}
	memset(f, 0x3f, sizeof(f));
	f[0] = 0;
	for(int i = 1; i <= n; i ++)
	{
		for(int j = 0; j < i; j ++)
		{
			if(Q[j + 1][i] == 0) continue;
			if(f[j] + 1 == f[i]) g[i] = (g[i] + 1) % MOD;
			else if(f[j] + 1 < f[i])
			{
				f[i] = f[j] + 1;
				g[i] = 1;
			}
		} 
	}
	cout << f[n] << '\n' << g[n] << '\n'; 
	return 0;
}

Subtask 2：$|s|\le 5\times {10}^5$

首先特判：

1. 如果字符串内的元素全部相等，那么必然要划分成 $n$ 个串，个数就是 $1$ 个。
2. 如果字符串没有长度 $>1$ 的周期或者 $|s|=1$，那么可以不用划分，最小划分个数就是 $1$，个数也是 $1$。

后面有一个非常强的结论，我不想证。就是如果存在周期长度 $>1$，那么一定可以从第一个字符后面切开，使这个字符串变为两个串，那么这两个串一定不是 Power Strings。这点通过对于暴力 $f$ 数组的打表也可以发现，所以这种情况的最小划分个数就是 $2$。

然后怎么计数呢？因为是划分成两段，所以我们很自然的想到枚举分界点，然后看前面一段是不是 Power Strings，然后看后面一段是不是 Power Strings，因为 KMP 跑出的 border 具有对称性，所以可以通过正反串两次 KMP 得出答案。最后判断是 $O(1)$ 的，上面讲过怎么判断 Power Strings。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
string s, t;
int n, KMP[MAXN], KMP2[MAXN];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> s; n = s.length(); s = ' ' + s; 
	bool Flag = true;
	for(int i = 2; i <= n; i ++) if(s[i] != s[i - 1]) Flag = false;
	if(Flag)
	{
		cout << n << '\n' << 1 << '\n';
		return 0;
	}
	for(int i = n; i >= 1; i --) t += s[i];
	t = ' ' + t;
	for(int i = 2, j = 0; i <= n; i ++)
	{
		while(j > 0 && s[i] != s[j + 1]) j = KMP[j];
		if(s[i] == s[j + 1]) j ++;
		KMP[i] = j;
	}
	for(int i = 2, j = 0; i <= n; i ++)
	{
		while(j > 0 && t[i] != t[j + 1]) j = KMP2[j];
		if(t[i] == t[j + 1]) j ++;
		KMP2[i] = j;
	}
	if(!KMP[n] || n % (n - KMP[n]) != 0) // 没有循环节
	{
		cout << 1 << '\n' << 1 << '\n';
		return 0;
	} 
	int ans = 0;
	for(int i = 1; i < n; i ++)
		if((KMP[i] == 0 || i % (i - KMP[i]) != 0) && (KMP2[n - i] == 0 || (n - i) % (n - i - KMP2[n - i]) != 0)) ans ++;
	cout << 2 << '\n' << ans << '\n';
	return 0;
}