2022东北四省赛 F. Tree Path (树剖 + 线段树维护堆)

给定一棵有 n n n个节点的树, 其中有 k k k条有权路径(保证不同路径边权互不相同), 有 m m m次如下操作:

0: 删除树中权值最小的路径

1 x: 询问树中删除x节点后, 剩余连通边权中的最小值.

本题的查询操作, 属于上题的强制在线版本, 因此我们可以用上题中类似的方式实现.

推荐大家先去做上面这道题, 题解思路都详细一些. 做完后再回来看这道题, 你会发现处理手段几乎是一模一样的.

首先我们考虑查询操作, 我们需要每次对删除节点x后的连通路径上的最小边权.

同上题处理方法, 我们每次修改路径 ( a , b ) (a, b) (a,b)的权值时, 变为修改其补集. 这样每个节点所维护的权值就是不包含该点时, 剩余连通边权中的最小值.

这样, 我们就解决了查询操作.

关于本题的修改操作, 由于每次都是删除权值最小的边, 因此我们没有必要再用双堆的方式去维护了, 我们可以开一个全局变量, 记录被删除掉的数值即可.

特别的, 线段树内推荐维护优先队列, 如果维护set, 会增加时间/空间常数复杂度.

#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E5 + 10, INF = 0x3f3f3f3f;
int n, k, m;

vector v(1, -0x3f3f3f3f); // int len;
int find(int x) { return lower_bound(v.begin(), v.end(), x) - v.begin(); }
void discrete() { sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end()); }
bool del[N];



int w[N];
vector edge[N];
struct EDGE { int a, b, c; }EG[N];

int p[N], dep[N], sz[N], son[N];
void dfs1(int x = 1, int fa = 0) {
	p[x] = fa, dep[x] = dep[fa] + 1, sz[x] = 1; // son[x] = 0;
	for (auto& to : edge[x]) {
		if (to == fa) continue;
		dfs1(to, x);
		sz[x] += sz[to];
		if (sz[to] > sz[son[x]]) son[x] = to;
	}
}
int id[N], nw[N], top[N], ind;
void dfs2(int x = 1, int tp = 1) {
	id[x] = ++ind, nw[ind] = w[x], top[x] = tp;

	if (!son[x]) return;
	dfs2(son[x], tp);

	for (auto& to : edge[x]) {
		if (to == p[x] or to == son[x]) continue;
		dfs2(to, to);
	}
}




struct SEG {
	struct node {
		int l, r;
		priority_queue, greater<>> val;
		int top() {
			while (!val.empty() and del[val.top()]) val.pop();
			return val.empty() ? INF : val.top();
		}

	}t[N << 2];
	void build(int l, int r, int x = 1) {
		t[x] = { l, r };
		if (l == r) return;
		int mid = l + r >> 1;
		build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
	}
	void modify(int l, int r, int c, int x = 1) {
		if (l <= t[x].l and r >= t[x].r) {
			t[x].val.push(c);
			return;
		}
		int mid = t[x].l + t[x].r >> 1;
		if (l <= mid) modify(l, r, c, x << 1);
		if (r > mid) modify(l, r, c, x << 1 | 1);
	}
	int ask(int a, int x = 1) {
		if (t[x].l == t[x].r) return t[x].top();
		int mid = t[x].l + t[x].r >> 1;
		return min(t[x].top(), ask(a, x << 1 | (a > mid)));
	}
}seg;


void modify_route(int a, int b, int c) {
	vector> area;
	while (top[a] != top[b]) {
		if (dep[top[a]] < dep[top[b]]) swap(a, b);
		area.push_back({ id[top[a]], id[a] });
		a = p[top[a]];
	}
	if (id[a] > id[b]) swap(a, b);
	area.push_back({ id[a], id[b] });

	sort(area.begin(), area.end());

	int L = 1;
	// [L, l - 1], L = r + 1
	for (auto& [l, r] : area) {
		if (L <= l - 1) seg.modify(L, l - 1, c);
		L = r + 1;
	}
	if (L <= n) seg.modify(L, n, c);
}
int main()
{
	cin >> n >> k >> m;
	rep(i, n - 1) {
		int a, b; scanf("%d %d", &a, &b);
		edge[a].push_back(b), edge[b].push_back(a);
	}
	dfs1(), dfs2();
	seg.build(1, n);

	rep(i, k) {
		int a, b, c; scanf("%d %d %d", &a, &b, &c);
		EG[i] = { a, b, c };
		v.push_back(c);
	}
    
	discrete();
	rep(i, k) {
		auto& [a, b, c] = EG[i];
		c = find(c);
		modify_route(a, b, c);
	}

	int last = 0, delindex = 0;
	rep(i, m) {
		int tp; scanf("%d", &tp);
		if (!tp) del[++delindex] = 1;
		else {
			int x; scanf("%d", &x); x ^= last;

			int res = seg.ask(id[x]);
			last = res == INF ? -1 : v[res];
			printf("%dn", last);
		}
	}

	return 0;
}