CSP-S 2020 题解
赛后我重拳出击，赛场上我却爆零。哎。
题解本人口胡。有错请各位大佬们指出。
A. 儒略日
这题是大型模拟题。
介绍两种写法：一种代码量致死（赛 场 自 闭），一种是非常好写的。
写法 1
我在赛场的思路：预处理三种情况（闰年，平年，鬼畜 \(1582\) 年），然后只需快速找到适当的年就可以了，在 \(1582\) 年前每 \(4\) 年一个循环；\(1582\) 年以后 \(400\) 年一个循环，\(400\) 年中又嵌套着一个 \(100\) 年，\(100\) 年中又前套着 \(4\) 循环。每一个循环的天数相同，可以用整除 \(O(1)\) 快速跳。
时间复杂度
\(O(T)\)。
奉上赛场丑陋的代码。
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
LL x;
LL k = 1573, r = 1461, r1 = 1460, d2, d4, d3, d5, d6;
const int N = 405;
int D[3][N], M[3][N];
int inline get(int x, int t) {
if (t && x == 2) return 29;
if (x == 4 || x == 6 || x == 9 || x == 11) return 30;
if (x == 2) return 28;
return 31;
}
int main() {
d4 = 365 * 400 + 97; d5 = 100 * 365 + 25, d6 = 100 * 365 + 24;
for (int i = 0; i <= 1; i++) {
int t = 365 + i;
int d = 0, m = 1;
for (int j = 0; j < t; j++ ){
if (d == get(m, i)) {
m ++, d = 1;
} else {
d++;
}
D[i][j] = d, M[i][j] = m;
}
}
int d = 0, m = 1;
for (int j = 0; j < 365 - 10; j++ ){
if (m == 10 && d == 4) {
d = 15;
} else if (d == get(m, 0)) {
m ++, d = 1;
} else {
d++;
}
D[2][j] = d, M[2][j] = m;
}
d2 = 366 + 365 * 2 - 10; d3 = 17 * 365 + 4;
int T; scanf("%d", &T);
while (T--) {
scanf("%lld", &x);
LL a = min(k, x / r);
LL d = 1, m = 1, y = -4713;
y += a * 4; x -= r * a;
if (y >= 0) y ++;
if (y == 1580 && x >= d2) {
y = 1583; x -= d2;
if (y == 1583 && x >= d3) x -= d3, y = 1600;
if (y == 1583) {
if (x >= 365) {
x -= 365, y++;
}
a = x / r;
y += a * 4; x -= r * a;
int k = (y % 100 || (y % 400 == 0)) ? 366 : 365;
if (x >= k) {
x -= k, y ++;
if (x >= 365) x -= 365, y++;
if (x >= 365) x -= 365, y++;
}
int t = (y % 400 == 0 || (y % 4 == 0 && y % 100));
printf("%d %d %lld\n", D[t][x], M[t][x], y);
continue;
}
a = x / d4;
y += 400 * a; x -= a * d4;
if (x >= d5) {
x -= d5, y += 100;
if (x >= d6) x -= d6, y += 100;
if (x >= d6) x -= d6, y += 100;
}
if (y % 400 != 0) {
if (x >= r1) x -= r1, y += 4;
}
a = x / r;
y += a * 4; x -= r * a;
int k = (y % 100 || (y % 400 == 0)) ? 366 : 365;
if (x >= k) {
x -= k, y ++;
if (x >= 365) x -= 365, y++;
if (x >= 365) x -= 365, y++;
}
int t = (y % 400 == 0 || (y % 4 == 0 && y % 100));
printf("%d %d %lld\n", D[t][x], M[t][x], y);
} else {
if (x >= 366) {
x -= 366, y ++;
if (y == 0) y++;
if (x >= 365) x -= 365, y++;
if (x >= 365) x -= 365, y++;
}
int t;
if (y < 0) t = (y % 4 == -1);
else t = y % 4 == 0;
if (y == 1582) {
printf("%d %d %lld\n", D[2][x], M[2][x], y);
} else {
if (y < 0) printf("%d %d %lld BC\n", D[t][x], M[t][x], -y);
else printf("%d %d %lld\n", D[t][x], M[t][x], y);
}
}
}
return 0;
}
写法 2
xtq 鸽鸽教了我一个超好写的方法，tql！
具体是通过观察样例 2 发现，到 \(1582\) 年 \(< A = 3000000\) 天，而之后都是 \(400\) 年共 \(97\) 闰年的循环（共 \(T = 365 \times 400 + 97 = 146097\)）这个天数的循环。那么暴力预处理出来 \(G = A + T = 3000000 + 146097 = 3146097\) 这么多天的答案，对于任意 \(r\)，若 \(r \le A\)，直接输出，若 \(r > M\)，答案月日就等同于 \(A + (r - A) \bmod T\)，年份就是这个天数的年份 \(+ \lfloor (r - A) / T \rfloor\)。
非 常 好 写。
时间复杂度
复杂度 \(O(G + T)\)，每个询问还是 \(O(1)\)。
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;
const int N = 3146100;
int A = 3000000, T = 146097, G = A + T;
int D[N], M[N], Y[N];
int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int inline isLeap(int y) {
if (y <= 1582) return y > 0 ? (y % 4 == 0) : (y % 4 == -1);
else return y % 400 == 0 || (y % 4 == 0 && y % 100);
}
int inline getDays(int x, int y) {
if (y && x == 2) return 29;
else return days[x];
}
void init() {
int d = 1, m = 1, y = -4713;
for (int i = 0; i <= G; i++) {
D[i] = d, M[i] = m, Y[i] = y;
if (d == 4 && m == 10 && y == 1582) {
d = 15;
} else if (d == getDays(m, isLeap(y))) {
d = 1;
if (m == 12) {
m = 1, y ++;
if (y == 0) y++;
} else m++;
} else d++;
}
}
void inline out(int d, int m, int y) {
if (y < 0) printf("%d %d %d BC\n", d, m, -y);
else printf("%d %d %d\n", d, m, y);
}
int main() {
init();
int Q; scanf("%d", &Q);
while (Q--) {
LL r; scanf("%lld", &r);
if (r <= A) out(D[r], M[r], Y[r]);
else {
int a = A + ((r - A) % T);
out(D[a], M[a], Y[a] + (r - A) / T * 400);
}
}
return 0;
}
B. 动物园
由于这题保证 \(a_i, q_i\) 各自互不相同，所以会好写一些。
把所有 \(a_i\) 所覆盖的所有位搞出来，这只需要一个按位或，设 \(w_i\) 表示所有 \(a\) 中有没有第 \(i\) 位为 \(1\) 的。
考虑什么情况才不能选择一位，对于一个要求 \(p, q\)，若 \(w[p] = \text{false}\)，就意味着第 \(p\) 位肯定不能选（由于 \(q\) 互不相同，不会其他的 \(p\) 会使原来买了 \(q\) 了）。
设能选的位数是 \(k\)，答案就是 \(2 ^ k - n\)，即所有满足的（组合计数算出） \(-\) 目前已经有的。
若 \(k = 64\)，则式子直接算会爆 \(\text{unsigned long long}\) 需要特判。
时间复杂度
\(O(n)\)。
P.S. 如果不保证各不相同（我赛场就是这样眼瞎），只需要把 \(q\) 离散化，记录覆盖了哪些 \(q\)，把 \(a\) 去重即可，再扫一遍限制，复杂度只带排序的 \(O(n \log n)\)。
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 1000005;
typedef unsigned long long ULL;
int n, m, c, K;
bool f[64];
ULL a[N];
int main() {
scanf("%d%d%d%d", &n, &m, &c, &K);
ULL sum = 0;
for (int i = 1; i <= n; i++) {
ULL x; scanf("%llu", &x); sum |= x;
}
int c = K;
for (int i = 1, p, q; i <= m; i++) {
scanf("%d%d", &p, &q);
if (!(sum >> p & 1) && !f[p]) f[p] = true, c--;
}
if (c == 64) {
if (n == 0) puts("18446744073709551616");
else printf("%llu\n", (~0ull) - (n - 1));
} else printf("%llu\n", (1ull << c) - n);
}
C. 函数调用
事实上，你可以把整个问题作如下转化：
- 对于每个 \(a_i\)，可以看作新增了一个在最开始的 \(P = i, V = a_i\) 的 \(1\) 操作。
- 对于函数操作序列，可以看作新增一个 \(3\) 操作 \(m + 1\)，他的顺序就是 \(f\)。
如果对于每个 \(3\) 操作，让 \(j\) 向所有他调用的所有函数 \(g\) 顺序连一条有向边，由于题中不会调用自身的限制，这个图即变成一个有向无环图。
那么问题就变得统一了起来，即从 \(m + 1\) 开始遍历，每次按边的顺序 \(dfs\)，经过的 \(1, 2\) 操作做一遍操作，求最终的数组。
如果把 \(dfs\) 经过的所有点顺序打成一个序列，我们发现乘法实际上是把之前的加法整体乘一个数。
每经过一个加法来说，设其后经过的乘法数值乘积是 \(s\)，他的贡献就是让 \(a_P\) 加上了 \(V \times s\)。 也可以理解为添加了执行了 \(s\) 次这个操作的贡献。
我们执行一遍逆拓扑序，把调用每个点走到的所有乘法操作乘积 \(\text{mul}\) 找出来。
我们设 \(cnt_i\) 为第 \(i\) 个点所在操作需要执行多少次，我们只需要把这个东西算出来就可以了。
初始令 \(cnt_{m + 1} = 1\)，然后我们尝试递推到每一个点。
然后我们执行一遍拓扑排序，对于每个点 \(u\)，维护一个值初始为 \(s = cnt_u\) ，我们反向遍历他的每个指向点 \(v\)：
- 让 \(cnt_v\) 加上 \(s\)
- 让 \(s\) 为 \(s \times mul_v\)
你可以理解为每次遍历到 \(u\) 这个点就是需要执行 \(cnt_u\) 次的时候，我们考虑把这个点删掉，那么对于他的每个指向点 \(v\)，只需要加上其后指向边的乘积次，贡献加上，那么各个指向点就各自独立了。由于拓扑排序，因此每个点 \(u\) 被遍历时，能够让 \(cnt\) 变化的点都处理完了，所以是对的。
感觉写这个的时候好难讲清楚...
时间复杂度
\(O(n + m + Q + \sum C_j)\) （线性）
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
const int N = 100005, P = 998244353;
int n, a[N], m, T[N], B[N], V[N], Q, f[N];
int mul[N], q[N], in[N], deg[N], cnt[N];
vector<int> g[N], e[N];
int inline power(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = (LL)res * a % P;
a = (LL)a * a % P;
b >>= 1;
}
return res;
}
void inline topo1() {
int hh = 0, tt = -1;
for (int i = 1; i <= m; i++) if (!deg[i]) q[++tt] = i;
while (hh <= tt) {
int u = q[hh++];
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
mul[v] = (LL)mul[v] * mul[u] % P;
if (--deg[v] == 0) q[++tt] = v;
}
}
}
void inline topo2() {
int hh = 0, tt = -1;
for (int i = 1; i <= m; i++) if (!in[i]) q[++tt] = i;
while (hh <= tt) {
int u = q[hh++], s = cnt[u];
for (int i = g[u].size() - 1; ~i; i--) {
int v = g[u][i];
(cnt[v] += s) %= P;
if (--in[v] == 0) q[++tt] = v;
s = (LL)s * mul[v] % P;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) mul[i] = 1;
for (int i = 1; i <= m; i++) {
scanf("%d", T + i);
if (T[i] == 1) scanf("%d%d", B + i, V + i);
else if (T[i] == 2) scanf("%d", V + i), mul[i] = V[i];
else if (T[i] == 3) {
scanf("%d", V + i);
for (int j = 0, x; j < V[i]; j++) {
scanf("%d", &x);
g[i].push_back(x), e[x].push_back(i);
in[x]++, deg[i]++;
}
}
}
topo1();
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) scanf("%d", f + i);
int s = 1;
for (int i = Q; i; i--) {
if (T[f[i]] != 2) (cnt[f[i]] += s) %= P;
s = (LL)s * mul[f[i]] % P;
}
for (int i = 1; i <= n; i++) a[i] = (LL)a[i] * s % P;
topo2();
for (int i = 1; i <= m; i++)
if (T[i] == 1) a[B[i]] = (a[B[i]] + (LL)V[i] * cnt[i]) % P;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
D. 贪吃蛇
假设每条蛇都选择吃，我们把每轮的情况模拟出来，即模拟出：
- \(mx_i / mn_i\) 还剩 \(i\) 条蛇的轮次（吃之前）时，实力最强 / 最弱的蛇
- \(d_i\) 第 \(i\) 条蛇被吃掉后，还有几条蛇
由于轮次越前的蛇越有决定权，我们可以考虑从后往前推，最终结果仅有一条蛇，这是这条蛇满意的结果，动态维护一个 \(ans = 1\)，然后枚举 \(i\) 从 \(2\) 到 \(n\) （枚举还有几条蛇的时间）：
- 如果 \(d_{mx_i} \ge ans\)，那么 \(mx_i\) 会在从当前状态到我们目前答案的时间段中被吃掉，所以 \(mx_i\) 这轮不会选择吃，即要改变 \(ans = i\)。
- 否则，\(mx_i\) 会同意吃，所以 \(ans\) 不变，因为自己在后续不会死。
由于惨淡的数据范围，要求我们必须做到线性 \(O(Tn)\)
后面推的时间是线性的，只需要快速（线性）模拟情况。
把问题抽象出来：
开始我们有 \(a_1 \le a_2 \le \text{...} < a_n\)，\(n\) 个数，每个数与其下标作为一个二元组参与比较 \((a_i, i)\)，把这些二元组加入集合。
- 执行 \(n - 1\) 轮，每次从集合中找出并弹出最大和最小的两个数 （设这两个数下标为 \(mx, mn\)），然后把 \((a_{mx} - a_{mn}, mx)\) 加入集合。
如果要线性，必须满足加入的这个东西满足一些单调性，如 NOIP 2016 蚯蚓的那题。
我们设第 \(i\) 轮最大最小的数值分别是 \(A_i, B_i\)，推入集合的数值是 \(C_i = A_i - B_i\)。
因为不会推入更大的数进集合，所以满足 \(A_i \ge A_{i+1}\)，此时只需满足 \(B_i \le B_{i+1}\)，我们就可以发现 \(C_i\) 是单调非严格递减的了。但实际并不令我们所想的那样美好，我们需要对 \(B\) 的情况进行分类讨论。
Case 1
若需 \(B_i \le B_{i+1}\)，需要做到推入的数不小于最小的数，即对于任意的 \(i\) 都有 \(A_i - B_i \ge B_i \Leftrightarrow A_i \ge 2B_i\) 的话，\(C_i\) 是单调非严格递减的。那么我们只需要像蚯蚓那题一样开两个单调数组，\(b\) 保存初始的蚯蚓，\(c\) 保存推入的蚯蚓，两个蚯蚓都是单调的，极值就在队头队尾。
还有一个小问题，我们只保证数值满足关系，下标能否满足呢？
当 \(C_i = C_{i+1}\) 时，当且仅当 \(A_i = A_{i+1}\) 且 \(B_i = B_{i+1}\)，在这种情况下由于 \(A_i\) 的下标是大于 \(A_{i+1}\) 的下标，所以产生的 \(C_i\) 下标也是递减的。
Case 2
我们找到第一个 \(A_i - B_i < B_i \Leftrightarrow A_i < 2B_i\)。
设此时有 \(n\) 个元素，然后按顺序最小到大排好是 \(a\) 数组（实际上是把两个 Case 分开处理了，现在变成了一个新的问题而且初始就满足）。
此时排序，实际上是一个将 Case 1 中两个单调数组做二路归并排序的过程，是 \(O(n)\) 的，并且只会执行一次。
那么 \(A_i = a_n, B_i = a_1\)。
这种时候：
- 第 \(2\) 轮取出来的最小元素肯定是上次的数即 \(a_n - a_1\)，最大值是 \(a_{n - 1}\)，产生的 \(a_{n - 1} - (a_n - a_1) = (a_{n - 1} - a_n) + a_1 \le a_1\)
- 第 \(3\) 轮取出来的最小元素的值（注意这里元素不一定，因为还有下标的限制）一定是 \(a_{n - 1} - (a_n - a_1)\)，最大元素一定是 \(a_{n - 2}\)，产生的 \(a_{n - 2} - [a_{n - 1} - (a_n - a_1)] = a_{n - 2} - a_{n - 1} + (a_n - a_1) < a_1\)
注意这里的轮重新从进入 Case 2 算起，可以理解为我们把问题变成了一个一开始就满足 \(a_n < 2a_1\) 的一个问题。
这种时候，通过观察发现后续偶数轮数值都是 \(\le a_1\)，奇数轮都是 \(< a_1\)。
还是数学归纳法证一下吧：
设 \(f_i\) 为第 \(i\) 轮推出的数，\(f_1 = a_n - a_1 < a_1, f_2 = a_{n - 1} - (a_n - a_1) = (a_{n - 1} - a_n) + a_1 \le a_1\)
对于任意 \(i \ge 3\)，有 \(f_i = a_{n - i + 1} - f_{i - 1} = a_{n - i + 1} - a_{n - i + 2} + f_{i - 2} \le f_{i - 2}\)，因此每个 \(i\) 都有 \(f_i \le f_{i \bmod 2}\)
证毕。
这样证明完以后，我们发现产生的数要么马上下一轮作为最小值被咔嚓，要么有跟他同值得倒霉蛋代替他受罚。
那如果此时我们还用 Case 1 的方法还能保持单调吗？发现同值情况仅出现在 \(= a_1\) 的情况。如果推入的数 \(\not= a_1\)，他下一轮就被取出去，所以可以保证 \(c\) 只有一个元素。若有多个 \(= a_1\) 的情况，即需要满足当前的 \([n - i + 1, n]\) 这个区间的 \(a\) 全 \(= a_n\)，才能满足那个偶数轮次取等。\(b\) 队列中相同的值，下标大的会先作为最大值然后弹出来，所以 \(c\) 中也是满足单调递减的。
时间复杂度
\(O(Tn)\)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
const int N = 1000005, INF = 2e9;
int n, a[N], d[N], mx[N], mn[N], ans;
struct E{
int x, id;
bool operator < (const E &b) const {
if (x != b.x) return x < b.x;
return id < b.id;
}
bool operator == (const E &b) const {
return x == b.x && id == b.id;
}
};
E b[N], c[N], f[N];
int hh, tt, L, R;
E inline getMax() {
E x = (E) { -1, -1 };
if (hh <= tt && x < b[hh]) x = b[hh];
if (L <= R && x < c[L]) x = c[L];
if (hh <= tt && x == b[hh]) hh++;
if (L <= R && x == c[L]) L++;
return x;
}
E inline getMin() {
E x = (E) { INF, INF };
if (hh <= tt && b[tt] < x) x = b[tt];
if (L <= R && c[R] < x) x = c[R];
if (hh <= tt && x == b[tt]) tt--;
if (L <= R && x == c[R]) R--;
return x;
}
void inline merge() {
int len = tt - hh + 1 + R - L + 1;
for (int k = 1, i = hh, j = L; k <= len; k++) {
if (j > R || (i <= tt && c[j] < b[i])) f[k] = b[i++];
else f[k] = c[j++];
}
L = 0, R = -1;
hh = 1, tt = len;
for (int i = 1; i <= len; i++) b[i] = f[i];
}
void inline solve() {
hh = 0, tt = -1, L = 0, R = -1;
memset(d, 0, sizeof d);
ans = 1;
for (int i = n; i; i--) b[++tt] = (E) { a[i], i };
bool ok = false;
for (int i = n; i >= 2; i--) {
E A = getMax(), B = getMin();
mx[i] = A.id, mn[i] = B.id;
c[++R] = (E) { A.x - B.x, mx[i] };
if (!ok && A.x < B.x * 2) {
ok = true;
merge();
}
d[mn[i]] = i - 1;
}
for (int i = 2; i <= n; i++)
if (d[mx[i]] >= ans) ans = i;
printf("%d\n", ans);
}
int main() {
int T; scanf("%d", &T); T--;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
solve();
while (T--) {
int k; scanf("%d", &k);
for (int i = 1, x, y; i <= k; i++) {
scanf("%d%d", &x, &y);
a[x] = y;
}
solve();
}
return 0;
}
