@codechef - SONATR@ Sonya and Tree

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

给定 p 为 0~N-1 的一个排列，并给定一棵 N 个点的树。

我们称一个包含 L 个结点的路径是“漂亮”的，当且仅当对于 0 ≤ i ≤ L-1，路径都存在 v 使得 p[v] = i，一棵树的“漂亮程度”被定义为其包含的“漂亮”路径数量。

现给定 M 次操作，每次交换 p[u] 与 p[v]，询问每次操作完后当前树的“漂亮程度”。

输入格式

输入的第一行包含一个整数 N，第二行包含 N 个整数 p1,p2,...,pN。

接下来 N −1 行，每行包含两个整数 u 和 v，代表节点 u 和 v 之间有一条边。 接下来一行包含一个整数 M。 接下来 M 行，每行包含两个整数 u 和 v，代表一次操作。

输出格式

对于每组数据，输出一行，包含一个整数，代表操作后树的漂亮程度。

数据范围与子任务

• 1 ≤ N,M ≤ 5·10^5

• 0 ≤ pi ≤ N −1

• 1 ≤ u,v ≤ N

样例数据

输入

5

2 0 1 3 4

2 4

1 2

5 2

1 3

4

2 1

5 5

3 4

3 2

输出

4

4

3

2

@solution@

本道题和 IOI2018 那道题的排座位其实很像。。。

就是找一些特征值可以代表树上的一条链，然后维护一下。。。

直接避免这些抽象的东西，我们切入正题。

先考虑给定 L，怎么判断长度为 L 的“漂亮”路径是否存在。

一个链在有根树上有两种形态，一种由祖先连向子孙，一种形如 '^'。

对于祖先连向子孙这类形态，可以发现它有两个“特殊结点”：最上面那个，没有连向父亲的边；最下面那个，没有连向儿子的边。

稍微思考一下就可以发现，我们如果限制没有连向儿子的边的特殊点个数为 1，则可能的形态只有一种。

考虑维护特殊点个数。如果一个点有连向儿子的边，肯定会先选择到连 p 最小的儿子。

于是：我们维护一个计数器 cnt = L；依次扫描 p[i]=0...L-1 的点，如果它的最小儿子 < L 则 cnt--。最终剩下 cnt = 1 则说明是我们想要的形态。

对于 '^' 型的链，依然还是先限制没有连向儿子的边的特殊点个数为 2。此时可能会出现三种形态：不相交的两条链、一条链、一条链然后 lca 往上延伸出了一个枝末。

我们依次排除掉另两种情况。考虑找到一个 L' 使得存在一个点 x 使得它、它的最小儿子、它的次小儿子 < L'。假如我保证 L >= L'，则就可以排除掉第一个情况。

考虑找到这个 x，得到它父亲的 p 值为 k。假如我保证 L < k 既可以排除掉第三个情况。

考虑怎么维护。首先开个 set 维护一个点 x 的儿子（其实更合理地应该是使用可删除任意结点的堆，但是我不会写。。。），方便我们得到一个点的最小儿子 k1，次小儿子 k2。

维护一棵线段树表示我们的计数器，一开始线段树中位置 i 的值为 i，每个点 x 在 max(k1, p[x]) ~ N 中减一。

看起来我们需要维护一个值的出现次数，但是注意到 cnt = 1/2 都是对应情况 cnt 的最小可能取值，于是维护一下最小值与最小值的出现次数即可。

最后全局开一个 set 维护 max(k2, p[x]) 以及对应的 x，便于我们处理第二种情况。

交换的时候按照定义相应地改一改即可。时间复杂度 O(nlogn)。

@accepted code@

#include<set>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef pair<int, int> pii;
const int MAXN = 500000;
const int INF = (1<<30);
struct edge{
	edge *nxt; int to;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt=&edges[0];
void addedge(int u, int v) {
	edge *p = (++ecnt);
	p->to = v, p->nxt = adj[u], adj[u] = p;
	p = (++ecnt);
	p->to = u, p->nxt = adj[v], adj[v] = p;
}
struct segtree{
	struct node{
		int l, r, tg;
		pii mn;
	}t[4*MAXN + 5];
	pii merge(pii a, pii b) {
		pii ret = make_pair(min(a.first, b.first), 0);
		if( a.first == ret.first ) ret.second += a.second;
		if( b.first == ret.first ) ret.second += b.second;
		return ret;
	}
	void pushup(int x) {
		t[x].mn = merge(t[x << 1].mn, t[x << 1 | 1].mn);
	}
	void pushdown(int x) {
		if( t[x].tg ) {
			t[x << 1].tg += t[x].tg, t[x << 1 | 1].tg += t[x].tg;
			t[x << 1].mn.first += t[x].tg, t[x << 1| 1].mn.first += t[x].tg;
			t[x].tg = 0;
		}
	}
	void build(int x, int l, int r) {
		t[x].l = l, t[x].r = r, t[x].tg = 0;
		if( l == r ) {
			t[x].mn = make_pair(l, 1);
			return ;
		}
		int mid = (l + r) >> 1;
		build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
		pushup(x);
	}
	void modify(int x, int l, int r, int d) {
		if( l > t[x].r || r < t[x].l )
			return ;
		if( l <= t[x].l && t[x].r <= r ) {
			t[x].tg += d, t[x].mn.first += d;
			return ;
		}
		pushdown(x);
		modify(x << 1, l, r, d);
		modify(x << 1 | 1, l, r, d);
		pushup(x);
	}
	pii query(int x, int l, int r) {
		if( l > t[x].r || r < t[x].l )
			return make_pair(INF, 0);
		if( l <= t[x].l && t[x].r <= r )
			return t[x].mn;
		pushdown(x);
		return merge(query(x << 1, l, r), query(x << 1 | 1, l, r));
	}
}T;
set<int>st[MAXN + 5];
set<pii>st2;
int p[MAXN + 5], fa[MAXN + 5], N, M;
void dfs(int x, int f) {
	fa[x] = f;
	for(edge *q=adj[x];q;q=q->nxt) {
		if( q->to == f ) continue;
		dfs(q->to, x);
		st[x].insert(p[q->to]);
	}
}
int f[MAXN + 5], g[MAXN + 5];
void update(int x) {
	set<int>::iterator it = st[x].begin();
	if( it != st[x].end() ) {
		if( f[x] == 0 ) f[x] = max(p[x], *it), T.modify(1, f[x], N, -1);
		else {
			if( f[x] != max(p[x], *it) ) {
				if( f[x] < max(p[x], *it) )
					T.modify(1, f[x], max(p[x], *it)-1, 1);
				else T.modify(1, max(p[x], *it), f[x]-1, -1);
				f[x] = max(p[x], *it);
			}
		}
		it++;
		if( it != st[x].end() ) {
			if( g[x] == 0 ) g[x] = max(p[x], *it), st2.insert(make_pair(g[x], x));
			else {
				if( g[x] != max(p[x], *it) ) {
					st2.erase(make_pair(g[x], x));
					g[x] = max(p[x], *it);
					st2.insert(make_pair(g[x], x));
				}
			}
		}
	}
}
void update(int &x, pii p, int k) {
	if( p.first == k ) x += p.second;
}
int get_ans() {
	int ret = 0; update(ret, T.query(1, 1, N), 1);
	set<pii>::iterator it = st2.begin();
	if( it != st2.end() ) {
		if( fa[it->second] ) update(ret, T.query(1, it->first, p[fa[it->second]]-1), 2);
		else update(ret, T.query(1, it->first, N), 2);
	}
	return ret;
}
int main() {
	scanf("%d", &N);
	for(int i=1;i<=N;i++)
		scanf("%d", &p[i]), p[i]++;
	for(int i=1;i<N;i++) {
		int u, v; scanf("%d%d", &u, &v);
		addedge(u, v);
	}
	dfs(1, 0); T.build(1, 1, N);
	for(int i=1;i<=N;i++)
		update(i);
	scanf("%d", &M);
	for(int i=1;i<=M;i++) {
		int u, v; scanf("%d%d", &u, &v);
		if( fa[u] ) st[fa[u]].erase(p[u]);
		if( fa[v] ) st[fa[v]].erase(p[v]);
		swap(p[u], p[v]);
		if( fa[u] ) st[fa[u]].insert(p[u]);
		if( fa[v] ) st[fa[v]].insert(p[v]);
		update(u), update(v);
		if( fa[u] ) update(fa[u]);
		if( fa[v] ) update(fa[v]);
		printf("%d\n", get_ans());
	}
}

@details@

事实上。。。写得不好 set 用得太多的话。。。是会被卡常的。。。