AtCoder Beginner Contest 230

A. AtCoder Quiz 3

题意：给定一个正整数 $N$，输出第 $N$ 次比赛的名称，因为 $AGC42$ 被取消了，所以 $42$ 场及以后的场次的序号为场次 $+1$

判断 $N$ 和 $42$ 的大小即可，具体判断见代码

#include<bits/stdc++.h>
using namespace std;

int main(void) {
	int x;
	scanf("%d", &x);
	if (x >= 42) x++;
	printf("AGC%03d\n", x);
	return 0;
}

B. Triple Metre

题意：给定一个字符串 $S$，判断其是否是 $oxxoxxoxx\dots$ 的一个子串

首先 $S$ 要以 $3$ 为循环节

如果 $|S|\le 2$ 特判

对于 $|S|\ge 3$，需要满足前三个字符有 $2$ 个 $x$ 和 $1$ 个 $o$

否则不成立

#include<bits/stdc++.h>
using namespace std;

string s;

bool check(void) {
	int n = s.size();
	for (int i = 0; i < n; i++) {
		if (s[i] != s[i % 3]) return false;
	}
	if (n == 1) return true;
	if (n == 2) {
		if (s == "oo") return false;
		else return true;
	}
	int cnto = 0, cntx = 0;
	for (int i = 0; i < 3; i++) {
		cnto += s[i] == 'o';
		cntx += s[i] == 'x';
	}
	return cnto == 1 && cntx == 2;
}

int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> s;
	if (check()) cout << "Yes\n";
	else cout << "No\n";
	return 0;
}

C. X drawing

题意：给定一个 $N\times N$ 的格点，给定两个整数 $A,B$，做以下两个操作

• 对每个整数 $k$ 满足 $\max (1-A,1-B)\le k\le \min (N-A,N-B)$，将 $(A+k,B+k)$ 涂成黑色
• 对每个整数 $k$ 满足 $\max (1-A,B-N)\le k\le \min (N-A,B-1)$，将 $(A+k,B-k)$ 涂成黑色

然后给定一个子区域，需要输出这个子区域的涂色情况

其实将上述两种情况画到格子里就是斜率为 $1$ 和 $-1$ 的两个对角线，也就是说，一个格子 $(x,y)$ 是黑色，当且仅当 $|x-A|=|y-B|$

所以遍历这个子区域，每次判断一下是否满足上述条件即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll

int n, a, b, p, q, r, s;

signed main(void) {
	scanf("%lld%lld%lld", &n, &a, &b);
	scanf("%lld%lld%lld%lld", &p, &q, &r, &s);
	for (int i = p; i <= q; i++) {
		for (int j = r; j <= s; j++) {
			if (abs(i - a) == abs(j - b)) cout << '#';
			else cout << '.';
		}
		cout << '\n';
	}
	return 0;
}

D. Destroyer Takahashi

题意：一个 $N$ 行 $10^9$ 列的格点，有 $N$ 堵墙，第 $i$ 堵墙占据第 $i$ 行的 $(L_i,R_i)$ 的范围，现在可以进行以下操作

• 选定一个值 $x$，并摧毁第 $x$ 列到 $x+D-1$ 列中所有的墙

问至少需要几次操作能摧毁所有的墙

这是个贪心问题

我们将所有区间按照右端点从小到大排序，并按照顺序从小到大摧毁

记录一个摧毁的右边界

对于当前的一个区间 $(L_i,R_i)$

• 如果 $l_i\le x$ 说明当前已经被摧毁
• 否则在当前 $R_i$ 的位置进行下一次摧毁，并将摧毁边界 $x$ 变为 $R_i+d-1$

可以知道这样遍历了所有右边界的情况一定能摧毁所有的墙，并且是最优的

时间复杂度：$O(N\log N)$

#include<bits/stdc++.h>
using namespace std;

int n, d, ans;
vector<pair<int, int>> vt;

int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> d;
	for (int i = 1, l, r; i <= n; i++) {
		cin >> l >> r;
		vt.push_back({r, l});
	}
	sort(vt.begin(), vt.end());
	int r = 0;
	for (int i = 0; i < n; i++) {
		if (vt[i].second <= r) continue;
		r = vt[i].first + d - 1;
		ans++;
	}
	cout << ans << endl;
	return 0;
}

E. Fraction Floor Sum

题意：给定 $N$，$1\le N\le 10^{12}$，计算 $\sum _{i=1}^N\lfloor \frac{N}{i}\rfloor$

这是一个经典的问题，我们考虑分治

1. 对于 $1\le i\le \lfloor \sqrt{N}\rfloor$，这一部分我们可以暴力求答案

2. 对于 $\lfloor \sqrt{N}\rfloor <i\le N$

   满足 $\lfloor \frac{N}{i}\rfloor \le \sqrt{N}$

   我们对值进行枚举，即有多少个 $i$，满足 $\lfloor \frac{N}{i}\rfloor =x$

   即 $x\le \lfloor \frac{N}{i}\rfloor <x+1$

   即 $\lfloor \frac{N}{x+1}\rfloor <i\le \lfloor \frac{N}{x}\rfloor$

   所以有 $\lfloor \frac{N}{x}\rfloor -\lfloor \frac{N}{x+1}\rfloor$ 个 $i$

   所以当前的贡献为 $(\lfloor \frac{N}{x}\rfloor -\lfloor \frac{N}{x+1}\rfloor )\times x$

   枚举所有可能的 $x$ 的值即可

时间复杂度：$O(\sqrt{N})$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll

int n, ans;

signed main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n;
	for (int i = 1; i <= (int) sqrt(n); i++) {
		ans += n / i;
	}
	for (int i = 1; i <= n / ((int) sqrt(n) + 1); i++) {
		ans += (n / i - n / (i + 1)) * i;
	}
	cout << ans << endl;
	return 0;
}

F. Predilection

题意：给定长度为 $N$ 的数组 $A$，可以进行以下操作任意次数

• 选定两个相邻的数，将其相加替换原来的两个数

问最终有多少种可能的结果序列

我们考虑结果整数序列与操作序列之间的对应关系

为了得到一个非空的序列，我们可以采取如下贪心的方法：

• 重复添加第一个和第二个最左边的值，直到获得所需序列的第一个值，然后重复添加第二个和第三个最左边的值，直到 获得所需序列的第二个值，$\dots$，依此类推

记 $dp[i]$ 表示前 $i$ 个数对应的结果

那么对于第 $i+1$ 个数来说，对于每种序列，我们可以选择保留或不保留这个数，所以 $dp[i+1]\leftarrow dp[i]$，但是这两种情况有重复的部分，重复的情况是，对于 $i$ 前面最近一段和为 $0$ 的序列，将第 $i+1$ 个数向前加和不向前加是一样的，所以我们要把这个重叠的部分减去

也就是 $dp[i+1]\leftarrow 2\times dp[i]-dp[pre[i]]$，其中 $pre[i]$ 表示第 $i$ 个元素前面一段和等于 $0$ 的位置的前一个，这个信息可以通过前缀和和 $map$ 来维护从而实现 $O(\log N)$ 查询

总时间复杂度：$O(N\log N)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 2e5 + 5, mod = 998244353;
int a[N], dp[N], n;
map<ll, int> mp;

int main(void) {
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	int res = 1;
	ll sum = 0;
	for(int i = 1; i <= n; ++ i) {
		sum += a[i];
		dp[i] = res;
		res = 2ll * res % mod;
		res -= dp[mp[sum]];
		res %= mod; res += mod; res %= mod;
		mp[sum] = i;
	}
	cout << dp[n] << endl;
	return 0;
}