2021牛客暑期多校训练营7 F-xay loves trees
没有传送门。
题面大意：给你两棵树，根都是1号节点。让你找一个最大的节点集合，满足：
1.在第一棵树上，集合中的节点是相连的，且任意连个节点之间是祖孙关系。
2.在第二棵树上，任意两个节点直接都不是祖孙关系。
这题当时想出来了，结果有一个数组忘清空，先WA后RE，到最后也没查出来。
首先根据第一个条件，这些点一定某一个节点到根的链的一段。那么一种思路是处理出每一个节点\(u\)往上最高能往上走几步（即\(ans[u]\)），最后取最大值。而且对于一条边\((u,v)\)（\(u\)是\(v\)的父亲），必有\(ans[v] \leqslant ans[u] + 1\).
那对于一个节点，如何求出\(ans[u]\)呢？我现在会两种做法：
第一种做法：
答案显然具有单调性，因此我们对于每一个节点，二分其能向上走的步数。那么对于一个二分值\(mid\)，应该如何检验？即怎么判断这些点互相不是祖孙关系。其实就是将第二棵树的dfs序求出来，那么每一个点的dfs序区间就是\([dfn[u], dfn[u] + siz[u] - 1]\)，只要判断这些区间不相交即可。
如果是到根的路径，可以用线段树实现区间修改和查询区间和是否为\(0\)；现在改成了一段，那么就能想到用主席树。虽然主席树不支持区间修改，但是可以这么解决：建立两棵主席树，一棵叫“祖先树”，一棵叫“儿子树”。
祖先树专门用来判断\(u\)是否为某些点的祖先，那么只要查询\([dfn[u], dfn[u] +siz[u] - 1]\)这段区间和是否为\(0\)。而修改恰好是单点修改，将\(dfn[u]\)标记成\(1\)即可。
儿子树专门用来判断\(u\)是否为某些点的儿子，如果单点查询\(dfn[u]\)的值是否为\(0\)，那修改就要区间修改。因此我们修改的时候用差分，查询的时候查询前缀和就行了！
这样两棵主席树都是区间（前缀）查询和单点修改，主席树就能胜任了。时间复杂度\(O(nlog^2n)\)，能过。（比赛的时候是倍增的数组忘清空了……）
第二种做法：
上面提到主席树无法区间修改，是因为标记无法下传（会下传到被继承的原来的节点）。但是如果用“标记永久化”就可以实现了。
标记永久化好久没写，完全忘掉了。其思路就是将改变的值的贡献直接算到区间里，在递归边界时打标记。但是标记不下传，而是在查询的时候，算上标记的贡献。
对于这道题，我们可以用标记永久化维护覆盖某一个区间的最深的点的深度，那么这个深度之下必然没有点可以覆盖这一dfs序的区间。因此我们建立一棵树，查询的时候就查询该dfs序区间被覆盖的最大深度，修改的时候就进行区间修改，更新最大值。
而且该算法不用二分，因为我们需要的就是前缀查询，标记永久化刚好可以胜任。这样时间复杂度就是\(O(nlogn)\)了。
一下给出两份代码：
第一种做法：
#include<bits/stdc++.h>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
const int maxn = 3e5 + 500;
const int maxt = 1.2e7 + 5;
const int N = 18;
ll read() {ll x; scanf("%lld", &x); return x;}
void write(ll x) {printf("%lld", x);}
int n;
struct Edge
{
int nxt, to;
}e[maxn << 1];
int head[maxn], ecnt = -1;
In void addEdge(int x, int y)
{
e[++ecnt] = (Edge){head[x], y};
head[x] = ecnt;
}
Edge e2[maxn << 1];
int head2[maxn], ecnt2 = -1;
In void addEdge2(int x, int y)
{
e2[++ecnt2] = (Edge){head2[x], y};
head2[x] = ecnt2;
}
int dfsx[maxn], siz[maxn], cnt = 0;
In void dfs2(int now, int _f)
{
siz[now] = 1;
dfsx[now] = ++cnt;
for(int i = head2[now], v; ~i && (v = e2[i].to); i = e2[i].nxt)
{
if(v == _f) continue;
dfs2(v, now);
siz[now] += siz[v];
}
}
const int P = maxn - 20;
struct Tree
{
int ls = 0, rs = 0, sum = 0;
In void init() {ls = rs = sum = 0;}
};
struct trees
{
Tree t[maxt];
int root[maxn << 1], cnt;
In void init() {Mem(root, 0), cnt = 0;}
In void insert(int old, int& now, int l, int r, int x, int d)
{
t[now = ++cnt] = t[old];
if(x < l || x > r) return;
t[now].sum += d;
if(l == r) return;
int mid = (l + r) >> 1;
if(x <= mid) insert(t[old].ls, t[now].ls, l, mid, x, d);
else insert(t[old].rs, t[now].rs, mid + 1, r, x, d);
}
In int query(int old, int now, int l, int r, int L, int R)
{
if(!old && !now) return 0;
if(l == L && r == R) return t[now].sum - t[old].sum;
int mid = (l + r) >> 1;
if(R <= mid) return query(t[old].ls, t[now].ls, l, mid, L, R);
else if(L > mid) return query(t[old].rs, t[now].rs, mid + 1, r, L, R);
else return query(t[old].ls, t[now].ls, l, mid, L, mid) + query(t[old].rs, t[now].rs, mid + 1, r, mid + 1, R);
}
}tA, tS;
int ha[maxn], dep[maxn], fa[N + 2][maxn];
In int calc(int x, int len)
{
int sta = x;
for(int i = ha[len]; i >= 0; --i)
{
int y = fa[i][x], z = fa[0][y];
if(!y) continue;
int tp1 = tA.query(tA.root[z], tA.root[fa[0][sta]], 1, n, dfsx[sta], dfsx[sta] + siz[sta] - 1);
int tp2 = tS.query(tS.root[z], tS.root[fa[0][sta]], 1, n, 1, dfsx[sta]);
if(!tp1 && !tp2) x = y;
}
return dep[sta] - dep[x];
}
int ans[maxn];
In void dfs1(int now, int _f)
{
for(int i = 1; (1 << i) <= dep[now]; ++i)
fa[i][now] = fa[i - 1][fa[i - 1][now]];
ans[now] = min(ans[_f] + 1, calc(now, ans[_f] + 1));
tA.insert(tA.root[_f], tA.root[now], 1, n, dfsx[now], 1);
tS.insert(tS.root[_f], tS.root[P], 1, n, dfsx[now], 1);
tS.insert(tS.root[P], tS.root[now], 1, n, dfsx[now] + siz[now], -1);
forE(i, now, v)
{
if(v == _f) continue;
dep[v] = dep[now] + 1;
fa[0][v] = now;
dfs1(v, now);
}
}
In void init()
{
Mem(fa, 0);
Mem(head, -1), ecnt = -1;
Mem(head2, -1), ecnt2 = -1;
cnt = 0;
tA.init(), tS.init();
}
int main()
{
int T = read();
while(T--)
{
init();
n = read();
for(int i = 1; i < n; ++i)
{
int x = read(), y = read();
addEdge(x, y), addEdge(y, x);
}
for(int i = 1; i < n; ++i)
{
int x = read(), y = read();
addEdge2(x, y), addEdge2(y, x);
}
dfs2(1, 0);
for(int i = 2; i <= n; ++i) ha[i] = ha[i >> 1] + 1;
dep[1] = 1, dfs1(1, 0);
int Max = 0;
for(int i = 1; i <= n; ++i) Max = max(Max, ans[i]);
write(Max + 1), enter;
}
return 0;
}
比较长，还慢，还是看第二种做法吧。
#include<bits/stdc++.h>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 3e5 + 5;
const int maxt = 6e6 + 5;
In ll read()
{
ll ans = 0;
char ch = getchar(), las = ' ';
while(!isdigit(ch)) las = ch, ch = getchar();
while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
if(las == '-') ans = -ans;
return ans;
}
In void write(ll x)
{
if(x < 0) x = -x, putchar('-');
if(x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int n;
#define pb push_back
vector<int> v1[maxn], v2[maxn];
int dfsx[maxn], siz[maxn], cnt = 0;
In void dfs2(int now, int _f)
{
siz[now] = 1, dfsx[now] = ++cnt;
for(auto v : v2[now])
{
if(v == _f) continue;
dfs2(v, now);
siz[now] += siz[v];
}
}
struct Tree
{
int ls, rs, lzy, Max;
}t[maxt];
int root[maxn], tcnt = 0;
In void insert(int old, int& now, int l, int r, int L, int R, int d)
{
t[now = ++tcnt] = t[old];
t[now].Max = max(t[now].Max, d);
if(l == L && r == R) return (void)(t[now].lzy = max(t[now].lzy, d));
int mid = (l + r) >> 1;
if(R <= mid) insert(t[old].ls, t[now].ls, l, mid, L, R, d);
else if(L > mid) insert(t[old].rs, t[now].rs, mid + 1, r, L, R, d);
else insert(t[old].ls, t[now].ls, l, mid, L, mid, d), insert(t[old].rs, t[now].rs, mid + 1, r, mid + 1, R, d);
}
In int query(int now, int l, int r, int L, int R)
{
if(l == L && r == R) return t[now].Max;
int ret, mid = (l + r) >> 1;
if(R <= mid) ret = query(t[now].ls, l, mid, L, R);
else if(L > mid) ret = query(t[now].rs, mid + 1, r, L, R);
else ret = max(query(t[now].ls, l, mid, L, mid), query(t[now].rs, mid + 1, r, mid + 1, R));
return max(ret, t[now].lzy);
}
int dep[maxn], f[maxn];
In void dfs1(int now, int _f)
{
f[now] = min(f[_f] + 1, dep[now] - query(root[_f], 1, n, dfsx[now], dfsx[now] + siz[now] - 1));
insert(root[_f], root[now], 1, n, dfsx[now], dfsx[now] + siz[now] - 1, dep[now]);
for(auto v : v1[now])
{
if(v == _f) continue;
dep[v] = dep[now] + 1;
dfs1(v, now);
}
}
In void init()
{
for(int i = 1; i <= n; ++i) v1[i].clear(), v2[i].clear();
Mem(root, 0), cnt = tcnt = 0;
}
int main()
{
int T = read();
while(T--)
{
n = read();
init();
for(int i = 1, x, y; i < n; ++i) x = read(), y = read(), v1[x].pb(y), v1[y].pb(x);
for(int i = 1, x, y; i < n; ++i) x = read(), y = read(), v2[x].pb(y), v2[y].pb(x);
dfs2(1, 0);
dep[1] = 1, dfs1(1, 0);
int Max = 0;
for(int i = 1; i <= n; ++i) Max = max(Max, f[i]);
write(Max), enter;
}
return 0;
}
