【BZOJ4538】【HNOI2016】网络

最新推荐文章于 2019-04-02 19:21:00 发布

cz_xuyixuan

最新推荐文章于 2019-04-02 19:21:00 发布

阅读量321

点赞数

CC 4.0 BY-SA版权

分类专栏：【OJ】BZOJ 【类型】做题记录【数据结构】线段树【数据结构】KD-Tree 【算法】树的DFS序

本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/79644537

【类型】做题记录同时被 3 个专栏收录

767 篇文章

订阅专栏

【OJ】BZOJ

397 篇文章

订阅专栏

【数据结构】线段树

122 篇文章

订阅专栏

本文介绍了一种结合DFS序标号、线段树和KDTree的数据结构解决方案，用于处理路径上节点影响的问题。通过对树进行DFS序标号，并利用线段树+堆维护特定条件下的节点信息，同时借助KDTree来处理另一类条件，实现了时间复杂度为O(M*√N)、空间复杂度为O(N+M)的高效算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【题目链接】

点击打开链接

【思路要点】

对树进行DFS序标号，令节点\(i\)的DFS序为\(dfn_i\)，\(i\)子树内的节点DFS序范围为\([dfn_i,rit_i]\)。
对于路径\((a,b)\)，节点\(x\)不影响\((a,b)\)的条件是满足以下之一：
1、\(dfn_{lca(a,b)}\in(dfn_x,rit_x]\)。
2、\(dfn_a\notin[dfn_x,rit_x]\)且\(dfn_b\notin[dfn_x,rit_x]\)。
1可以用线段树+堆维护，2可以用KDTree维护。
时间复杂度\(O(M*\sqrt{N})\)，空间复杂度\(O(N+M)\)。
由于常数较大，BZOJ上这份代码会TLE，但该代码在DBZOJ上已经测试通过。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXLOG = 20;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct Heap {
	priority_queue <int> Heap, Del;
	void push(int x) {Heap.push(x); }
	void pop(int x) {Del.push(x); }
	int query() {
		while (!Heap.empty() && !Del.empty() && Heap.top() == Del.top()) {
			Heap.pop();
			Del.pop();
		}
		if (Heap.empty()) return -1;
		else return Heap.top();
	}
};
struct SegmentTree {
	struct Node {
		int lc, rc;
		int Max;
	} a[MAXN * 2];
	Heap b[MAXN];
	int root, size, n;
	void update(int root) {
		a[root].Max = max(a[a[root].lc].Max, a[a[root].rc].Max);
	}
	void build(int &root, int l, int r) {
		root = ++size;
		a[root].Max = -1;
		if (l == r) return;
		int mid = (l + r) / 2;
		build(a[root].lc, l, mid);
		build(a[root].rc, mid + 1, r);
	}
	void init(int x) {
		n = x;
		root = size = 0;
		build(root, 1, n);
	}
	void update(int root, int l, int r, int pos) {
		if (l == r) {
			a[root].Max = b[l].query();
			return;
		}
		int mid = (l + r) / 2;
		if (mid >= pos) update(a[root].lc, l, mid, pos);
		else update(a[root].rc, mid + 1, r, pos);
		update(root);
	}
	void push(int x, int val) {
		b[x].push(val);
		update(root, 1, n, x);
	}
	void pop(int x, int val) {
		b[x].pop(val);
		update(root, 1, n, x);
	}
	int query(int root, int l, int r, int ql, int qr) {
		if (l == ql && r == qr) return a[root].Max;
		int mid = (l + r) / 2, ans = -1;
		if (mid >= ql) chkmax(ans, query(a[root].lc, l, mid, ql, min(mid, qr)));
		if (mid + 1 <= qr) chkmax(ans, query(a[root].rc, mid + 1, r, max(mid + 1, ql), qr));
		return ans;
	}
	int query(int l, int r) {
		if (l > r) return -1;
		else return query(root, 1, n, l, r);
	}
} ST;
int n, m, timer;
int dfn[MAXN], rit[MAXN];
int depth[MAXN], father[MAXN][MAXLOG];
vector <int> a[MAXN];
void work(int pos, int fa) {
	dfn[pos] = ++timer;
	father[pos][0] = fa;
	depth[pos] = depth[fa] + 1;
	for (int i = 1; i < MAXLOG; i++)
		father[pos][i] = father[father[pos][i - 1]][i - 1];
	for (unsigned i = 0; i < a[pos].size(); i++)
		if (a[pos][i] != fa) work(a[pos][i], pos);
	rit[pos] = timer;
}
int lca(int x, int y) {
	if (depth[x] < depth[y]) swap(x, y);
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (depth[father[x][i]] >= depth[y]) x = father[x][i];
	if (x == y) return x;
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (father[x][i] != father[y][i]) {
			x = father[x][i];
			y = father[y][i];
		}
	return father[x][0];
}
struct point {int x, y; }; bool mode;
bool operator < (point a, point b) {
	if (mode) {	
		if (a.x == b.x) return a.y < b.y;
		else return a.x < b.x;
	} else {
		if (a.y == b.y) return a.x < b.x;
		else return a.y < b.y;
	}
}
struct info {point pos; int home; };
bool operator < (info a, info b) {return a.pos < b.pos; }
struct KDTree {
	struct Node {
		int lc, rc, fa;
		int index, Max;
		point pos, l, r;
	} a[MAXN];
	int root, tot, size, pos[MAXN];
	info tmp[MAXN];
	void updaterange(int root) {
		a[root].l = a[root].r = a[root].pos;
		int lc = a[root].lc, rc = a[root].rc;
		if (lc) {
			chkmin(a[root].l.x, a[lc].l.x);
			chkmin(a[root].l.y, a[lc].l.y);
			chkmax(a[root].r.x, a[lc].r.x);
			chkmax(a[root].r.y, a[lc].r.y);
		}
		if (rc) {
			chkmin(a[root].l.x, a[rc].l.x);
			chkmin(a[root].l.y, a[rc].l.y);
			chkmax(a[root].r.x, a[rc].r.x);
			chkmax(a[root].r.y, a[rc].r.y);
		}
	}
	void build(int &root, int l, int r, bool now) {
		root = ++size;
		a[root].index = a[root].Max = -1;
		int mid = (l + r) / 2; mode = now;
		nth_element(tmp + l, tmp + mid, tmp + r + 1);
		a[root].pos = tmp[mid].pos;
		pos[tmp[mid].home] = root;
		if (mid > l) {
			build(a[root].lc, l, mid - 1, now ^ true);
			a[a[root].lc].fa = root;
		}
		if (mid < r) {
			build(a[root].rc, mid + 1, r, now ^ true);
			a[a[root].rc].fa = root;
		}
		updaterange(root);
	}
	void add(int x, int y, int home) {tmp[++tot] = (info) {(point) {x, y}, home}; }
	void init() {
		size = root = 0;
		build(root, 1, tot, 0);
	}
	void updateMax(int root) {
		a[root].Max = a[root].index;
		if (a[root].lc) chkmax(a[root].Max, a[a[root].lc].Max);
		if (a[root].rc) chkmax(a[root].Max, a[a[root].rc].Max);
	}
	void modify(int home, int val) {
		int now = pos[home];
		a[now].index = val;
		updateMax(now);
		while (now != root) {
			now = a[now].fa;
			updateMax(now);
		}
	}
	int query(int root, point ql, point qr) {
		if (root == 0 || a[root].Max == -1) return -1;
		if (ql.x <= a[root].l.x && ql.y <= a[root].l.y && qr.x >= a[root].r.x && qr.y >= a[root].r.y) return a[root].Max;
		if (ql.x > a[root].r.x || ql.y > a[root].r.y || qr.x < a[root].l.x || qr.y < a[root].l.y) return -1;
		int ans = -1;
		if (a[root].pos.x >= ql.x && a[root].pos.x <= qr.x && a[root].pos.y >= ql.y && a[root].pos.y <= qr.y) ans = a[root].index;
		chkmax(ans, query(a[root].lc, ql, qr));
		chkmax(ans, query(a[root].rc, ql, qr));
		return ans;
	}
	int query(int lx, int rx, int ly, int ry) {
		return query(root, (point) {lx, ly}, (point) {rx, ry});
	}
} KDT;
int type[MAXN], x[MAXN], y[MAXN], z[MAXN];
int main() {
	read(n), read(m);
	for (int i = 1; i <= n - 1; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		a[x].push_back(y);
		a[y].push_back(x);
	}
	work(1, 0);
	for (int i = 1; i <= m; i++) {
		read(type[i]), read(x[i]);
		if (type[i] == 0) {
			read(y[i]), read(z[i]);
			KDT.add(dfn[x[i]], dfn[y[i]], i);
		}
	}
	KDT.init(); ST.init(n);
	for (int i = 1; i <= m; i++) {
		if (type[i] == 0) {
			int Lca = lca(x[i], y[i]);
			ST.push(dfn[Lca], z[i]);
			KDT.modify(i, z[i]);
		}
		if (type[i] == 1) {
			int j = x[i], Lca = lca(x[j], y[j]);
			ST.pop(dfn[Lca], z[j]);
			KDT.modify(j, -1);
		}
		if (type[i] == 2) {
			int tmp = x[i];
			int ans = ST.query(dfn[tmp] + 1, rit[tmp]);
			chkmax(ans, KDT.query(1, dfn[tmp] - 1, rit[tmp] + 1, n));
			chkmax(ans, KDT.query(1, dfn[tmp] - 1, 1, dfn[tmp] - 1));
			chkmax(ans, KDT.query(rit[tmp] + 1, n, 1, dfn[tmp] - 1));
			chkmax(ans, KDT.query(rit[tmp] + 1, n, rit[tmp] + 1, n));
			writeln(ans);
		}
	}
	return 0;
}