P4374 [USACO18OPEN]Disruption P

题目链接

题目思路

给两个点加额外的双向边时 可以观察到只有对于在树上这两个点之间的路径中出现断边的时候才有可能会用的到这条边 如下图所示 则我们可以维护每个边权 转化为点权 维护最小值 对于给出的query的边 我们可以通过分析这条边的两个端点的深度 哪个深度高 则断这条边的时候可以认为成断深度高的那个点 即输出当前点最小值
我们可以将change的所有边从大到小排列 避免了pushup操作 直接覆盖即可

代码

#include <bits/stdc++.h>

#define L u << 1
#define R u << 1 | 1 

using namespace std;

const int N = 100100, M = N * 2, INF = 2e9;

int n, m;
int h[N], e[M], ne[M], idx;
int fa[N], son[N], sz[N], dep[N];
int id[N], top[N], cnt;

struct Node
{
	int l, r;
	int val, lazy;
}tr[N >> 2];

struct Edge
{
	int a, b, c;
};
Edge ed[N], que[N];

inline int read()
{
	register int 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 << 3) + (x << 1) + (c ^ 48);
		c = getchar();
	}
	return x * f;
}

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

bool cmp(Edge a, Edge b)
{
	return a.c > b.c;
}

void dfs1(int u, int father, int depth)
{
	dep[u] = depth, fa[u] = father, sz[u] = 1;
	for (int i = h[u]; ~i; i = ne[i])
	{
		int j = e[i];
		if (j == father) continue;
		dfs1(j, u, depth + 1);
		sz[u] += sz[j];
		if (sz[son[u]] < sz[j]) son[u] = j;
	}
}

void dfs2(int u, int t)
{
	id[u] = ++ cnt, top[u] = t;
	if (!son[u]) return;
	dfs2(son[u], t);
	for (int i = h[u]; ~i; i = ne[i])
	{
		int j = e[i];
		if (j == fa[u] || j == son[u]) continue;
		dfs2(j, j);
	}
}

void pushdown(int u)
{
	auto &root = tr[u], &left = tr[L], &right = tr[R];
	if (root.lazy != -1)
	{
		left.val = left.lazy = root.lazy;
		right.val = right.lazy = root.lazy;
		root.lazy = -1;
	}
}

void build(int u, int l, int r)
{
	tr[u] = {l, r, -1, -1};
	if (l == r) return;
	int mid = l + r >> 1;
	build(L, l, mid), build(R, mid + 1, r);
}

void update(int u, int l, int r, int c)
{
	if (tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].val = tr[u].lazy = c;
		return;
	}
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if (l <= mid) update(L, l, r, c);
	if (r > mid) update(R, l, r, c);
}

int query(int u, int x)
{
	if (tr[u].l == x && tr[u].r == x) return tr[u].val;
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if (x <= mid) return query(L, x);
	else return query(R, x);
}

void update_path(int u, int v, int c)
{
	while (top[u] != top[v])
	{
		if (dep[top[u]] < dep[top[v]]) swap(u, v);
		update(1, id[top[u]], id[u], c);
		u = fa[top[u]];
	}
	if (u != v)
	{
		if (dep[u] < dep[v]) swap(u, v);
		update(1, id[v] + 1, id[u], c);	
	}
}

int main()
{
	n = read(), m = read();
	
	memset(h, -1, sizeof h);
	for (int i = 0; i < n - 1; i ++ )
	{
		int a, b;
		a = read(), b = read();
		add(a, b), add(b, a); 
		que[i] = {a, b};
	}
	
	dfs1(1, -1, n);
	dfs2(1, 1);
	build(1, 1, n);
	
	for (int i = 0; i < m; i ++ )
	{
		int a, b, c;
		a = read(), b = read(), c = read();
		ed[i] = {a, b, c};
	}
	sort(ed, ed + m, cmp);
	for (int i = 0; i < m; i ++ ) 
		update_path(ed[i].a, ed[i].b, ed[i].c);
		
	for (int i = 0; i < n - 1; i ++ )
	{
		int a = que[i].a, b = que[i].b;
		if (dep[a] > dep[b]) printf("%d\n", query(1, id[a]));
		else printf("%d\n", query(1, id[b]));
	}
	
	return 0;
}