Day2
Hamiltonian
基环树和树构成的森林. 每个节点的值可以单向延边流向字节点, 总共可以给任意点增加权值 (m), 求最小值最大.
这个题的部分分给的特别多, 暴力打满就有 (72'). 场上我一个半小时写了 (56') 的数据点分治, 结果实测只 (52').
最后 (1H) 的时候想到能用二分答案, 写到最后 (10min) 也过不了大样例. 于是将暴力改改, 数据点分治, 暴力都解决不了的甩锅给二分答案, 爱得几分得几分, 发现最后的暴力是 (56'), 合着是二分答案作为正解就得了 (16').
不过最后只跑二分答案貌似也是 (72'), 所以还是问题不大.
下面是我的多级甩锅数据点分治, 考场 (72') 还不如暴力打满来的爽快的代码 (注释中出现的是数据点编号):
unsigned n, m, From[1000005], Cnt(0);
unsigned long long Ans(0), a[1000005], Sum[1000005], CirSum(0), Ave[1000005], CirAve(0), f[1000005], L, R, Mid, Root[1000005];
char flg(0), Yes[1000005], OnCir[1000005];
long long Left;
struct Node {
Node *Son, *Bro;
}N[1000005];
void DFS1(Node *x) {
register Node *now(x->Son);
while (now) {
if(!Root[now - N]) {
Root[now - N] = Root[x - N];
DFS1(now);
}
now = now->Bro;
}
return;
}
long long DFS(Node *x, long long Fa) {
register long long Tmp(Fa);
if(a[x - N] > Mid) {
Fa += a[x - N] - Mid;
} else {
Fa -= Mid - a[x - N];
}
Yes[x - N] = 1;
register Node *now(x->Son);
while (now) {
if(!Yes[now - N]) {
Fa = DFS(now, Fa);
}
now = now->Bro;
}
if(OnCir[x - N]) {
return Fa;
}
return min(Fa, Tmp);
}
char Judge(unsigned long long x) {
Left = m;
for (register unsigned i(1); i <= n; ++i) {
if(!Yes[i]) {
Left = DFS(N + i, Left);
}
}
return Left >= 0;
}
int main() {
n = RD(), m = RD();
for (register unsigned i(1); i <= n; ++i) {
From[i] = RDsg();
if(From[i] > 0x3f3f3f3f || From[i] == i) {
From[i] = 0;
}
}
for (register unsigned i(1); i <= n; ++i) {
a[i] = RD();
Sum[i] = Sum[i - 1] + a[i];
Ave[i] = Sum[i] / i;
}
if(!Sum[n]) { //6, 16, 17, 19
printf("%llu
", m / n);
return 0;
}
for (register unsigned i(1); i < n; ++i) {
if(From[i + 1] ^ i) {
flg = 1; break;
}
}
if(!flg) {
if(From[1] == n) { // 8, 9, 10, 11, 12, 13
printf("%llu
", (Sum[n] + m) / n);
return 0;
}
if(!From[1]) { // 3, 4, 5, 7
a[1] += m, Ave[1] = a[1], f[1] = 0;
for (register unsigned i(2); i <= n; ++i) {
if(Ave[i - 1] < a[i]) {
Ave[i] = Ave[i - 1];
f[i] = f[i - 1] + a[i] - Ave[i - 1];
} else {
if(f[i - 1] <= Ave[i - 1] - a[i]) {
Ave[i] = (Sum[i] + m) / i;
f[i] = (Sum[i] + m) % i;
} else {
Ave[i] = Ave[i - 1];
f[i] = f[i - 1] - Ave[i - 1] + a[i];
}
}
}
printf("%llu
", Ave[n]);
return 0;
}
}
for (register unsigned i(1); i <= n; ++i) {
if(From[i]) {
N[i].Bro = N[From[i]].Son;
N[From[i]].Son = N + i;
}
}
for (register unsigned i(1); i <= n; ++i) {
flg = 0;
register unsigned j(i);
while(!Root[j]) {
if(Yes[j]) {
Yes[j] = 0, OnCir[j] = 1;
Root[j] = j;
register unsigned Tmpj(j);
j = From[i];
while(!Root[j]) {
Root[j] = Tmpj;
Yes[j] = 0, OnCir[j] = 1;
j = From[j];
}
flg = 1; break;
}
Yes[j] = 1;
if(!From[j]) {
Root[j] = j;
DFS1(N + j);
flg = 1; break;
}
j = From[j];
}
if(!flg) {
DFS1(N + j);
}
}
L = 0, R = (Sum[n] + m) / n;
while (L < R) {
memset(Yes, 0, n + 1);
Mid = ((L + R + 1) >> 1);
if(Judge(Mid)) {
L = Mid;
} else {
R = Mid - 1;
}
}
printf("%llu
", L);
return 0;
}
接下来是把我的二分答案调成 (100'), 用了一个晚自习将自己的程序调成 (92'), 被卡常了, 冯育硕被卡常真是让人笑话. 在卡了一个小时常数后, 我成功通过了此题. 由于是在考场代码的基础上删掉数据点分治改的, 所以看起来会很难受, 但是能过.
int n, m, From[1000005], Cnt(0), Ans(0), List[1000005], Size[1000005];
char flg(0), Yes[1000005], OnCir[1000005], Vis[1000005];
long long a[1000005], Sum(0), Left, L, R, Mid;
struct Node {
Node *Son, *Bro;
}N[1000005];
void DFS1(Node *x) {
register Node *now(x->Son);
while (now) {
if(!Vis[now - N]) {
Vis[now - N] = 1;
DFS1(now);
}
now = now->Bro;
}
return;
}
long long DFS(Node *x, long long Fa) {
register long long Tmp(Fa);
if(OnCir[x - N]) {
Fa += a[x - N] - (Mid * Size[x - N]);
} else {
Fa += a[x - N] - Mid;
}
Yes[x - N] = 1;
register Node *now(x->Son);
while (now) {
if(!(Yes[now - N] & OnCir[now - N])) Fa = DFS(now, Fa);
now = now->Bro;
}
return min(Fa, Tmp);
}
char Judge() {
Left = m;
for (register int i(1); i <= Cnt; ++i) {
Left = DFS(N + List[i], Left);
}
return Left >= 0;
}
int main() {
n = RD(), m = RD();
for (register int i(1); i <= n; ++i) {
From[i] = RDsg();
if(From[i] < 0 || From[i] == i) From[i] = 0;
}
for (register int i(1); i <= n; ++i) a[i] = RD(), Sum += a[i];
for (register int i(1); i <= n; ++i) if(From[i])
N[i].Bro = N[From[i]].Son, N[From[i]].Son = N + i;
for (register int i(1), j; i <= n; ++i) {
flg = 0, j = i;
if(!Vis[j]) {
while(j) {
if(!From[j]) {
Vis[j] = 1, Size[j] = 1, List[++Cnt] = j, DFS1(N + j), flg = 1; break;
}
if(Yes[j]) {
register int Tmpj(j);
Vis[j] = 1, List[++Cnt] = j, j = From[i];
while(!OnCir[j]) {
Vis[j] = 1, OnCir[j] = 1, ++Size[Tmpj];
if(j ^ Tmpj) {
a[Tmpj] += a[j];
register Node *now(N[j].Son), *TmpBro;
N[j].Son = NULL;
while(now) {
TmpBro = now->Bro;
if(!OnCir[now - N]) now->Bro = N[Tmpj].Son, N[Tmpj].Son = now;
now = TmpBro;
}
}
j = From[j];
}
DFS1(N + Tmpj), flg = 1; break;
}
Yes[j] = 1, j = From[j];
}
}
if(!flg) DFS1(N + j);
}
flg = 0;
L = 0, R = (Sum + m) / n;
while (L < R) {
memset(Yes, 0, n + 1);
Mid = ((L + R + 1) >> 1);
if(Judge()) {
L = Mid;
} else {
R = Mid - 1;
}
}
printf("%llu
", L);
return 0;
}
Math
给三个等长序列, 定义区间 ([l, r]) 的权值为三个序列的区间极差乘积.
这个题我上来就写了 (6) 个 ST 表 然后把它用到了 (O(n^2)) 暴力上.
这个题输出 (0) 有 (20'), (n^2) 暴力有 (20'), 所以我只得了 (40').
但是这个常数极大的 (O(n^2)) 在别人大样例 (O(n^2)) 跑进 (10s) 的同时跑了 (180s). 我当时傻了没发现 ST 表 徒增常数, 还好刘少卿的暴力跑了 (500s).
下面是极具美学价值的考场代码:
unsigned A, B, C, Log[100005], n, m, a[100005], b[100005], c[100005], STA1[100005][18], STA2[100005][18], STB1[100005][18], STB2[100005][18], STC1[100005][18], STC2[100005][18];
unsigned long long Ans(0);
char flg(0);
inline unsigned Find(unsigned x[][18], const unsigned &l, const unsigned &r, const char &Ma) {
register unsigned LG(Log[r - l + 1]);
return Ma ? (max(x[l][LG], x[r - (1 << LG) + 1][LG])) : (min(x[l][LG], x[r - (1 << LG) + 1][LG]));
}
int main() {
n = RD();
for (register unsigned i(1); i <= n; ++i) {
a[i] = STA1[i][0] = STA2[i][0] = RD();
}
for (register unsigned i(1); i <= n; ++i) {
if(a[i] ^ 1) {
flg = 1;
break;
}
}
if(!flg) {
printf("0
");
return 0;
}
flg = 0;
for (register unsigned i(1); i <= n; ++i) {
b[i] = STB1[i][0] = STB2[i][0] = RD();
}
for (register unsigned i(1); i <= n; ++i) {
c[i] = STC1[i][0] = STC2[i][0] = RD();
}
for (register unsigned i(1), Lg(0); i <= n; i <<= 1, ++Lg) {
Log[i] = Lg;
}
for (register unsigned i(1); i <= n; ++i) {
Log[i] = max(Log[i], Log[i - 1]);
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STA1[i][loglen] = min(STA1[i][loglen - 1], STA1[i + leng][loglen - 1]);
}
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STA2[i][loglen] = max(STA2[i][loglen - 1], STA2[i + leng][loglen - 1]);
}
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STB1[i][loglen] = min(STB1[i][loglen - 1], STB1[i + leng][loglen - 1]);
}
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STB2[i][loglen] = max(STB2[i][loglen - 1], STB2[i + leng][loglen - 1]);
}
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STC1[i][loglen] = min(STC1[i][loglen - 1], STC1[i + leng][loglen - 1]);
}
}
for (register unsigned len(2), loglen(1); len <= n; len <<= 1, ++loglen) {
for (register unsigned i(n - len + 1), leng(len >> 1); i; --i) {
STC2[i][loglen] = max(STC2[i][loglen - 1], STC2[i + leng][loglen - 1]);
}
}
for (register unsigned i(1); i <= n; ++i)
for (register unsigned j(i); j <= n; ++j)
Ans += (Find(STA2, i, j, 1) - Find(STA1, i, j, 0)) * (Find(STB2, i, j, 1) - Find(STB1, i, j, 0)) * (Find(STC2, i, j, 1) - Find(STC1, i, j, 0));
printf("%u
", Ans);
return 0;
}
其实还有 (20') 别人推式子能推出来线性算法, 但是我推了 (1H) 还是没有推出来, 还是要在数学上下功夫.
最离谱的是我这个题本来想分块, 可惜分不得, 结果在第三道题上本来有分块的分却没想到.
Leetcode
这个题维护的是一堆操作, 对输入值进行形如 (v = |x - v|) 的操作, 每次查询 (v) 在依次经历区间 ([l, r]) 的所有操作后的值.
强制在线.
对于相同的起点和终点, 初值到结果的映射是一个分段函数, 段数和区间长度是指数关系. 用可持久化平衡树维护一个初始值的不同结果.
其实这个题我想了分层图, DP, 扫描线, 结果都没整出来, 唯一写出代码的 DP 还假了.
于是最后只写了一个 (20') 的无脑 (O(nm)), 极简主义代码:
unsigned n, m, a[100005], A, B, C, Last(0);
char flg(0);
int main() {
n = RD(), m = RD();
for (register unsigned i(1); i <= n; ++i) {
a[i] = RD();
}
for (register unsigned i(1); i <= m; ++i) {
A = RD() ^ Last, B = RD() ^ Last, C = RD() ^ Last;
for (register unsigned j(A); j <= B; ++j) {
C = (C < a[j]) ? (a[j] - C) : (C - a[j]);
}
printf("%u
", Last = C);
}
return 0;
}
其实在值域足够小的部分分, 可以分块做, 这个分块也近乎无脑了, 可是我没有想到. (明明第二题像了那么多分块) 所以白白扔了 (20').
正解竟然真的是扫描线, 我场上想了, 但是没做出来...
CF464E
(n) 点 (m) 边无向图. 第 (i) 条边的边权是 (2^{x_i}), 求两点最短路, 对 (10^9 + 7) 取模.
用 0/1 Trie 维护路径长度, 跑 Dijkstra. 为了实现加法, 在 Trie 上线段树维护所有极长 1 串, 然后区间修改这个 1 串为 0, 单点修改进位.
CF1446D2
求 (5 * 10^7) 长度的序列中最长的最少包含两个出现次数最多的元素的字段长度.
显然需要线性算法.
考虑整个序列的全局众数 (x) 的 (a) 个位置, 因为出现两个及以上的众数, 必须减少区间中 (x) 的数量.
CF700D
给序列的元素进行哈夫曼编码, 每次查询某区间的哈夫曼编码最短的元素的编码长度.
所以统计所有出现的元素的出现数量, 离散化. 然后数据结构维护这些编码的哈希值.
CF1476G
维护序列, 支持:
单点修改
查询区间中, 取 (k) 个元素出现次数 (Cnt) 的极差最小值
一个重要的性质: 不同的 (Cnt) 值有 (sqrt n) 种. 达到这种上界的情况是不同的出现次数为 (1), (2), (3),..., (x), 这时序列长度为 (frac{(1 + x)x}2).
带修莫队维护出现次数, 离线询问, 每次取 (k) 个元素的操作可以用数据结构维护 (Cnt) 数组实现, 可能需要对元素的值进行离散化.
CF1344E
一棵树, 从根往下走, 目标为点 (Dest), 边权是通行时间, 点瞬间经过. 在某点只能往下走, 且只能往某个特定的儿子走, 每个 Tick 可选择修改任意一个点的后继儿子.
给一些出发时刻, 求是否能使所有时刻出发的点都能到达目标, 否则求首个偏离目标的时间. 并且求达到上面的结果进行的最小操作数.
启发式合并 + 平衡树