翻开以前打的 #583，水平不够场上只过了五题。最近来补一下题，来记录我sb的调试过程。
估计我这个水平现场也过不了，因为前面的题已经zz调了好久……
F：就是给你环上一些点，两两配对求距离最小值。
匹配边明显是不能交叉的啊。那就直接转一个环就好了。
考虑计算贡献，盲猜一个点的贡献方向改变不会特别多，观看题解以验证，证明一发，发现猜对了。
很明显，考虑 \(x \leq y\)，那么固定 \(y\)，一定有一个分界点，使得 \(y - x > m - x + y\)。
开一个长度为 \(n\) 的数组，表示转 \(\frac{2 \pi i}{n}\)。
所以对于每个点计算一下贡献，对于一个连续段贡献相同，直接差分前缀和就行。
边界还是要仔细考虑的，也就是 \(y - x = m - x + y\) 的时候。分别考虑两个环贡献，具有对偶性，那么写成一个函数时就要注意边界。
细节也不多，过了样例就A了。
#include <bits/stdc++.h>
const int MAXN = 200010;
typedef long long LL;
int n, R;
struct node {
LL at; int id;
bool operator < (node b) const { return at < b.at; }
} as[MAXN], bs[MAXN];
int ansl[MAXN];
LL pre1[MAXN], pre2[MAXN], * pre;
void _mkadd(int l, int r, int v) {
pre[l] += v, pre[r + 1] -= v;
}
void mkadd(int l, int r, int v, int dta) {
if (l >= r) return ;
--r;
l = (l - 1 - dta + n) % n + 1;
r = (r - 1 - dta + n) % n + 1;
if (l <= r) _mkadd(l, r, v);
else _mkadd(1, r, v), _mkadd(l, n, v);
}
void pusharr(int at, node * dst, int dta) {
node * it;
if (dst == bs)
it = std::lower_bound(dst + 1, dst + 1 + n, (node) {at << 1, 0});
else
it = std::upper_bound(dst + 1, dst + 1 + n, (node) {at << 1, 0});
node * lhs = std::upper_bound(dst + 1, it, (node) {2 * at - R, 0});
node * rhs = std::lower_bound(it, dst + 1 + n, (node) {2ll * at + R, 0});
const int delta = (dst != as) * R;
mkadd(1, lhs - dst, delta - at, dta);
mkadd(lhs - dst, it - dst, at, dta);
mkadd(it - dst, rhs - dst, -at, dta);
mkadd(rhs - dst, 1 + n, delta + at, dta);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> R >> n;
for (int i = 1; i <= n; ++i) as[i].id = i, std::cin >> as[i].at;
for (int i = 1; i <= n; ++i) bs[i].id = i, std::cin >> bs[i].at;
std::sort(as + 1, as + 1 + n);
std::sort(bs + 1, bs + 1 + n);
for (int i = 1; i <= n; ++i) as[i].at <<= 1, bs[i].at <<= 1;
for (int i = 1; i <= n; ++i) {
pre = pre1, pusharr(as[i].at >> 1, bs, i - 1);
pre = pre2, pusharr(bs[i].at >> 1, as, i - 1);
}
LL ans = 0x3f3f3f3f3f3f3f3fLL; int at = 1;
for (int i = 1; i <= n; ++i)
pre1[i] += pre1[i - 1], pre2[i] += pre2[i - 1];
for (int i = 1; i <= n; ++i) {
LL now = pre1[i] + pre2[i > 1 ? n - i + 2 : 1];
if (now < ans) ans = now, at = i;
}
for (int i = 1; i <= n; ++i)
ansl[as[i].id] = bs[(i + at - 2) % n + 1].id;
std::cout << ans << std::endl;
for (int i = 1; i <= n; ++i)
std::cout << ansl[i] << ' ';
std::cout << std::endl;
return 0;
}G：询问是否存在一个矩形的四个顶点，对角相等，邻边相反的点，带一行的区间修改。
看到数据范围，\(m \times Q = 10^9\)，自然 bitset。但是怎么维护呢？
考虑两行，记 \(A\) 为其中一行 \(1\) 出现的位置， \(B\) 是另一行的 \(1\)，所有位置（全集）就是 \(U\)。
那么就是 \(A \cap \left(U \backslash B\right)\) 和 \(B \cap \left(U \backslash A\right)\) 都非空，这个判定函数记为 \(f(A, B) = [A \cap \left(U \backslash B \right) \neq \emptyset][B \cap \left(U \backslash A \right) \neq \emptyset]\)。
根据题解，\(\neg f\left(A,B\right)\) 具有传递性。其实这个是集合包含啦，如果两个集合互不包含，就会有解。（我太菜没从上面想到包含关系）
那么显然无解时包含关系形成了一条链。我们直接按集合大小排序，然后维护相邻不包含关系的集合即可。
手写bitset写挂……貌似效率还没stl高。
#include <bits/stdc++.h>
const int MAXN = 2000;
typedef long long LL;
int n, m, Q;
const int dig = 2048 / 64;
struct bitset {
LL A[dig]; int ppc;
bool contains(const bitset & b) const {
for (int i = 0; i != dig; ++i)
if ((A[i] & b.A[i]) != b.A[i])
return false;
return true;
}
void rev(int l, int r) {
for (int i = (l >> 6); i <= (r >> 6); ++i)
ppc -= __builtin_popcountll(A[i]);
A[l >> 6] ^= ((1ll << (l & 63)) - 1) ^ -1;
A[r >> 6] ^= (r & 63) == 63 ? -1 : (1ll << ((r & 63) + 1)) - 1;
(l >> 6) == (r >> 6) ? (A[l >> 6] ^= -1) : 0;
for (int i = (l >> 6) + 1; i < (r >> 6); ++i) A[i] ^= -1;
for (int i = (l >> 6); i <= (r >> 6); ++i)
ppc += __builtin_popcountll(A[i]);
}
int ctzofandinvb(const bitset & b) {
for (int i = 0; i != dig; ++i) {
LL now = A[i] & ~b.A[i];
if (now) return i << 6 | __builtin_ctzll(now);
}
return -1;
}
} mat[MAXN];
typedef std::pair<int, int> PII;
std::set<PII> S, diff;
int getsuc(std::set<PII>::iterator it) {
return ++it != S.end() ? it -> second : -1;
}
int getpre(std::set<PII>::iterator it) {
return it != S.begin() ? (--it) -> second : -1;
}
void ins(int a, int b) {
if (a == -1 || b == -1) return ;
if (!mat[b].contains(mat[a]))
diff.insert(PII(a, b));
}
void del(int a, int b) {
if (a == -1 || b == -1) return ;
diff.erase(PII(a, b));
}
bitset t;
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> m >> Q;
for (int i = 0; i < n; ++i) S.insert(PII(0, i));
int t1, t2, t3;
while (Q --> 0) {
std::cin >> t1 >> t2 >> t3; --t1, --t2, --t3;
auto t = S.find(PII(mat[t1].ppc, t1));
int suc = getsuc(t), pre = getpre(t);
del(pre, t1); del(t1, suc);
S.erase(t); mat[t1].rev(t2, t3);
auto at = S.insert(PII(mat[t1].ppc, t1)).first;
int ts = getsuc(at), tp = getpre(at);
del(tp, ts);
ins(tp, t1); ins(t1, ts);
if (ts != suc && tp != pre) ins(pre, suc);
if (diff.empty()) std::cout << "-1\n";
else {
PII t = *diff.begin();
int x1 = t.first, x2 = t.second;
int y1 = mat[x1].ctzofandinvb(mat[x2]);
int y2 = mat[x2].ctzofandinvb(mat[x1]);
if (x1 > x2) std::swap(x1, x2);
if (y1 > y2) std::swap(y1, y2);
++x1, ++x2, ++y1, ++y2;
std::cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\n';
}
}
return 0;
}H：给树 \(K\) 染色，使得所有长为 \(K\) 的路径恰好包含所有 \(K\) 种颜色。
一道简单题，但我挂了一堆 sb 地方
显然，应该找出直径来。然后直径上插入一些子树，根据在直径上的位置调整颜色。颜色就从上往下按顺序分配。
有了这个，我们考虑无解情况：
如果在直径上，从左边和右边都能下来，那么直径必须回文。
所以先特判掉 \(K = 2\) 的情况，剩下直径肯定不回文。
乍一看这个判定太弱了。我们考虑颜色分配，祖先链分配下来分叉成两个子树，两个子树的链又能拼成长度为 \(K\) 的链，那这链必须存在回文，必定无解。
也就是存在一个点，往三个方向 \(A, B, C\)，\(AB, BC, AC\) 三个方向的链长度都大于等于 \(K\)。
那么最后的问题就是考虑直径上怎么下去了。
如果能从右边下来，那么编号分配的 \(delta = -1\)，否则就是 \(1\)。
据说我直径求完没加 \(1\) 导致少一个点，还有 dp 时在根加入了没用的子树导致 \(No\) 判挂，取模有两处应该写 \(K\) 结果写了 \(R\)……
实际上细节不多。
#include <bits/stdc++.h>
const int MAXN = 200010;
void bye() { std::cout << "No\n"; exit(0); }
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], tot;
void addedge(int b, int e) {
nxt[++tot] = head[b]; to[head[b] = tot] = e;
nxt[++tot] = head[e]; to[head[e] = tot] = b;
}
int ansl[MAXN];
int n, K;
void simpledfs(int u, int fa = 0, int col = 1) {
ansl[u] = col;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa)
simpledfs(to[i], u, col ^ 1);
}
int dis[MAXN];
void dfsx(int u, int fa = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
dis[to[i]] = dis[u] + 1;
dfsx(to[i], u);
}
}
const int INF = 0x3f3f3f3f;
struct data {
int a[3];
data() { a[0] = a[1] = a[2] = -INF; }
void insert(int x) {
if (x >= a[0]) a[2] = a[1], a[1] = a[0], a[0] = x;
else if (x >= a[1]) a[2] = a[1], a[1] = x;
else if (x >= a[2]) a[2] = x;
}
void shift() { ++a[0], ++a[1], ++a[2]; }
} val[MAXN], vt[MAXN];
void dfs1(int u, int fa = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
dfs1(to[i], u);
val[u].insert(std::max(val[to[i]].a[0], 0) + 1);
}
}
void dfs2(int u, int fa = 0, int upv = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
int tv = std::max(upv, val[u].a[val[to[i]].a[0] + 1 == val[u].a[0]]) + 1;
dfs2(to[i], u, tv);
}
vt[u] = val[u]; if (fa) vt[u].insert(upv);
if (vt[u].a[2] + vt[u].a[1] + 1 >= K) bye();
}
int li[MAXN], inc[MAXN];
bool mark(int u, int dst, int fa = 0) {
if (u == dst) {
li[dis[u]] = u;
return true;
}
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
if (mark(to[i], dst, u)) {
li[dis[u]] = u;
return true;
}
}
return false;
}
int R;
void dfsmk(int u, int fa, int now, int delta) {
now = (now + delta) % K;
ansl[u] = now;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa)
dfsmk(to[i], u, now, delta);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> K;
for (int i = 1, t1, t2; i < n; ++i) {
std::cin >> t1 >> t2;
addedge(t1, t2);
}
if (K == 2) simpledfs(1);
else {
dfs1(1); dfs2(1);
dis[1] = 0; dfsx(1);
int at = 1, rt;
for (int i = 2; i <= n; ++i) if (dis[i] > dis[at]) at = i;
dis[at] = 0; dfsx(rt = at);
at = 1;
for (int i = 2; i <= n; ++i) if (dis[i] > dis[at]) at = i;
R = dis[at] + 1;
mark(rt, at);
for (int i = 0; i < R; ++i) inc[li[i]] = true;
for (int i = 0; i < R; ++i) {
ansl[li[i]] = i % K;
int dta = R - 1 - i > i ? K - 1 : 1;
for (int j = head[li[i]]; j; j = nxt[j])
if (!inc[to[j]])
dfsmk(to[j], li[i], i, dta);
}
}
std::cout << "Yes" << std::endl;
for (int i = 1; i <= n; ++i) std::cout << ansl[i] + 1 << ' ';
std::cout << std::endl;
return 0;
}