luogu6584 重拳出击

题目链接

solution

为了方便，我们以小(z)的初始位置为根。

大概理解完题意，可以发现有一个比较显然的性质：每一回合结束，每个(Youyou)与小(z)之间的距离不会变大。

然后考虑小(z)移动所产生的影响。

考虑当小(z)开始移动时，如果小(z)从(u)移动到了(u)的一个儿子(v)。那么这一回合结束，(v)子树中的每个Youyou与小z之间的距离就会减小2。其他的(Youyou)与小(z)之间的距离不变。

如果小(z)从(u)移动到了他的父亲(fa)，那么除了(u)这个子树内的(Youyou)外，其他的(Youyou)与小(z)之间的距离都会减小(2)。

然后我们考虑贪心，初始的时候每个(Youyou)与小(z)之间的距离就是(Youyou)所在节点的深度。我们每次让小(z)走向离他最远的那个(Youyou)。

这样显然是对的，因为如果小(z)不走向这个最远的(Youyou)，这个(Youyou)与小(z)之间的距离将永远是最大的。

那当有若干个与小(z)之间距离相同的(Youyou)时，应该如何决策呢？

走向任意一个即可。假设(y_1)和(y_2)与小(z)当前所在节点之间的距离都是x且是最大的，而且小(z)走向(y_1)和(y_2)不在小(z)的同一个方向上。如果我们先走向了(y_1)，那么y1与小z之间的距离减小(2)，下一回合的时候最大的点就是(y_2)了，所以下一回合就要走向(y_2)，也就是回到之前的点。这样就相当于进行了两次操作，小(z)位置没变，与(y_1)和(y_2)之间的距离都减小了(2).如果先走向(y_2)显然也是同样的情况。

所以这题思路也就理顺了。下面就是如何实现的问题了。

看一看思路中我们需要进行的操作，发现只有下面这几种：

• 将一个子树每个节点权值-2
• 求整颗子树中最大值所在的位置
• 求整棵树的权值最大值
• 求某个节点x在另外一个节点(y)的哪个方向上。也就是说,如果要从(y)走向(x)下一步应该走向哪个节点。

我们前三个操作就(dfs)序一下，然后用一个线段树维护区间加，区间最大值即可。

对于最后一个操作其实也很简单。我们分为两种情况。

下面假设我们要从(y)走向(x)。

如果(x)不在(y)的子树中，显然下一步走向(y)的父亲即可。

如果(x)在(y)的子树中，我们就用倍增的方法，从(x)开始向上跳，一直跳到深度比(y)大一即可。

这样我们就基本解决了这道题，剩下的就按照题目给的流程来操作即可。

注意一个坑点

如果当前与小(z)之间距离最大的几个点与小(z)之间的距离都是(k+1)，那么这一轮应当不动

code

/*
* @Author: wxyww
* @Date:   2020-05-30 16:25:49
* @Last Modified time: 2020-05-30 19:12:59
*/
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<ctime>
#include<cmath>
using namespace std;
typedef long long ll;
const int N = 400010,logN = 20;
ll read() {
	ll x = 0,f = 1;char c = getchar();
	while(c < '0' || c > '9') {
		if(c == '-') f = -1; c = getchar();
	}
	while(c >= '0' && c <= '9') {
		x = x * 10 + c - '0'; c = getchar();
	}
	return x * f;
}
int bz[N];
struct node {
	int v,nxt;
}e[N << 1];

int head[N],ejs;
void add(int u,int v) {
	e[++ejs].v = v;e[ejs].nxt = head[u];head[u] = ejs;
}

int n,K,siz[N],dep[N],id[N],dfn[N],tot;

int tree[N << 2];

int lca[N][logN + 2];
void dfs(int u,int fa) {
	dfn[u] = ++tot;
	dep[u] = dep[fa] + 1;
	id[tot] = u;
	siz[u] = 1;
	for(int i = 1;i <= logN;++i) {
		lca[u][i] = lca[lca[u][i - 1]][i - 1];
	}

	for(int i = head[u];i;i = e[i].nxt) {
		int v = e[i].v;
		if(v == fa) continue;
		lca[v][0] = u;
		dfs(v,u);
		siz[u] += siz[v];
	}
}
int lazy[N << 2];

void pushdown(int rt) {
	if(lazy[rt] != 0) {
		tree[rt << 1] += lazy[rt];
		tree[rt << 1 | 1] += lazy[rt];
		lazy[rt << 1] += lazy[rt];
		lazy[rt << 1 | 1] += lazy[rt];
		lazy[rt] = 0;
	}
}

void build(int rt,int l,int r) {
	if(l == r) {
		if(bz[id[l]]) tree[rt] = dep[id[l]];
		return;
	}
	int mid = (l + r) >> 1;
	build(rt << 1,l,mid);build(rt << 1 | 1,mid + 1,r);
	tree[rt] = max(tree[rt << 1],tree[rt << 1 | 1]);
}

void update(int rt,int l,int r,int L,int R,int c) {
	if(L <= l && R >= r) {
		tree[rt] += c;lazy[rt] += c;
		return;
	}

	pushdown(rt);
	int mid = (l + r) >> 1;
	if(L <= mid) update(rt << 1,l,mid,L,R,c);
	if(R > mid) update(rt << 1 | 1,mid + 1,r,L,R,c);
	tree[rt] = max(tree[rt << 1],tree[rt << 1 | 1]);
}

int query(int rt,int l,int r) {
	if(l == r) return id[l];
	pushdown(rt);
	int mid = (l + r) >> 1;
	if(tree[rt << 1] >= tree[rt << 1 | 1]) return query(rt << 1,l,mid);
	else return query(rt << 1 | 1,mid + 1,r);
}

int get(int x,int depth) {
	for(int i = logN;i >= 0;--i) {
		if(dep[lca[x][i]] >= depth) x = lca[x][i];
	}
	return x;
}

int main() {
	n = read();
	for(int i = 1;i < n;++i) {
		int u = read(),v = read();
		add(u,v);add(v,u);
	}
	memset(tree,-0x3f,sizeof(tree));
	int m = read();
	if(!m) {puts("0");return 0;}
	for(int i = 1;i <= m;++i) {
		int x = read();
		bz[x] = 1;
	}

	K = read();int root = read();
	dep[0] = -1;
	dfs(root,0); build(1,1,n);
	int ans = 0;

	while(1) {
		++ans;
		if(tree[1] <= K) {
			cout<<ans;return 0;
		}
		if(tree[1] - K == 1) {
			update(1,1,n,1,n,-1);
			continue;
		}
		int p = query(1,1,n);

		if(dfn[p] >= dfn[root] && dfn[p] < dfn[root] + siz[root]) {
			p = get(p,dep[root] + 1);
			update(1,1,n,dfn[p],dfn[p] + siz[p] - 1,-2);
			root = p;
		}
		else {
			update(1,1,n,dfn[root],dfn[root] + siz[root] - 1,2);
			update(1,1,n,1,n,-2);
			root = lca[root][0];
		}
	}
	return 0;
}