CodeForces 1702G2 Passable Paths (hard version)

洛谷传送门

CF 传送门

思路

显然如果确定了路径的两个端点 \(x,y\)，就可以树剖将树上 \(x\) 到 \(y\) 的路径上的点权值 \(+1\)，再判断询问点是否在路径上。

于是钦定深度最大的点为其中一个端点 \(x\)，另一个端点 \(y\) 为询问点中不为 \(x\) 的祖先且深度最大的点。如果 \(y\) 不存在说明路径为一条从祖先直接到儿子的链，否则按上面的方法判断即可。

注意特判 \(m = 1\) 的情况。

代码

code

/*

p_b_p_b txdy
AThousandMoon txdy
AThousandSuns txdy
hxy txdy

*/

#include <bits/stdc++.h>
#define pb push_back
#define fst first
#define scd second

using namespace std;
typedef long long ll;
typedef pair<ll, ll> pii;

const int maxn = 200100;

int n, q, head[maxn], len, a[maxn], dfn[maxn], times;
int fa[maxn], sz[maxn], son[maxn], dp[maxn];
int top[maxn], cnt[maxn];
vector<int> G[maxn];

struct edge {
	int to, next;
} edges[maxn << 1];

void add_edge(int u, int v) {
	edges[++len].to = v;
	edges[len].next = head[u];
	head[u] = len;
}

int dfs(int u, int f, int d) {
	fa[u] = f;
	dp[u] = d;
	sz[u] = 1;
	int maxson = -1;
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (v == f) {
			continue;
		}
		sz[u] += dfs(v, u, d + 1);
		if (sz[v] > maxson) {
			son[u] = v;
			maxson = sz[v];
		}
	}
	return sz[u];
}

void dfs2(int u, int tp) {
	top[u] = tp;
	dfn[u] = ++times;
	if (!son[u]) {
		return;
	}
	dfs2(son[u], tp);
	for (int i = head[u]; i; i = edges[i].next) {
		int v = edges[i].to;
		if (!dfn[v]) {
			dfs2(v, v);
		}
	}
}

int querylca(int x, int y) {
	while (top[x] != top[y]) {
		if (dp[top[x]] < dp[top[y]]) {
			swap(x, y);
		}
		x = fa[top[x]];
	}
	if (dp[x] > dp[y]) {
		swap(x, y);
	}
	return x;
}

const int logn = 20;

int ff[maxn][logn], c[maxn];

bool cmp(int a, int b) {
	return dp[a] > dp[b];
}

int jump(int x, int y) {
	for (int j = 0; j <= 19; ++j) {
		if (y & (1 << j)) {
			x = ff[x][j];
		}
	}
	return x;
}

void update(int x, int d) {
	for (int i = x; i <= n; i += (i & (-i))) {
		c[i] += d;
	}
}

int query(int x) {
	int res = 0;
	for (int i = x; i; i -= (i & (-i))) {
		res += c[i];
	}
	return res;
}

void update(int x, int y, int v) {
	update(x, v);
	update(y + 1, -v);
}

void treeupdate(int x, int y, int v) {
	while (top[x] != top[y]) {
		if (dp[top[x]] < dp[top[y]]) {
			swap(x, y);
		}
		update(dfn[top[x]], dfn[x], v);
		x = fa[top[x]];
	}
	if (dp[x] > dp[y]) {
		swap(x, y);
	}
	update(dfn[x], dfn[y], v);
}

void solve() {
	scanf("%d", &n);
	for (int i = 1, u, v; i < n; ++i) {
		scanf("%d%d", &u, &v);
		add_edge(u, v);
		add_edge(v, u);
	}
	dfs(1, 0, 1);
	dfs2(1, 1);
	for (int i = 1; i <= n; ++i) {
		ff[i][0] = fa[i];
	}
	for (int j = 1; (1 << j) <= n; ++j) {
		for (int i = 1; i <= n; ++i) {
			ff[i][j] = ff[ff[i][j - 1]][j - 1];
		}
	}
	scanf("%d", &q);
	while (q--) {
		int m;
		scanf("%d", &m);
		for (int i = 1; i <= m; ++i) {
			scanf("%d", &a[i]);
		}
		if (m == 1) {
			puts("YES");
			continue;
		}
		sort(a + 1, a + m + 1, cmp);
		map<int, int> mp;
		bool f1 = 0;
		for (int i = 1; i <= m; ++i) {
			if ((++mp[dp[a[i]]]) > 2) {
				puts("NO");
				f1 = 1;
				break;
			}
		}
		if (f1) {
			continue;
		}
		int x = -1, y = -1;
		if (dp[a[1]] == dp[a[2]]) {
			x = a[1];
			y = a[2];
		} else {
			x = a[1];
			for (int i = 2; i <= m; ++i) {
				int dif = dp[a[1]] - dp[a[i]];
				if (jump(a[1], dif) != a[i]) {
					y = a[i];
					break;
				}
			}
			if (y == -1) {
				puts("YES");
				continue;
			}
		}
		bool flag = 1;
		treeupdate(x, y, 1);
		for (int i = 1; i <= m; ++i) {
			if (query(dfn[a[i]]) == 0) {
				flag = 0;
				break;
			}
		}
		treeupdate(x, y, -1);
		puts(flag ? "YES" : "NO");
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}