洛谷P4114 Qtree1 树剖+点权化边权+线段树

最新推荐文章于 2021-08-07 11:12:59 发布

dan__zh

最新推荐文章于 2021-08-07 11:12:59 发布

阅读量228

点赞数

CC 4.0 BY-SA版权

分类专栏： # 树链剖分

本文链接：https://blog.youkuaiyun.com/weixin_42431507/article/details/95915355

树链剖分专栏收录该内容

20 篇文章

订阅专栏

该博客详细解析了洛谷P4114题目，涉及树剖、边权化点权和线段树在解决查询与修改问题上的应用。博主介绍了如何将边权转化为点权，以及在修改和查询操作中处理LCA（最低公共祖先）的方法，并强调了操作过程中应注意的细节。

洛谷P4114 Qtree1

简明题意

给一颗树，给出边权，需要支持两种操作：
1. 修改：将第i条边权改为c
2. 查询：查询u-v的路径中权值最大值

思路

首先化边权为点权是必须的。然后
1. 修改操作：
  单点修改，直接改就行了
2. 查询操作：
  由于化边权为点权了，对于u-v的路径，我们直接去掉LCA(u,v)再查就是正确答案了。具体怎么去掉呢？直接在查询之前，将LCA(u,v)置为无穷小，查完再还原就可以了

注意事项

将LCA(u,v)置为无穷小时，记得用change函数去修改，不要直接在w上修改

总结

永远不要对w操作…

AC代码

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn = 1e5 + 10;
const int inf = -2e9;

struct Edge
{
   int v, w;
   Edge(int v, int w) : v(v), w(w) {}
};

int n, a[maxn];
vector<Edge> g[maxn];
pair<int, int> rec[maxn];

int dep[maxn], fa[maxn], siz[maxn], son[maxn];
void dfs1(int u, int f, int deep, int w)
{
   dep[u] = deep;
   fa[u] = f;
   siz[u] = 1;
   a[u] = w;

   int max_son = -1;
   for (auto& v : g[u])
   	if (v.v != f)
   	{
   		dfs1(v.v, u, deep + 1, v.w);
   		siz[u] += siz[v.v];
   		if (siz[v.v] > max_son)
   			max_son = siz[v.v], son[u] = v.v;
   	}
}

int top[maxn], id[maxn], cnt, w[maxn];
void dfs2(int u, int topf)
{
   top[u] = topf;
   id[u] = ++cnt;
   w[cnt] = a[u];

   if (son[u])
   {
   	dfs2(son[u], topf);
   	for (auto& v : g[u])
   		if (v.v != fa[u] && v.v != son[u])
   			dfs2(v.v, v.v);
   }
}

struct Node
{
   int l, r, max;
};

Node tree[maxn * 4];

void update(int o)
{
   if (tree[o].l != tree[o].r)
   	tree[o].max = max(tree[o * 2].max, tree[o * 2 + 1].max);
}

void build(int o, int l, int r)
{
   tree[o].l = l, tree[o].r = r;
   if (l == r)
   {
   	tree[o].max = w[l];
   	return;
   }

   int mid = (l + r) / 2;
   build(o * 2, l, mid);
   build(o * 2 + 1, mid + 1, r);

   update(o);
}

int ask(int o, int l, int r)
{
   if (tree[o].l == l && tree[o].r == r)
   	return tree[o].max;

   int mid = (tree[o].l + tree[o].r) / 2;
   if (r <= mid)
   	return ask(o * 2, l, r);
   else if (l > mid)
   	return ask(o * 2 + 1, l, r);
   else
   	return max(ask(o * 2, l, mid), ask(o * 2 + 1, mid + 1, r));
}

void change(int o, int x, int c)
{
   if (tree[o].l == tree[o].r)
   {
   	tree[o].max = c;
   	return;
   }

   int mid = (tree[o].l + tree[o].r) / 2;
   if (x <= mid)
   	change(o * 2, x, c);
   else
   	change(o * 2 + 1, x, c);

   update(o);
}

int LCA(int u, int v)
{
   while (top[u] != top[v])
   {
   	if (dep[top[v]] < dep[top[u]]) swap(u, v);
   	v = fa[top[v]];
   }
   return dep[u] < dep[v] ? u : v;
}

void solve()
{
   scanf("%d", &n);
   for (int i = 1; i < n; i++)
   {
   	int u, v, w;
   	scanf("%d%d%d", &u, &v, &w);
   	rec[i].first = u, rec[i].second = v;

   	g[u].push_back(Edge(v, w)), g[v].push_back(Edge(u, w));
   }

   dfs1(1, 1, 1, 0);
   dfs2(1, 1);
   build(1, 1, n);

   char cmd[20];
   while (scanf("%s", cmd))
   {
   	if (cmd[0] == 'D') return;
   	
   	if (cmd[0] == 'Q')
   	{
   		int u, v;
   		scanf("%d%d", &u, &v);
   		if (u == v)
   		{
   			printf("0\n");
   			continue;
   		}

   		int k = LCA(u, v);
   	
   		int bef = ask(1, id[k], id[k]);
   		change(1, id[k], inf);

   		int ans = -2e9;
   		while (top[u] != top[v])
   		{
   			if (dep[top[v]] < dep[top[u]]) swap(u, v);
   			ans = max(ans, ask(1, id[top[v]], id[v]));
   			v = fa[top[v]];
   		}
   		printf("%d\n", max(ans, ask(1, min(id[u], id[v]), max(id[u], id[v]))));

   		change(1, id[k], bef);
   	}
   	else
   	{
   		int x, c;
   		scanf("%d%d", &x, &c);

   		change(1, dep[rec[x].first] > dep[rec[x].second] ? id[rec[x].first] : id[rec[x].second], c);
   	}
   }
}

int main()
{
   freopen("Testin.txt", "r", stdin);
   solve();
   return 0;
}