AtCoder Beginner Contest 252
作者:互联网
A,B,C跳过。
D - Distinct Trio
题意
求满足\(i < j < k\)且\(a_i,a_j,a_k\)这3个数两两互不相等的\((i, j, k)\)的数量。
\(n \le 2 \times 10^5\)。
思路
正着不好算,逆向思考一下就行。
AC代码
// Problem: D - Distinct Trio
// Contest: AtCoder - AtCoder Beginner Contest 252
// URL: https://atcoder.jp/contests/abc252/tasks/abc252_d
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
// std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
int n;
std::cin >> n;
std::map<int, int> cnt;
for (int i = 0; i < n; ++i) {
int x;
std::cin >> x;
++cnt[x];
}
i64 ans = i64(1) * n * (n - 1) / 2 * (n - 2) / 3;
for (auto [_, c] : cnt) {
if (c >= 3) {
ans = ans - i64(1) * c * (c - 1) / 2 * (c - 2) / 3;
}
if (c >= 2) {
ans = ans - i64(1) * c * (c - 1) / 2 * (n - c);
}
}
std::cout << ans << "\n";
}
E - Road Reduction
题意
给一张\(n\)个点\(m\)条边的无向图,现在只能保留\(n - 1\)条边,需要使得图保持连通且使\(\sum_{i = 2}^n d_i\)最小,其中\(d_i\)表示\(1\)到\(i\)的简单路径长度。
问应该保留哪些边?
\(n, m \le 2 \times 10^5\)。
思路
一眼最短路树,跑遍dijkstra就行了。
AC代码
// Problem: E - Road Reduction
// Contest: AtCoder - AtCoder Beginner Contest 252
// URL: https://atcoder.jp/contests/abc252/tasks/abc252_e
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
// std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
struct Edge {
int v;
int w;
int eid;
Edge() {}
Edge(int _v, int _w, int _eid) : v(_v), w(_w), eid(_eid) {}
};
struct Node {
int u;
i64 c;
Node() {}
Node(int _u, i64 _c) : u(_u), c(_c) {}
bool operator<(const Node& nd) const { return c > nd.c; }
};
void solve_case(int Case) {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<Edge>> g(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
std::cin >> u >> v >> w;
--u, --v;
g[u].push_back(Edge(v, w, i));
g[v].push_back(Edge(u, w, i));
}
std::vector<i64> dis(n, INT64_MAX);
std::vector<bool> vis(n, false);
std::vector<int> use(n, -1);
std::priority_queue<Node> q;
dis[0] = 0;
q.push(Node(0, dis[0]));
while (!q.empty()) {
auto [u, c] = q.top();
q.pop();
if (vis[u])
continue;
vis[u] = true;
for (auto [v, w, eid] : g[u]) {
if (dis[v] > c + w) {
dis[v] = c + w;
use[v] = eid;
q.push(Node(v, dis[v]));
}
}
}
for (int i = 1; i < n; ++i) {
std::cout << use[i] + 1 << " \n"[i + 1 == n];
}
}
F - Bread
题意
给一条长度为\(L\)的绳子。
每次可以选择一条长度为\(K\)的绳子,以\(K\)的代价将其分成两段,每段的长度需要是整数。
需要得到\(n\)条绳子分给\(n\)个人,第\(i\)个人得到的绳子长度为\(a_i\),可以有绳子剩下来,问最小代价。
\(n \le 2 \times 10^5,1 \le a_i \le 10^9, \sum_i a_i \le L \le 10^15\)。
思路
如果\(L = \sum_i a_i\),那就是构成huffman树的做法最优。
现在可能会多出来一些绳子,可以证明只多出一段的时候代价是最小的,所以就在\(a_1, a_2, \dots, a_n\)的基础上,再加一段\(L - \sum_i a_i\),然后跑huffman树。
AC代码
// Problem: F - Bread
// Contest: AtCoder - AtCoder Beginner Contest 252
// URL: https://atcoder.jp/contests/abc252/tasks/abc252_f
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
// std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
int n;
i64 l;
std::cin >> n >> l;
std::priority_queue<i64, std::vector<i64>, std::greater<i64>> q;
i64 z = 0;
for (int i = 0; i < n; ++i) {
int x;
std::cin >> x;
q.push(x);
z += x;
}
if (z < l)
q.push(l - z);
i64 ans = 0;
while (q.size() > 1) {
i64 x = q.top();
q.pop();
i64 y = q.top();
q.pop();
ans += x + y;
q.push(x + y);
}
std::cout << ans << "\n";
}
G - Pre-Order
题意
给出一颗树的先序遍历,一个节点的多个子节点按从小到大的优先级遍历,问对应这个先序遍历的树有多少种。
树种节点个数至多为\(500\)。
思路
区间DP。
假设\(dp_{l, r}\)表示:以\(?\)为根,先序遍历为\(?\ a_l\ a_{l + 1} \dots\ a_{r - 1}\)的树的种类,其中\(?\)为一个虚拟节点。
可以把\(l\)替换到\(?\)的位置,所以\(dp_{l + 1, r}\)也可以表示以\(l\)为根,先序遍历为\(a_l a_{l + 1}, \dots, a_{r-1}\)的树的种类。类似地有答案为\(dp_{2, n + 1}\)。
对于\(dp_{l, r}\),要么\(?\)只有一个子节点为\(l\),要么\(?\)还包含其他子节点,由于遍历的优先级,下一个子节点\(k\)必须满足\(a_l < a_k\)。
\[dp_{l, r} = \left\{ \begin{align*} &1 & r - l \le 1\\ & dp_{l + 1, r} + \sum_{\substack{l + 1 \le k < r\\a_l < a_k}} dp_{l + 1, k} \times dp_{k, r} & \text{ohterwise} \end{align*} \right. \]AC代码
// Problem: F - Bread
// Contest: AtCoder - AtCoder Beginner Contest 252
// URL: https://atcoder.jp/contests/abc252/tasks/abc252_f
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
// std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
int n;
i64 l;
std::cin >> n >> l;
std::priority_queue<i64, std::vector<i64>, std::greater<i64>> q;
i64 z = 0;
for (int i = 0; i < n; ++i) {
int x;
std::cin >> x;
q.push(x);
z += x;
}
if (z < l)
q.push(l - z);
i64 ans = 0;
while (q.size() > 1) {
i64 x = q.top();
q.pop();
i64 y = q.top();
q.pop();
ans += x + y;
q.push(x + y);
}
std::cout << ans << "\n";
}
Ex - K-th beautiful Necklace
题意
给\(n\)个宝石,第\(i\)珍珠颜色为\(c_i\),价值为\(v_i\),可以每种颜色的珍珠选一个构成一条项链,项链的权值为每颗珍珠权值的异或和。
求可能组出来的所有项链中,第\(k\)大的项链权值。
\(n \le 70, v_i < 2^60, k \le 10^18\),颜色数目不超过\(n\)。
思路
观察: 项链的种类不会超过\(3^{\frac{n}{3}}\)种。
证明:假设颜色为\(c\)的珍珠有\(n_c\)颗。尝试构造\(n_c\)使得\(\sum_c n_c = N\)且\(\prod_c n_c\)最大化。
- \(n_c = 1\),假设有另外一种颜色\(c^\prime\),\(n_c \times n_{c^\prime} \le n_c + n_{c^\prime}\),则\(c\)可以和\(c^\prime\)合并得到更多的项链种类。
- \(n_c = 2\),由于\(2^3 \le 3^2\),3个2可以合并成两个3从而得到更多的项链种类。
- \(n_c \ge 4\),由于\(2(n_c - 2) \ge n_c\),可以将\(n_c\)拆成\(2\)和\(n_c - 2\)从而获得更更多项链种类。
由此最差情况下\(n_c \in {2, 3}\)且至多只有两个\(2\),至多有\(O(3^{\frac{n}{3}})\)种项链。
然后可以将珍珠对半分,然后两边分别枚举出\(O(3^{\frac{n}{6}})\)种项链,分别记为集合\(A\)和\(B\),再由异或运算的结合律,合并两边的结果,从而得出答案。
可以将\(B\)中的数存进01-trie,这样每个\(A_i\)就可以通过01-trie实现\(O(\log V)\)查询\(A_i \oplus B_j > x\)的\(j\)的数量,再通过二分(从高位开始枚举每一位是0还是1)实现\(O(3^{\frac{n}{6}} \log^2 V)\)的做法。这个复杂度还是不够优秀。
可以将插入和查询按照位拆分成多步,用一个数组记录上一步的结果,在上一步的基础上推出下一步,这样就查询的时候就不用每次都从trie的根开始往下走,每个\(A_i\)就可以实现\(O(1)\)查询\(A_i \oplus B_j > x\)的\(j\)的数量,时间复杂度为\(O(3^{\frac{n}{6}} \log V)\)。
AC代码
// Problem: Ex - K-th beautiful Necklace
// Contest: AtCoder - AtCoder Beginner Contest 252
// URL: https://atcoder.jp/contests/abc252/tasks/abc252_h
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
// std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
struct Node {
Node* child[2];
int count;
};
void solve_case(int Case) {
int n, c;
i64 k;
std::cin >> n >> c >> k;
std::vector<std::vector<i64>> cc(c);
for (int i = 0; i < n; ++i) {
int x;
i64 y;
std::cin >> x >> y;
--x;
cc[x].push_back(y);
}
std::function<void(int, int, i64, std::vector<i64>&)> gen = [&](int p, int t, i64 x,
std::vector<i64>& A) -> void {
if (p == t) {
A.push_back(x);
return;
}
for (i64 v : cc[p]) {
gen(p + 1, t, x ^ v, A);
}
};
int d = c / 2;
std::vector<i64> A, B;
gen(0, d + 1, 0, A);
gen(d + 1, c, 0, B);
Node* null = new Node;
null->child[0] = null->child[1] = null;
null->count = 0;
Node* root = new Node;
root->child[0] = root->child[1] = null;
root->count = B.size();
std::vector<Node*> pa(A.size(), root), pb(B.size(), root);
i64 ans = 0;
for (i64 w = 59; w >= 0; --w) {
for (int i = 0; i < (int)B.size(); ++i) {
int c = (B[i] >> w) & 1;
if (pb[i]->child[c] == null) {
Node* new_node = new Node;
new_node->child[0] = new_node->child[1] = null;
new_node->count = 0;
pb[i]->child[c] = new_node;
}
pb[i] = pb[i]->child[c];
++pb[i]->count;
}
i64 gt = 0;
for (int i = 0; i < (int)A.size(); ++i) {
int c = (A[i] >> w) & 1;
gt = gt + (pa[i]->child[c ^ 1]->count);
}
if (gt < k) {
// ans + 0
k -= gt;
for (int i = 0; i < (int)A.size(); ++i) {
int c = (A[i] >> w) & 1;
pa[i] = pa[i]->child[c];
}
} else {
// ans + 1
ans = ans | (i64(1) << w);
for (int i = 0; i < (int)A.size(); ++i) {
int c = (A[i] >> w) & 1;
pa[i] = pa[i]->child[c ^ 1];
}
}
logd(k);
}
std::cout << ans << "\n";
}
标签:std,AtCoder,le,Beginner,int,cin,i64,ans,252 来源: https://www.cnblogs.com/zengzk/p/16296821.html