VP Educational Codeforces Round 3
A. USB Flash Drives
题意：给你一个\(m\)和\(n\)个数，你要从中选最少的数使得它们的和大于等于\(m\)。
排序后从大到小枚举即可。
点击查看代码
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<int> a(n);`
for (int i = 0; i < n; ++ i) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end(), std::greater<int>());
int sum = 0;
for (int i = 0; i < n; ++ i) {
sum += a[i];
if (sum >= m) {
std::cout << i + 1 << "\n";
return;
}
}
}
B. The Best Gift
题意：总共有\(n\)本书分为\(m\)类，告诉你每本书的类型，求有多少种方式选两本书使得两本书的类型不同。
直接统计每一类有多少本书，然后按顺序枚举，每种类型的书都可以和前面所有类型的书一对。
点击查看代码
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<int> cnt(11);
for (int i = 0; i < n; ++ i) {
int x;
std::cin >> x;
++ cnt[x];
}
int ans = 0, sum = 0;
for (int i = 1; i <= m; ++ i) {
ans += cnt[i] * sum;
sum += cnt[i];
}
std::cout << ans << "\n";
}
C. Load Balancing
题意：给你\(n\)个数，你每次可以让一个数加一另一个数减一，求使得极差最小的最小操作次数。
要极差最小，那么最终序列是固定的，我们只需要排序后让大的变成大的，小的变成小的就行，记录需要变的次数。
点击查看代码
void solve() {
int n;
std::cin >> n;
std::vector<int> a(n);
for (int i = 0; i < n; ++ i) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end(), std::greater<int>());
int ans = 0, sum = std::accumulate(a.begin(), a.end(), 0);
for (int i = 0; i < n; ++ i) {
int x = sum / n;
if (i < sum % n) {
++ x;
}
ans += std::abs(a[i] - x);
}
std::cout << ans / 2 << "\n";
}
D. Gadgets for dollars and pounds
题意：有\(n\)天，\(m\)种物品，你要买\(k\)个物品，给你两个长度为\(n\)的价格数组\(a,b\)代表每一天某一类商品的成本，每个物品要么是\(a\)类要么是\(b\)类，价格为购买时当天的成本乘商品价格。
你有\(s\)块，求最少几天可以买到\(k\)件商品。
考虑二分，如果我们要在第\(mid\)天内买\(k\)件物品，则每一类都应该集中在成本最低的那天购买，于是需要记录\(a,b\)的前缀\(min\)，然后我们要枚举买几个\(a\)类和几个\(b\)类，也是贪心的买最便宜的，所以要从大到小排序后记录前缀和。
点击查看代码
void solve() {
int n, m, k, s;
std::cin >> n >> m >> k >> s;
std::vector<i64> a(n), b(n);
for (int i = 0; i < n; ++ i) {
std::cin >> a[i];
}
for (int i = 0; i < n; ++ i) {
std::cin >> b[i];
}
std::vector<std::pair<i64, int>> ta, tb;
for (int i = 0; i < m; ++ i) {
int t, x;
std::cin >> t >> x;
if (t == 1) {
ta.push_back({x, i});
} else {
tb.push_back({x, i});
}
}
std::sort(ta.begin(), ta.end());
std::sort(tb.begin(), tb.end());
int lena = ta.size(), lenb = tb.size();
std::vector<i64> suma(lena + 1), sumb(lenb + 1);
for (int i = 0; i < lena; ++ i) {
suma[i + 1] = suma[i] + ta[i].first;
}
for (int i = 0; i < lenb; ++ i) {
sumb[i + 1] = sumb[i] + tb[i].first;
}
const i64 inf = 1e18;
std::vector<i64> mina(n + 1, inf), minb(n + 1, inf);
for (int i = 0; i < n; ++ i) {
mina[i + 1] = std::min(mina[i], a[i]);
minb[i + 1] = std::min(minb[i], b[i]);
}
auto check = [&](int d) -> std::pair<i64, int> {
i64 va = mina[d], vb = minb[d];
i64 res = inf, p = 0;
for (int i = std::max(0, k - lenb), j = lenb; i <= std::min(k, lena); ++ i) {
while (j > 0 && i + j > k) {
-- j;
}
if (i + j < k) {
break;
}
if (res > suma[i] * va + sumb[j] * vb) {
res = suma[i] * va + sumb[j] * vb;
p = i;
}
}
return {res, p};
};
int l = 1, r = n;
while (l < r) {
int mid = l + r >> 1;
if (check(mid).first <= s) {
r = mid;
} else {
l = mid + 1;
}
}
auto [val, p] = check(l);
if (val > s) {
std::cout << -1 << "\n";
return;
}
int da = 0, db = 0;
for (int i = 0; i < l; ++ i) {
if (a[i] == mina[l]) {
da = i;
break;
}
}
for (int i = 0; i < l; ++ i) {
if (b[i] == minb[l]) {
db = i;
break;
}
}
std::vector<std::pair<int, int>> ans;
for (int i = 0; i < p; ++ i) {
ans.push_back({ta[i].second, da});
}
for (int i = 0; i < k - p; ++ i) {
ans.push_back({tb[i].second, db});
}
std::cout << l << "\n";
for (auto & [x, y] : ans) {
std::cout << x + 1 << " " << y + 1 << "\n";
}
}
E. Minimum spanning tree for each edge
题意：给你一个图，包含某条边的生成树的最小权值。
经典题，考虑建最小生成树，然后根据\(lca\)记录到祖先节点的最大边权。那么对于每条边，如果想要让它更换最小生成树上的边，它加进来会形成一个环，我们需要在这个环里的边选一条最大的删，而这个环上的边恰好都在边连接的两个端点的\(lca\)上。
点击查看代码
struct DSU {
std::vector<int> fa, cnt;
DSU(int _n) {
init(_n);
}
void init(int _n) {
fa.assign(_n, 0);
cnt.assign(_n, 1);
std::iota(fa.begin(), fa.end(), 0);
}
int find(int x) {
return x == fa[x] ? x : fa[x] = find(fa[x]);
}
bool merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) {
return false;
}
fa[y] = x;
cnt[x] += cnt[y];
return true;
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return cnt[find(x)];
}
};
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<std::array<int, 4>> edges(m);
for (int i = 0; i < m; ++ i) {
int u, v, w;
std::cin >> u >> v >> w;
edges[i] = {w, u, v, i};
}
std::sort(edges.begin(), edges.end());
DSU dsu(n + 1);
std::vector<std::vector<std::pair<int, int>>> adj(n + 1);
i64 sum = 0;
for (int i = 0; i < m; ++ i) {
auto & [w, u, v, id] = edges[i];
if (dsu.same(u, v)) {
continue;
}
sum += w;
dsu.merge(u, v);
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
int lg = std::__lg(n) + 1;
std::vector f(n + 1, std::vector<int>(lg + 1));
std::vector max(n + 1, std::vector<int>(lg + 1, 0));
std::vector<int> d(n + 1);
d[1] = 1;
std::queue<int> q;
q.push(1);
while (q.size()) {
int u = q.front(); q.pop();
for (auto & [v, w] : adj[u]) {
if (d[v] == 0) {
d[v] = d[u] + 1;
f[v][0] = u;
max[v][0] = w;
for (int i = 1; i <= lg; ++ i) {
f[v][i] = f[f[v][i - 1]][i - 1];
max[v][i] = std::max(max[v][i - 1], max[f[v][i - 1]][i - 1]);
}
q.push(v);
}
}
}
auto lca = [&](int x, int y) -> int {
if (d[x] < d[y]) {
std::swap(x, y);
}
int res = 0;
for (int i = lg; i >= 0; -- i) {
if (d[f[x][i]] >= d[y]) {
res = std::max(res, max[x][i]);
x = f[x][i];
}
}
if (x == y) {
return res;
}
for (int i = lg; i >= 0; -- i) {
if (f[x][i] != f[y][i]) {
res = std::max({res, max[x][i], max[y][i]});
x = f[x][i], y = f[y][i];
}
}
res = std::max({res, max[x][0], max[y][0]});
return res;
};
std::vector<i64> ans(m);
for (auto & [w, u, v, id] : edges) {
ans[id] = sum - lca(u, v) + w;
}
for (int i = 0; i < m; ++ i) {
std::cout << ans[i] << "\n";
}
}
F. Frogs and mosquitoes
待补
浙公网安备 33010602011771号