【25届秋招】饿了么0817算法岗笔试

1. 第一题

给定一个长度为 $n$ 且仅由 $0$ 、 $1$ 两种字符构成的字符串 $s$ 。每次操作你都可以选择字符串 $s$ 的任意一个字符，并将其反置。
询问经过恰好 $k$ 次操作后，字符串 $s$ 是否为一个回文字符串。
若当前字符为 $0$ ，反置后为 $1$ 。若当前字符为 $1$ ，反置后为 $0$ 。
一个字符串被称作回文字符串，当且仅当这个字符串从左往右读和从右往左读都是相同的。

输入描述

每个测试文件均包含多组测试数据。第一行输入一个整数 $T\,(1\leq T\leq100)$ 代表数据组数，每组测试数据描述如下:
第一行输入两个整数 $n,k\,(1\leq n\leq1000,\,0\leq k\leq n)$ 。
第二行输入一个长度为 $n$ 且仅由 $0$ 、 $1$ 两种字符构成的字符串 $s$ 。

输出描述

对于每一组测试数据，如果经过怡好 $k$ 次操作后，字符串 $s$ 可以成为一个回文字符串，在一行上输出 YES；否则，直接输出 NO。

题解

首先我们需要统计将字符串 $s$ 转化为回文串所需的最少操作次数，记为 $c$ 。具体来说，可以通过双指针遍历，计算出对应位置的字符不同的次数，这就是需要改变的字符对数。

然后我们考虑以下两种情况：

当 $k < c$ ：显然无法在给定的操作次数内将字符串变为回文串，输出 “NO”。
当 $k\geq c$ ：此时，我们需要考虑多余的操作次数 $k - c$ ：
- 字符串长度为奇数：由于中间字符不影响回文性，因此我们可以通过多余的操作次数调整中间字符，从而总是能变成回文串，输出 “YES”。
- 字符串长度为偶数：为了保证能够最终形成回文串，剩余操作次数 $k - c$ 必须为偶数（每次操作可以对称改变两边的字符），否则输出 “NO”。

#include <bits/stdc++.h>using namespace std;int ops(const string &s) {int left = 0, right = s.size() - 1;int changes = 0;while (left < right) {if (s[left] != s[right]) {changes++;}left++;right--;}return changes;
}void solve() {int n, k;cin >> n >> k;string s;cin >> s;int changes = ops(s);if (changes > k) {cout << "NO" << endl;} else if ((k - changes) % 2 == 0 || n % 2 == 1) {cout << "YES" << endl;} else {cout << "NO" << endl;}
}int main() {int t;cin >> t;while (t--) {solve();}return 0;
}

2. 第二题

有一个 $n$ 行 $n$ 列的棋盘，每个格子上写着数字 $0$ 或 $1$ 。有一个小球从某个格子出发，移动到写着 $0$ 的格子时会向下移动一格，移动到写着 $1$ 的格子时会向右移动一格，直到滚出棋盘边界。

现在有 $9$ 个询问，每次询问在子矩阵 $(x_1,y_1)\sim(x_2,y_2)$ 中，小球从 $x_1,y_1)$ 出发开始滚动，最后会从哪个格子滚出子矩阵 $(x_1,y_1)\sim(x_2,y_2)$ 。

从某个格子滚出子矩阵 $(x_1,y_1)\sim(x_2,y_2)$ ，意思是当前所在的格子在子矩阵内，但是小球滚动路径的下一个格子不在子矩阵内，视为滚出。

从棋盘 $(x, y)$ 向右滚动一格即抵达 $(x, y + 1)$ ，从棋盘 $(x, y)$ 向下滚动一格即抵达 $(x + 1, y)$ 。

输入描述

第一行输入一个整数 $n\,(1\leq n\leq 500)$ 代表棋盘大小。
此后 $n$ 行，每行输入 $n$ 个整数 $a_1,a_2,...,a_n\,(0\leq a_i\leq 1)$ 代表棋盘上每个格子上写的数字。
第 $n + 2$ 行输入一个整数 $q\,(1\leq q\leq 2\cdot 10^5)$ 代表询问次数。
随后 $q$ 行，每行输入四个整数 $x_1,y_1,x_2,y_2\,(1\leq x_1,x_2,y_1,y_2\leq n,x_1\leq x_2,y_1\leq y_2)$ 代表子矩阵范围。

输出描述

对于每一次询问，在一行上输出两个整数，代表小球滚出的位置。

题解

直接模拟的时间复杂度为 $O (q n)$ ，看似会超时，但实际并不会。

#include <bits/stdc++.h>using namespace std;void query(const vector<vector<int>>& board) {int x1, y1, x2, y2;cin >> x1 >> y1 >> x2 >> y2;int cx = x1, cy = y1, last_cx = cx, last_cy = cy;while (cx >= x1 && cx <= x2 && cy >= y1 && cy <= y2) {last_cx = cx;last_cy = cy;if (board[cx][cy]) cy++;else cx++;}cout << last_cx << ' ' << last_cy << endl;
}int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int n;cin >> n;vector<vector<int>> board(n + 1, vector<int>(n + 1));for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {cin >> board[i][j];}}int q;cin >> q;while (q--) {query(board);}return 0;
}

3. 第三题

给出一张由几个点 $m$ 条带边权的边构成的无向连通图，你有恰好 $k$ 次机会，选择一条边使得其边权 $+ 1$ 。在 $k$ 次操作全部完成后，你要选出一个合法的生成树，使得这棵生成树中：边权最小的边最大。

输出这个边权。

对于一张图，选择其中 $n - 1$ 条边，使得所有顶点联通，这些边一定会组成一棵树，即为这张图的一棵生成树。可以证明，图中存在至少一棵生成树。

输入描述

第一行输入三个整数 $n,m,k\,(1\leq n,m\leq 10^5,1\leq k\leq 10^{14})$ 代表给定图的点数、边数和你的操作次数。
此后 $m$ 行，第 $i$ 行输入三个整数 $a_i,b_i,c_i(1\leq a_i,b_i\leq n;1\leq c_i\leq 10^{14})$ 代表图上第 $i$ 条边连接节点 $a_i$ 和 $b_i$ ，且边权为 $c_i$ 。保证图联通，没有重边。

输出描述

在一行上输出一个整数，代表全部生成树中、边权最小的边最大的那棵树，它的边权最小的边。

题解

先通过 Kruskal 算法求解最大生成树。为此，我们将图中的边按权值从大到小排序，然后依次选择不形成环的边加入生成树。得到最大生成树后，我们面临的问题是如何通过最多 k 次操作，将这些边中的最小边权尽量提高。考虑使用二分查找。二分查找的对象是最小边权的下界，假设当前下界为 mid，我们计算将所有生成树边的权值提升到至少 mid 所需的操作次数。如果这些操作次数不超过 k，说明 mid 是可行的，我们可以尝试更大的下界；否则，需要降低下界。最终，二分查找得到的值就是所有生成树中边权最小的最大值。

#include <bits/stdc++.h>using namespace std;using i64 = long long;struct UnionFind {vector<int> p;UnionFind(int n) : p(n) {iota(p.begin(), p.end(), 0);}int find(int x) {return p[x] == x ? x : (p[x] = find(p[x]));}bool unite(int x, int y) {int root_x = find(x);int root_y = find(y);if (root_x != root_y) {p[root_x] = root_y;return true;}return false;}
};int main() {ios::sync_with_stdio(false);cin.tie(nullptr);int n, m;i64 k;cin >> n >> m >> k;vector<array<i64, 3>> edges(m);for (auto& [u, v, w] : edges) {cin >> u >> v >> w;--u;--v;}sort(edges.begin(), edges.end(), [](const auto& lhs, const auto& rhs) {return lhs[2] > rhs[2];});UnionFind uf(n);vector<i64> tree_edges;// 使用Kruskal算法构建最大生成树for (const auto& [u, v, w] : edges) {if (uf.unite(u, v)) {tree_edges.push_back(w);}}// 二分查找最小可能的边权i64 left = *min_element(tree_edges.begin(), tree_edges.end());i64 right = 1e14 + k;while (left < right) {i64 mid = left + (right - left + 1) / 2;i64 required = 0;// 计算需要多少次操作才能将所有边权提升到至少 midfor (i64 w : tree_edges) {required += max(0LL, mid - w);if (required > k) break; }if (required <= k) left = mid;else right = mid - 1;}cout << left << "\n";return 0;
}