Misc on 练习本

第十七届北京信息科技大学程序设计竞赛

Thu, 27 Nov 2025 18:51:59 +0800

比赛🔗

Problem A. 小苯接雨水

把前两大的挡板放在左右两端。

Problem B. 小芳与残骸

模拟几个样例，发现答案就是 $2^{n - 1}$

Problem C. 小苯的棋盘游戏

发现如果行数和列数有一个是奇数，那么一定存在解。

Problem D. 暴暴龙的防奶龙要塞

多画图，我们发现当 $n \le 4$ 的时候无解。当 $n \ge 5$ 时，可以这样构造：中间一个点，点的两边分别和两个环通过两条边进行连接。

最小的环其实就是一条边。因此构造方案就是：(1,2) 连接一条边。[4,n]构成一个环。3 作为中间点，和上面每个环分别连接两条边。

Problem E. 奶龙与奥利奥自动机

组合数学题目。

设 $num_k$ 代表使用 $k$ 次操作，能够产生的非空字符串的数量。 $a_k$ 代表使用 $k$ 次操作，产生的非空字符串中，结尾是 0 的字符串的数量。 $b_k$ 代表使用 $k$ 次操作，产生的非空字符串中，结尾是 $1$ 的字符串的数量。 $c_k$ 代表使用 $k$ 次操作，产生的非空字符串中，结尾是 $01$ 的字符串的数量。

我们有这样的递推关系： $num_k = a_k + b_k + c_k$ ， $a_k = c_k = num_{k - 1}$ ， $b_k = b_{k - 1} + c_{k - 1}$

根据上面的关系，可以得到 $num_k = 3num_{k - 1} - num_{k - 2}$

答案就是 $\sum_{k = 0}^{n} num_{k}$

初始状态下， $num_0 = 1$ ， $num_1 = 3$ 。其中 $num_0 = 1$ 代表的含义其实是空字符串，0 次操作只有一种情况，把它作为特殊情况处理。

void solve() {
 int n;
 cin >> n;
 ll ans = 0;
 ll a = 1, b = 3;
 ans += a + b;

 For1(i, 2, n) {
 ll c = (3 * b - a + MOD1) % MOD1;
 a = b;
 b = c;
 ans = (ans + b) % MOD1;
 }
 cout << ans << '\n';
}

Problem F. 奶龙智斗暴暴龙

猜到采用极端分配的方式比较优。

在桶 A 中放置 1 个白球，在桶 B 中放置 $n-1$ 个白球和 $n$ 个黑球。此时如果选择桶 A，那么取到白球的概率是 1. 如果选择桶 B，那么取到白球的概率是 $\frac{n-1}{2n-1}$

最终答案是 $\frac{3n-2}{4n-2}$

Problem G. 小红的抛物线

把三个点按照横坐标排序，设三个点是 $a, b, c$ ，从 $b$ 做 $x$ 轴的垂线，交线段 $a, c$ 于点 $d$ ，判断点 $d$ 和点 $b$ 的 Y 坐标的大小即可。

Problem H. 小苯的序列染色

每个点可能向左扩展，也可能向右扩展，也就是每个点最多对应 2 个区间。一共有 $2n$ 个区间。问题转化成从这些区间中选出最少的区间，使得这些区间能够覆盖 $[1, n]$

这可以贪心：先按照区间的左端点从小到大排序。维护当前能够覆盖的最远距离 cur_end，如果当前区间的左端点 l <= cur_end + 1, 说明当前区间能够接上之前一段。那么从能够接上的这些区间中，选择一个右端点 $r$ 最大的。如果找不到能够接上的区间，直接返回无解。

void solve() {
 int n;
 cin >> n;

 VI a(n + 1);
 For1(i, 1, n) cin >> a[i];

 vector<PII> b;
 For1(i, 1, n) {
 int l = i - a[i] + 1, r = i + a[i] - 1;
 if (l >= 1 && l <= n && a[i] >= a[l]) {
 b.push_back({l, i});
 }
 if (r <= n && a[i] >= a[r]) {
 b.push_back({i, r});
 }
 }
 sort(all(b), [&](PII x, PII y) {
 if (x.f1 != y.f1)
 return x.f1 < y.f1;
 return x.f2 > y.f2;
 });

 if (b.empty()) {
 cout << "-1\n";
 return;
 }

 int cur_end = 0, len = SZ(b), ans = 0, nx_end = 0;
 int i = 0;
 while (cur_end < n) {
 while (i < len && b[i].f1 <= cur_end + 1) {
 ckmax(nx_end, b[i].f2);
 i++;
 }

 if (nx_end == cur_end) {
 cout << "-1\n";
 return;
 }
 ans++;
 cur_end = nx_end;
 }
 if (cur_end == n)
 cout << ans << '\n';
 else
 cout << "-1\n";
}

Problem I. 小苯的字符串构造

题目意思比较难懂。

其实就是要求长度是奇数的子字符串，出现次数都是奇数。对偶数长度的字符串没有要求。

模拟几个样例发现，如果 $n$ 是奇数，那么我们可以构造全部是 $a$ 的字符串。这恰好符合要求。如果 $n$ 是偶数，我们只需要添加一个字符 $b$ 即可。

Problem J. 小苯的运算式

设状态 $d_{i, 0}$ 表示只考虑前 $i$ 个元素，最后一个数字的符号是负号的最大值。状态 $d_{i, 1}$ 表示只考虑前 $i$ 个元素，最后一个数字的符号是正号的最大值。这是一个线性 DP

Problem K. 小苯的闯关游戏

注意到如果初始战力越大，到最后越容易满足条件。也就是有单调的性质，因此我们可以对答案二分。

Problem L. 小苯的序列还原

考虑最后一次操作，我们可以直接确定答案数组的最后一个位置 $b_n$ ，它的位置再也不会发生改变了。

根据这个想法，我们可以依次确定 $b_{n - 1}, b_{n - 2}, \ldots$

我们只需要维护当前需要考虑的区间 $[l, r]$ 和当前的翻转次数是奇数还是偶数。

Problem M. GPA Calculator

模拟。

牛客2025秋季算法编程训练联赛6-基础组

Thu, 20 Nov 2025 00:03:51 +0800

题目🔗 牛客2025秋季算法编程训练联赛6-基础组

A. 签到题

三条边构成三角形的充分必要条件是：假设 $a \le b \le c$ ，满足 $a + b \lt c$

题目给出的样例有一点误导性，开始以为需要等腰三角形才可以，其实并不是。

如果能够组成三角形，那么必定能够构造三个圆外切。设它们的半径分别是 $r_1, r_2, r_3$ , 那么满足 $r_1 + r_2 = a, r_1 + r_3 = b, r_2 + r_3 = c$ ，求解这个三元一次方程组。

void solve() {
 vector<int> a(3);
 For(i, 0, 3) cin >> a[i];
 sort(all(a));

 if (a[0] + a[1] > a[2]) {
 vector<double> arr(3);
 arr[1] = (1.0 * a[0] + a[1] - a[2]) / 2;
 arr[2] = a[1] - arr[1];
 arr[0] = a[0] - arr[1];
 sort(all(arr));
 cout << "Yes\n";
 for (auto i : arr) {
 cout << fixed << setprecision(2) << i << ' ';
 }
 cout << '\n';
 } else {
 cout << "wtnl\n";
 }
}

B. 括号序列

这道题比 A 简单。

我们只需要求出不匹配的括号的个数，只有两种情况不匹配：剩余的左括号，不能被匹配掉的右括号。

void solve() {
 int n;
 string s;
 cin >> n >> s;

 int ans{}, cur = 0;
 for (auto c : s) {
 if (c == '(')
 cur++;
 else {
 if (cur > 0)
 cur--;
 else
 ans++;
 }
 }

 ans += cur;
 cout << ans << '\n';
}

C. 十字阵列

记录第 $i$ 行总的伤害数，记录第 $j$ 列总的伤害数。如果把这两部分加起来，那么位置 $(i, j)$ 的伤害会被计算两次，因此我们需要记录下 $(i, j)$ 最后应该需要减去的伤害数。这样我们就可以得到每个位置最后实际的伤害数。

const int N = 2010;
ll a[N][N], col[N], row[N];

void solve() {
 int n, m, h;
 cin >> n >> m >> h;

 For1(i, 1, n) {
 row[i] = 0;
 For1(j, 1, m) a[i][j] = 0;
 }
 For1(j, 1, m) col[j] = 0;

 For(i, 0, h) {
 int x, y, z;
 cin >> x >> y >> z;
 row[x] += z;
 col[y] += z;
 a[x][y] += z;
 }

 ll ans = 0;
 For1(i, 1, n) {
 For1(j, 1, m) {
 ll tmp = row[i] + col[j] - a[i][j];
 ans = (ans + (tmp * (i + j) % MOD)) % MOD;
 }
 }
 cout << ans << '\n';
}

D. 配对

容易想到我们可以对答案进行二分，设最终的答案是 $sum$ ，我们需要保证两个数组中，我们可以构造出数对和 $\ge sum$ 的数对的数量 $\ge k$ 。此时最大 $sum$ 就是所求。

接下来考虑对于给定的 $sum$ ，如何找到这样的数对的数量，使得每个数对的和都 $\ge sum$ 。这恰好是一个双指针经典问题：把数组 $A$ 从小到大排序，数组 $B$ 从大到小排序。如果 $A_i + B_j \ge sum$ ，那么我们找到合法的一对，此时 $i++, j++$ 。如果 $A_i + B_j \lt sum$ ，此时 $i++$ 。

void solve() {
 int n, k;
 cin >> n >> k;

 VI a(n), b(n);
 For(i, 0, n) cin >> a[i];
 For(i, 0, n) cin >> b[i];
 sort(all(a));
 sort(all(b), greater<int>());

 auto check = [&](ll sum) -> bool {
 ll res = 0;
 for (int i = 0, j = 0; i < n && j < n;) {
 if ((ll)a[i] + b[j] >= sum) {
 res++;
 i++;
 j++;
 } else {
 i++;
 }
 }
 return res >= k;
 };

 ll l = 1, r = 2e8 + 10, mid;
 while (l < r) {
 mid = (l + r + 1) / 2;
 if (check(mid))
 l = mid;
 else
 r = mid - 1;
 }

 cout << l << '\n';
}

E. 重排列

容易发现，对两个数组排序，不会影响答案。

如果排序之后，还是不能够满足条件，那么无解。

如果有解，我们可以求出方案数。对于 $B_i$ ，我们可以求出 $A_j \le B_i$ 的最大的 $j$ ，也就是说 $A[1..j]$ 中的所有数字都可以放在 $B_i$ 的位置。因为 $B$ 已经排好序了，我们还需要考虑到 $B[1..i-1]$ 它们已经占用的位置，因此 $B_i$ 对应的方案数是 $j - (i - 1)$ ，根据乘法原理，把所有的 $B_i$ 对应的方案数相乘就是答案。

void solve() {
 int n;
 cin >> n;

 VI a(n), b(n);
 For(i, 0, n) cin >> a[i];
 For(i, 0, n) cin >> b[i];
 sort(all(a));
 sort(all(b));

 ll ans = 0;
 int cnt = 0;
 For(i, 0, n) {
 if (a[i] > b[i]) {
 cout << "0\n";
 return;
 }
 }

 ans = 1;
 for (int i = 0, j = 0; j < n; j++) {
 while (i < n && a[i] <= b[j])
 i++;
 ans = ans * (i - cnt) % MOD;
 cnt++;
 }
 cout << ans << '\n';
}

F. 图

很有意思的一道题目。

简单路径的含义是，路径上不经过重复的点。

因为题目条件中要求每个点仅有一条出边，所以这个图其实并不复杂。可能存在环，如果存在环也没有问题，我们可以把环切断作为路径的一部分。

画图可以发现，分成一下几种情况：

最简单的是一条链的情况。

如果存在环，那么就不能“逃”出去了，每个点的入度都恰好是 1.

一条链或者多条链最多可以连接到一个环中。

也就是最终的答案构成一定是：一条链+可选的一个环。

我们可以通过拓扑排序，得到所有的环，同时得到所有链上每个点的深度（也就是以当前点做为终点的最长链的长度）。

然后对每个环进行一次 DFS，求出环的大小。用环大小加上链长度维护答案。

const int N = 1000100;
int n, g[N], deg[N], dep[N];
bool st[N];

void Init() {
 For1(i, 1, n) {
 deg[i] = 0;
 g[i] = -1;
 st[i] = false;
 dep[i] = 1;
 }
}

int dfs(int u, int &mx) {
 st[u] = true;
 ckmax(mx, dep[u]);

 int res = 1, v = g[u];
 if (!st[v]) {
 res += dfs(v, mx);
 }
 return res;
}

void solve() {
 cin >> n;
 Init();
 For1(i, 1, n) {
 int x;
 cin >> x;
 g[i] = x;
 deg[x]++;
 }

 queue<int> q;
 For1(i, 1, n) {
 if (deg[i] == 0) {
 q.push(i);
 }
 }

 while (!q.empty()) {
 auto t = q.front();
 st[t] = true;
 q.pop();
 int v = g[t];
 ckmax(dep[v], dep[t] + 1);
 deg[v]--;
 if (deg[v] == 0) {
 q.push(v);
 }
 }

 int ans = 0;
 For1(i, 1, n) {
 if (!st[i]) {
 int cur_dep = 0;
 int sz = dfs(i, cur_dep), tmp = sz + cur_dep;
 ckmax(ans, tmp - 1);
 }
 }
 cout << ans << '\n';
}