本文详细解析了CTSC2018中一道名为《林克卡特树》的问题，针对其中k=0的部分分，介绍了如何通过边分治策略结合树形DP来解决树上最长链问题。
[LOJ#2553][CTSC2018]暴力写挂
试题描述
temporaryDO 是一个很菜的 OIer 。在 4 月，他在省队选拔赛的考场上见到了《林克卡特树》一题，其中 \(k = 0\) 的部分分是求树 \(T\) 上的最长链。可怜的 temporaryDO 并不会做这道题，他在考场上抓猫耳挠猫腮都想不出一点思路。
这时，善良的板板出现在了空中，他的身上发出璀璨却柔和的光芒，荡漾在考场上。‘‘题目并不难。’’ 板板说。那充满磁性的声音，让 temporaryDO 全身充满了力量。 他决定：写一个枚举点对求 LCA 算距离的 \(k = 0\) 的 $\(O(n^2\log\ n)\) 的部分分程序！于是， temporaryDO 选择以 \(1\) 为根，建立了求 LCA 的树链剖分结构，然后写了二重 for 循环枚举点对。
然而，菜菜的 temporaryDO 不小心开小了数组，于是数组越界到了一片神秘的内存区域。但恰好的是，那片内存区域存储的区域恰好是另一棵树 \(T'\)。这样一来，程序并没有 RE ，但他求 \(x\) 和 \(y\) 的距离的时候，计算的是
\[ depth(x) + depth(y) - (depth(LCA(x, y)) + depth'(LCA'(x, y))) \]
最后程序会输出每一对点对 \(i, j (i \le j)\) 的如上定义的‘‘距离’’ 的最大值。
temporaryDO 的程序在评测时光荣地爆零了。但他并不服气，他决定花好几天把自己的程序跑出来。请你根据 \(T\) 和 \(T'\) 帮帮可怜的 temporaryDO 求出他程序的输出。
输入
第一行包含一个整数 \(n\) ，表示树上的节点个数；
第 \(2\) 到第 \(n\) 行，每行三个整数 \(x , y , v\)，表示 \(T\) 中存在一条从 \(x\) 到 \(y\) 的边，其长度为 \(v\)； 第 \(n + 1\) 到第 \(2n - 1\) 行，每行三个整数 \(x , y , v\)，表示 \(T'\) 中存在一条从 \(x\) 到 \(y\) 的边，其长度为 \(v\)。
输出
输出一行一个整数，表示 temporaryDO 的程序的输出。
输入示例
6
1 2 2
1 3 0
2 4 1
2 5 -7
3 6 0
1 2 -1
2 3 -1
2 5 3
2 6 -2
3 4 8输出示例
5数据规模及约定
对于所有数据， \(n \le 366666 , |v| \le 2017011328\)。
\(depth(p)\) 和 \(depth'(p)\) 分别表示树 \(T\)、\(T'\) 中点 \(1\) 到点 \(p\) 的距离，这里规定，距离指的是经过的边的边权总和，其中 \(depth(1) = 0\)。
\(LCA(x, y)\) 和 \(LCA'(x, y)\) 分别表示树 \(T\)、\(T'\) 中点 \(x\) 与点 \(y\) 的最近公共祖先，即在从 \(x\) 到 \(y\) 的最短路径上的距离根经过边数最少的点。
题解
搁置已久的大锅终于搞掉了……这个题让自带大常数的我卡得生活不能自理……
将第一棵树转化成二叉树后边分治，那么考虑重心边的两侧一定有一侧是更“靠近”根的；假设集合 \(A\) 离根更近，集合 \(B\) 离根更远，那么 \(\forall x \in A\) 都有 \(\forall y \in B, y' \in B, lca(x, y) = lca(x, y')\)，其中 \(lca(a, b)\) 表示在原树上 \(a\) 和 \(b\) 的最近公共祖先。
那么这样我们可以枚举 \(x\)，然后 \(depth(x) - depth(lca(x, y))\) 就固定了，我们就是要找到最小的 \(depth(y) - depth'(lca'(x, y))\)，这个东西建一下虚树然后树形 dp 即可（正反两次 dp，一次从子树往上推，第二次从父节点更新到子节点）。
#include <bits/stdc++.h>
using namespace std;
#define rep(i, s, t) for(int i = (s), mi = (t); i <= mi; i++)
#define dwn(i, s, t) for(int i = (s), mi = (t); i >= mi; i--)
const int BufferSize = 1 << 16;
char buffer[BufferSize], *Head, *Tail;
char Getchar() {
if(Head == Tail) {
int l = fread(buffer, 1, BufferSize, stdin);
Tail = (Head = buffer) + l;
}
return *Head++;
}
int read() {
int x = 0, f = 1; char c = Getchar();
while(!isdigit(c)){ if(c == '-') f = -1; c = Getchar(); }
while(isdigit(c)){ x = x * 10 + c - '0'; c = Getchar(); }
return x * f;
}
#define maxn 800010
#define maxm 1600010
#define maxlog 21
#define pii pair <int, int>
#define x first
#define y second
#define mp(x, y) make_pair(x, y)
#define LL long long
int Log[maxn<<1];
struct tree {
int n, m, head[maxn], nxt[maxm], to[maxm], dist[maxm];
tree(): m(0) { memset(head, 0, sizeof(head)); }
void AddEdge(int a, int b, int c) {
to[++m] = b; dist[m] = c; nxt[m] = head[a]; head[a] = m;
swap(a, b);
to[++m] = b; dist[m] = c; nxt[m] = head[a]; head[a] = m;
return ;
}
} Tmp;
struct Tree {
int n, m, head[maxn], nxt[maxm], to[maxm], dist[maxm], id[maxm], dep[maxn], dfn[maxn], clo, mnp[maxlog][maxn<<1];
LL Dep[maxn];
Tree(): m(0) { memset(head, 0, sizeof(head)); }
void AddEdge(int a, int b, int c, int Id = 0) {
to[++m] = b; dist[m] = c; id[m] = Id; nxt[m] = head[a]; head[a] = m;
swap(a, b);
to[++m] = b; dist[m] = c; id[m] = Id; nxt[m] = head[a]; head[a] = m;
return ;
}
void build(int u, int fa) {
mnp[0][dfn[u] = ++clo] = u;
for(int e = head[u]; e; e = nxt[e]) if(to[e] != fa) {
dep[to[e]] = dep[u] + 1;
Dep[to[e]] = Dep[u] + dist[e];
build(to[e], u);
mnp[0][++clo] = u;
}
return ;
}
void rmq_init() {
Log[1] = 0;
rep(i, 2, clo) Log[i] = Log[i>>1] + 1;
rep(i, 1, Log[clo])
rep(j, 1, clo - (1 << i) + 1) {
int a = mnp[i-1][j], b = mnp[i-1][j+(1<<i>>1)];
mnp[i][j] = dep[a] < dep[b] ? a : b;
}
return ;
}
int lca(int a, int b) {
int l = dfn[a], r = dfn[b];
if(l > r) swap(l, r);
int t = Log[r-l+1], A = mnp[t][l], B = mnp[t][r-(1<<t)+1];
return dep[A] < dep[B] ? A : B;
}
} T, T1;
namespace rebuildTree {
int sons[maxn], sonv[maxn], cs, M;
void getT(int u, int fa) {
for(int e = Tmp.head[u]; e; e = Tmp.nxt[e]) if(Tmp.to[e] != fa) getT(Tmp.to[e], u);
cs = 0;
for(int e = Tmp.head[u]; e; e = Tmp.nxt[e]) if(Tmp.to[e] != fa) sons[++cs] = Tmp.to[e], sonv[cs] = Tmp.dist[e];
// printf("%d has %d sons\n", u, cs);
if(cs <= 2) rep(i, 1, cs) T.AddEdge(u, sons[i], sonv[i], ++M);
else {
T.n++; T.AddEdge(T.n, sons[1], sonv[1], ++M); T.AddEdge(T.n, sons[2], sonv[2], ++M);
rep(i, 3, cs - 1) T.n++, T.AddEdge(T.n, T.n - 1, 0, ++M), T.AddEdge(T.n, sons[i], sonv[i], ++M);
T.AddEdge(u, T.n, 0, ++M); T.AddEdge(u, sons[cs], sonv[cs], ++M);
}
return ;
}
void build() {
getT(1, 0);
// printf("M: %d, %d\n", M, T.n);
T.build(1, 0); T1.build(1, 0);
T.rmq_init(); T1.rmq_init();
return ;
}
}
namespace Solve {
const LL ool = 1ll << 60;
LL ans = -ool;
namespace Vtree {
int KeyPoint[maxn], K;
int m, head[maxn], nxt[maxm], to[maxm];
LL val[maxn], extra[maxn];
void clear() {
rep(i, 1, K) val[KeyPoint[i]] = extra[KeyPoint[i]] = -ool, head[KeyPoint[i]] = 0;
K = m = 0;
return ;
}
void AddEdge(int a, int b) {
to[++m] = b; nxt[m] = head[a]; head[a] = m;
return ;
}
LL f[maxn], pre[maxn], suf[maxn], sonv[maxn];
int son[maxn], cs;
void dp(int u, int fa) {
f[u] = val[u];
for(int e = head[u]; e; e = nxt[e]) dp(to[e], u), f[u] = max(f[u], f[to[e]]);
cs = 0;
for(int e = head[u]; e; e = nxt[e]) son[++cs] = to[e], sonv[cs] = f[to[e]];
LL nmx = -ool;
rep(i, 1, cs) {
pre[son[i]] = nmx;
nmx = max(nmx, sonv[i]);
}
nmx = -ool;
dwn(i, cs, 1) {
suf[son[i]] = nmx;
nmx = max(nmx, sonv[i]);
}
return ;
}
void dp2(int u, int fa, LL nmx) {
if(extra[u] > -ool && (f[u] > -ool || nmx > -ool)) ans = max(ans, extra[u] + max(f[u] - T1.Dep[u], nmx));
for(int e = head[u]; e; e = nxt[e]) {
LL now = max(max(pre[to[e]], suf[to[e]]), val[u]);
dp2(to[e], u, max(nmx, now > -ool ? now - T1.Dep[u] : -ool));
}
return ;
}
bool cmp(const int &a, const int &b) { return T1.dfn[a] < T1.dfn[b]; }
void build() {
sort(KeyPoint + 1, KeyPoint + K + 1, cmp);
rep(i, 1, K - 1) KeyPoint[++K] = T1.lca(KeyPoint[i], KeyPoint[i+1]);
KeyPoint[++K] = T1.lca(KeyPoint[K], KeyPoint[1]);
sort(KeyPoint + 1, KeyPoint + K + 1, cmp);
K = unique(KeyPoint + 1, KeyPoint + K + 1) - KeyPoint - 1;
rep(i, 1, K - 1) {
int a = KeyPoint[i], b = KeyPoint[i+1], c = T1.lca(a, b);
AddEdge(c, b);
}
dp(KeyPoint[1], 0); dp2(KeyPoint[1], 0, -ool);
return ;
}
}
using Vtree::KeyPoint;
using Vtree::K;
using Vtree::val;
using Vtree::extra;
pii rt;
int eid, size, best, siz[maxn];
bool vis[maxn];
void getrt(int u, int fa, int fae) {
siz[u] = 1;
for(int e = T.head[u]; e; e = T.nxt[e]) if(T.id[e] != fae && !vis[T.id[e]]) {
int v = T.to[e];
getrt(v, u, T.id[e]);
siz[u] += siz[v];
}
if(fa && best > max(siz[u], size - siz[u])) best = max(siz[u], size - siz[u]), rt = mp(u, fa), eid = fae;
return ;
}
void dfs(int u, int fae, bool tp) {
if(u <= T1.n) {
KeyPoint[++K] = u;
if(tp) val[u] = T.Dep[u];
else extra[u] = T.Dep[u] - T.Dep[T.lca(u,rt.x)];
}
for(int e = T.head[u]; e; e = T.nxt[e]) if(T.id[e] != fae && !vis[T.id[e]]) dfs(T.to[e], T.id[e], tp);
return ;
}
void solve(pii u, int ed) {
// printf("%d(%d) -- %d(%d)\n", u.x, siz[u.x], u.y, siz[u.y]);
vis[ed] = 1;
if(T.dep[u.x] > T.dep[u.y]) swap(u.x, u.y);
dfs(u.x, 0, 0); dfs(u.y, 0, 1);
Vtree::build();
Vtree::clear();
if(siz[u.x] > 1) {
rt = mp(0, 0); eid = 0; best = (size = siz[u.x]) + 1; getrt(u.x, 0, 0);
if(eid) solve(rt, eid);
}
if(siz[u.y] > 1) {
rt = mp(0, 0); eid = 0; best = (size = siz[u.y]) + 1; getrt(u.y, 0, 0);
if(eid) solve(rt, eid);
}
return ;
}
void main() {
rep(i, 1, T1.n) val[i] = extra[i] = -ool;
rt = mp(0, 0); eid = 0; best = (size = T.n) + 1; getrt(1, 0, 0);
solve(rt, eid);
rep(i, 1, T1.n) ans = max(ans, T.Dep[i] - T1.Dep[i]);
return ;
}
}
int main() {
Tmp.n = T.n = T1.n = read();
rep(i, 1, Tmp.n - 1) {
int a = read(), b = read(), c = read();
Tmp.AddEdge(a, b, c);
}
rep(i, 1, T1.n - 1) {
int a = read(), b = read(), c = read();
T1.AddEdge(a, b, c);
} // */
rebuildTree::build();
Solve::main();
printf("%lld\n", Solve::ans);
return 0;
}
扫一扫
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
