QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#165406 | #6738. Cover | mendicillin2# | AC ✓ | 536ms | 31424kb | C++17 | 6.6kb | 2023-09-05 17:56:54 | 2023-09-05 17:56:55 |
Judging History
answer
#include <bits/stdc++.h>
using namespace std;
template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }
template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;
using ll = int64_t;
using vi = vc<int>;
mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
template <class F>
struct ycr {
F f;
template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}
template <class... Args> decltype(auto) operator()(Args&&... args) {
return f(ref(*this), forward<Args>(args)...);
}
};
template <class F> decltype(auto) yc(F&& f) {
return ycr<decay_t<F>>(forward<F>(f));
}
void wassert(bool b) {
if (!b) {
cout << "nmsl" << endl;
exit(0);
}
}
struct GC {
char buf[1<<16];
size_t s = 0, e = 0;
char operator()() {
if (s >= e) {
buf[0] = 0;
s = 0;
e = fread(buf, 1, sizeof(buf), stdin);
}
return buf[s++];
}
} gc;
int scan_int() {
char c;
while ((c = gc()) < 40);
if (c == '-') return -scan_int();
int a = c - '0';
while (isdigit(c = gc())) a = a * 10 + c - '0';
return a;
}
template <class T> void setmax(T& a, const T& b) {
if (a < b) a = b;
}
struct hldecomp {
int n;
vi ord;
vc<array<int, 2>> idx;
vc<pair<int, int>> heavy;
vvc<int> ch;
hldecomp(const vi& par) : n(sz(par)), ord(n), idx(n), heavy(n) {
ch.resize(n);
for (int i = 0; i < n; i++) {
if (par[i] != -1) {
ch[par[i]].push_back(i);
}
}
vi s(n);
int nidx = 0;
for (int i = 0; i < n; i++) {
if (par[i] != -1) continue;
yc([&](auto self, int v) -> void {
s[v] = 1;
for (int w : ch[v]) {
self(w);
s[v] += s[w];
}
if (!ch[v].empty()) {
auto mit = max_element(ch[v].begin(), ch[v].end(), [&](int a, int b) {
return s[a] < s[b];
});
swap(*ch[v].begin(), *mit);
}
})(i);
yc([&](auto self, int v, bool rt = true) -> void {
ord[idx[v][0] = nidx++] = v;
if (rt) {
heavy[idx[v][0]] = {par[v] == -1 ? -1 : idx[par[v]][0], 1};
} else {
assert(idx[par[v]][0] == idx[v][0]-1);
heavy[idx[v][0]] = heavy[idx[v][0]-1];
heavy[idx[v][0]].second++;
}
bool crt = false;
for (int w : ch[v]) {
self(w, crt);
crt = true;
}
idx[v][1] = nidx;
})(i);
}
assert(n == nidx);
}
int lca(int a, int b) {
a = idx[a][0], b = idx[b][0];
while (true) {
if (a > b) swap(a, b);
assert(a <= b);
if (a > b - heavy[b].second) {
return ord[a];
}
b = heavy[b].first;
if (b == -1) return -1;
}
}
bool in_subtree(int a, int p) const {
return idx[p][0] <= idx[a][0] &&
idx[a][1] <= idx[p][1];
}
};
template <class T> struct FT {
vc<T> d;
int s;
FT(int n) { init(n); }
void init(int n) {
d.clear();
d.resize(s = n);
}
void add(int i, T v) {
for (; i < s; i |= i+1) d[i] += v;
}
T get(int i) {
T res = 0;
for (; i; i &= i-1) res += d[i-1];
return res;
}
};
int main() {
//ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N, M, K;
N = scan_int();
M = scan_int();
K = scan_int();
vector<vector<int>> adj(N);
for (int e = 0; e < N-1; e++) {
int a = scan_int()-1;
int b = scan_int()-1;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<int> par(N);
{
yc([&](auto self, int cur, int prv) -> void {
par[cur] = prv;
for (int nxt : adj[cur]) {
if (nxt == prv) continue;
self(nxt, cur);
}
})(0, -1);
}
hldecomp hld(par);
const auto& tree = hld.ch;
struct P {
int a, b, w;
};
vector<vector<P>> paths(N);
for (int j = 0; j < M; j++) {
int a = scan_int()-1;
int b = scan_int()-1;
int w = scan_int();
int c = hld.lca(a, b);
paths[c].push_back(P{a, b, w});
}
vector<ll> ans(N);
FT<ll> ft_sum(N);
FT<ll> ft_sum_ch(N);
vector<ll> sum_ch(N);
vector<ll> cur_dp(1 << K);
vector<ll> cur_set_sum(1 << K);
yc([&](auto self, int cur) -> void {
for (int nxt : tree[cur]) {
self(nxt);
}
const int num_ch = int(tree[cur].size());
assert(num_ch <= K);
vector<ll> best(num_ch);
vector<vector<ll>> best2(num_ch, vector<ll>(num_ch));
auto update_sum = [&](int l, int r, ll x) -> void {
assert(x >= 0);
assert(l < r);
ft_sum.add(l, x);
ft_sum.add(r, -x);
};
auto get_sum = [&](int i) -> ll {
const int idx = hld.idx[i][0];
return ft_sum.get(idx+1);
};
auto get_which_ch = [&](int i) -> int {
for (int c = 0; c < num_ch; c++) {
if (hld.in_subtree(i, tree[cur][c])) return c;
}
assert(false);
};
auto get_val = [&](int i, int c) -> ll {
// Line
//return ans[i];
/*
ll res = get_sum_ch(i) - get_sum(i) - sum_ch[i] + ans[i];
res += ans[tree[cur][c]];
return res;
*/
//if (i != tree[cur][c]) res += ans[tree[cur][c]];
//assert(res == ans[i]);
/*
cerr << "sum_ch=" << get_sum_ch(i) << endl;
cerr << "sum=" << get_sum(i) << endl;
cerr << "get(" << cur << ", " << i << ") = " << res << endl;
return res;
*/
/*
ll res = ans[i];
if (i == tree[cur][c]) return res;
for (int prv = i, v = par[i]; ; prv = v, v = par[v]) {
res += sum_ch[v];
res -= ans[prv];
if (v == tree[cur][c]) break;
}
//assert(res == ans[i]);
return res;
*/
return get_sum(i);
};
for (auto [a, b, w] : paths[cur]) {
if (b == cur) {
swap(a, b);
}
if (a == cur) {
assert(b != cur);
const int b_ch = get_which_ch(b);
//assert(get_val(b) == ans[b]);
const ll val = get_val(b, b_ch) + w;
//assert(val <= ll(1e14));
setmax(best[b_ch], val);
} else {
int a_ch = get_which_ch(a);
int b_ch = get_which_ch(b);
//assert(get_val(a) == ans[a]);
//assert(get_val(b) == ans[b]);
const ll val = get_val(a, a_ch) + get_val(b, b_ch) + w;
//assert(val <= ll(1e14));
if (a_ch > b_ch) swap(a_ch, b_ch);
assert(a_ch < b_ch);
setmax(best2[a_ch][b_ch], val);
}
}
for (int m = 1; m < (1 << num_ch); m++) {
const int i = __builtin_ctz(m);
cur_dp[m] = cur_dp[m - (1 << i)] + max(best[i], ans[tree[cur][i]]);
for (int j = i+1; j < num_ch; j++) {
if (m & (1 << j)) {
setmax(cur_dp[m], cur_dp[m - (1 << i) - (1 << j)] + best2[i][j]);
}
}
}
ans[cur] = cur_dp[(1 << num_ch) - 1];
update_sum(hld.idx[cur][0], hld.idx[cur][0]+1, ans[cur]);
for (int c = 0; c < num_ch; c++) {
int nxt = tree[cur][c];
update_sum(hld.idx[nxt][0], hld.idx[nxt][1], cur_dp[(1 << num_ch) - 1 - (1 << c)]);
}
//cerr << "ans(" << cur << ")=" << ans[cur] << endl;
})(0);
cout << ans[0] << '\n';
}
詳細信息
Test #1:
score: 100
Accepted
time: 2ms
memory: 3808kb
input:
5 7 3 1 2 1 3 2 4 2 5 3 2 8 5 4 10 3 1 2 1 2 7 2 1 2 1 2 1 5 2 3
output:
19
result:
ok 1 number(s): "19"
Test #2:
score: 0
Accepted
time: 536ms
memory: 28220kb
input:
100000 500000 12 2 1 3 2 4 2 5 2 6 5 7 2 8 5 9 3 10 2 11 2 12 5 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 1 21 1 22 1 23 1 24 12 25 2 26 2 27 2 28 2 29 2 30 15 31 30 32 23 33 26 34 22 35 30 36 26 37 3 38 3 39 3 40 3 41 3 42 3 43 3 44 3 45 3 46 3 47 20 48 21 49 4 50 4 51 4 52 4 53 4 54 4 55 4 56 4 57 4 5...
output:
660925834533
result:
ok 1 number(s): "660925834533"
Test #3:
score: 0
Accepted
time: 525ms
memory: 28748kb
input:
100000 500000 12 2 1 3 2 4 1 5 4 6 2 7 5 8 2 9 7 10 8 11 3 12 11 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 1 21 1 22 1 23 22 24 8 25 2 26 2 27 2 28 2 29 2 30 2 31 2 32 2 33 26 34 27 35 23 36 13 37 3 38 3 39 3 40 3 41 3 42 3 43 3 44 3 45 3 46 3 47 14 48 8 49 4 50 4 51 4 52 4 53 4 54 4 55 4 56 4 57 4 58 4...
output:
664434138007
result:
ok 1 number(s): "664434138007"
Test #4:
score: 0
Accepted
time: 532ms
memory: 27548kb
input:
100000 500000 12 2 1 3 1 4 2 5 3 6 4 7 2 8 7 9 2 10 6 11 4 12 8 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 1 21 1 22 1 23 13 24 23 25 2 26 2 27 2 28 2 29 2 30 2 31 2 32 2 33 26 34 31 35 33 36 33 37 3 38 3 39 3 40 3 41 3 42 3 43 3 44 3 45 3 46 3 47 34 48 16 49 4 50 4 51 4 52 4 53 4 54 4 55 4 56 4 57 4 58 ...
output:
639691495391
result:
ok 1 number(s): "639691495391"
Test #5:
score: 0
Accepted
time: 525ms
memory: 26336kb
input:
100000 500000 12 2 1 3 1 4 2 5 1 6 5 7 4 8 2 9 1 10 4 11 8 12 7 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 1 21 14 22 14 23 21 24 20 25 2 26 2 27 2 28 2 29 2 30 2 31 2 32 2 33 2 34 23 35 31 36 7 37 3 38 3 39 3 40 3 41 3 42 3 43 3 44 3 45 3 46 3 47 3 48 29 49 4 50 4 51 4 52 4 53 4 54 4 55 4 56 4 57 4 58 3...
output:
662244733768
result:
ok 1 number(s): "662244733768"
Test #6:
score: 0
Accepted
time: 533ms
memory: 26960kb
input:
100000 500000 12 2 1 3 1 4 1 5 1 6 3 7 1 8 4 9 3 10 7 11 2 12 5 13 1 14 1 15 1 16 1 17 1 18 1 19 1 20 14 21 12 22 11 23 9 24 20 25 2 26 2 27 2 28 2 29 2 30 2 31 2 32 2 33 2 34 2 35 14 36 30 37 3 38 3 39 3 40 3 41 3 42 3 43 3 44 3 45 3 46 24 47 38 48 35 49 4 50 4 51 4 52 4 53 4 54 4 55 4 56 4 57 4 58...
output:
669458090009
result:
ok 1 number(s): "669458090009"
Test #7:
score: 0
Accepted
time: 89ms
memory: 30228kb
input:
100000 500000 12 2 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 11 13 12 14 13 15 14 16 15 17 16 18 17 19 18 20 19 21 20 22 21 23 22 24 23 25 24 26 25 27 26 28 27 29 28 30 29 31 30 32 31 33 32 34 33 35 34 36 35 37 36 38 37 39 38 40 39 41 40 42 41 43 42 44 43 45 44 46 45 47 46 48 47 49 48 50 49 51 50 ...
output:
488921502446
result:
ok 1 number(s): "488921502446"
Test #8:
score: 0
Accepted
time: 96ms
memory: 29608kb
input:
100000 500000 12 2 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 11 13 12 14 13 15 14 16 15 17 16 18 17 19 18 20 19 21 20 22 21 23 22 24 23 25 24 26 25 27 26 28 27 29 28 30 29 31 30 32 31 33 32 34 33 35 34 36 35 37 36 38 37 39 38 40 16 41 40 42 41 43 42 44 33 45 44 46 45 47 46 48 47 49 48 50 49 51 50 ...
output:
468137226275
result:
ok 1 number(s): "468137226275"
Test #9:
score: 0
Accepted
time: 71ms
memory: 28988kb
input:
100000 500000 12 2 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 11 13 12 14 13 15 14 16 15 17 16 18 17 19 18 20 19 21 20 22 21 23 22 24 23 25 24 26 25 27 26 28 27 29 28 30 29 31 30 32 31 33 32 34 33 35 34 36 35 37 36 38 37 39 38 40 39 41 40 42 41 43 42 44 43 45 44 46 45 47 46 48 47 49 48 50 35 51 50 ...
output:
483733769728
result:
ok 1 number(s): "483733769728"
Test #10:
score: 0
Accepted
time: 87ms
memory: 30172kb
input:
100000 500000 12 2 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 11 13 12 14 13 15 14 16 15 17 16 18 17 19 18 20 19 21 20 22 21 23 22 24 23 25 24 26 25 27 26 28 27 29 28 30 29 31 30 32 31 33 32 34 33 35 34 36 35 37 36 38 37 39 38 40 39 41 40 42 41 43 42 44 43 45 44 46 45 47 46 48 47 49 48 50 49 51 50 ...
output:
478945297872
result:
ok 1 number(s): "478945297872"
Test #11:
score: 0
Accepted
time: 80ms
memory: 31424kb
input:
100000 500000 12 2 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 11 13 12 14 13 15 14 16 15 17 16 18 17 19 18 20 19 21 20 22 21 23 22 24 23 25 24 26 25 27 26 28 27 29 28 30 29 31 30 32 31 33 32 34 33 35 34 36 35 37 36 38 37 39 38 40 39 41 40 42 41 43 42 44 43 45 44 46 45 47 46 48 47 49 48 50 49 51 50 ...
output:
489443708266
result:
ok 1 number(s): "489443708266"
Test #12:
score: 0
Accepted
time: 65ms
memory: 13768kb
input:
10000 500000 12 2 1 3 2 4 1 5 1 6 2 7 5 8 2 9 8 10 6 11 8 12 4 13 11 14 1 15 6 16 5 17 10 18 17 19 12 20 8 21 16 22 1 23 5 24 21 25 23 26 3 27 18 28 6 29 8 30 15 31 1 32 30 33 17 34 23 35 5 36 24 37 33 38 25 39 34 40 1 41 24 42 11 43 6 44 18 45 28 46 25 47 32 48 40 49 29 50 43 51 33 52 9 53 2 54 20 ...
output:
560772428222
result:
ok 1 number(s): "560772428222"
Test #13:
score: 0
Accepted
time: 54ms
memory: 12340kb
input:
10000 500000 12 2 1 3 2 4 2 5 2 6 4 7 5 8 4 9 4 10 4 11 4 12 10 13 5 14 13 15 9 16 15 17 2 18 5 19 14 20 11 21 11 22 20 23 20 24 1 25 5 26 15 27 20 28 17 29 4 30 18 31 12 32 14 33 18 34 18 35 16 36 31 37 18 38 19 39 12 40 17 41 14 42 7 43 27 44 25 45 13 46 35 47 10 48 15 49 46 50 44 51 21 52 15 53 2...
output:
572767352204
result:
ok 1 number(s): "572767352204"
Test #14:
score: 0
Accepted
time: 49ms
memory: 11972kb
input:
10000 500000 12 2 1 3 1 4 2 5 2 6 2 7 4 8 7 9 7 10 2 11 9 12 3 13 1 14 7 15 9 16 8 17 2 18 13 19 12 20 2 21 16 22 8 23 13 24 8 25 20 26 25 27 14 28 4 29 28 30 4 31 12 32 13 33 24 34 1 35 21 36 5 37 16 38 28 39 35 40 28 41 13 42 20 43 19 44 16 45 40 46 28 47 3 48 5 49 14 50 2 51 4 52 47 53 47 54 15 5...
output:
585482767864
result:
ok 1 number(s): "585482767864"
Test #15:
score: 0
Accepted
time: 62ms
memory: 11760kb
input:
10000 500000 12 2 1 3 2 4 3 5 3 6 3 7 5 8 7 9 4 10 3 11 2 12 7 13 4 14 8 15 9 16 1 17 12 18 13 19 2 20 3 21 16 22 10 23 20 24 4 25 19 26 6 27 17 28 5 29 17 30 27 31 22 32 14 33 11 34 4 35 24 36 34 37 14 38 23 39 18 40 30 41 28 42 36 43 12 44 5 45 14 46 17 47 11 48 14 49 16 50 16 51 18 52 30 53 17 54...
output:
564574799774
result:
ok 1 number(s): "564574799774"
Test #16:
score: 0
Accepted
time: 56ms
memory: 12668kb
input:
10000 500000 12 2 1 3 1 4 2 5 2 6 4 7 6 8 5 9 8 10 7 11 7 12 5 13 1 14 5 15 11 16 9 17 3 18 4 19 10 20 8 21 2 22 11 23 18 24 10 25 8 26 16 27 22 28 11 29 20 30 12 31 4 32 19 33 27 34 6 35 1 36 24 37 18 38 30 39 32 40 10 41 9 42 15 43 34 44 27 45 34 46 7 47 34 48 39 49 32 50 13 51 11 52 38 53 17 54 5...
output:
575291114848
result:
ok 1 number(s): "575291114848"