树剖换根_

于 2021-08-15 11:50:59 发布
阅读量224 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mango114514/article/details/119672682
版权

P3979 遥远的国度

本题需要支持 3 3 3 个操作：

  1. 把根修改为 i d id id；
  2. 将 x    y x\;y xy 路径上的所有点权修改为 v v v；
  3. 询问以 x x x 为根的子树中的最小点权。

看到这道题，第一思路就是对于每个操作 1 1 1，换根后重新剖一遍。但时间复杂度为 O ⁡ ( q n ) \operatorname{O}(qn) O(qn)！直接原地爆炸

所以，我们想到另一种方法，直接以 1 1 1 为根来剖，记录当前的根，每次修改和查询的时候再根据根的位置回答。

对于修改操作，由于一棵树上任意两点间只有一条路径，所以直接修改就行了。

重点是查询：

设当前的根为 r t rt rt，要询问以 x x x 为根的子树中的最小值。

  1. x = r t x=rt x=rt：直接输出全局最小值；
  2. r t rt rt 是 x x x 的祖先：直接输出 x x x 的子树的最小值；
  3. x x x 是 r t rt rt 的祖先：这种情况非常 毒瘤 \color{White}\colorbox{White}{毒瘤} 毒瘤​有意思！我们待会会讨论如何处理；
  4. 以上情况都不是，相当于 x x x 在其他的分支，也是直接输出 x x x 的子树的最小值。

判断顺序：先判断是否是 1 1 1，再判断是否是 3 3 3，剩下自然就是 2 2 2 和 4 4 4 了。

现在讨论一下如何处理情况 3 3 3：

如图，若 x = 2 , r t = 4 x=2,rt=4 x=2,rt=4，则以 4 4 4 为根时， 2 2 2 的子树就是除了往 4 4 4 的方向的节点外的所有节点。也就是要找 x x x 到 r t rt rt 这条路径上 x x x 的儿子。

找的方法可以用倍增，记录 f a ( x ) ( i ) fa(x)(i) fa(x)(i) 为 x x x 的第 2 i 2^i 2i 级祖先， getfa(x,k) ⁡ \operatorname{getfa(x,k)} getfa(x,k) 函数返回 x x x 的第 2 k 2^k 2k 级祖先，实现如下：

int getfa(int x, int k)
{
	for (int i = lg[k]; i >= 0; i--)
	{
		if (k >= (1 << i))
		{
			x = fa[x][i];
			k -= (1 << i);
		}
	}
	return x;
}

令 y ← getfa(x,dep[rt]-dep[x]-1) ⁡ y\gets\operatorname{getfa(x,dep[rt]-dep[x]-1)} y←getfa(x,dep[rt]-dep[x]-1)，我们只需判断 f a ( y ) ( 0 ) fa(y)(0) fa(y)(0) 是否等于 x x x 即可，这样既判断了 x x x 是否是 r t rt rt 的祖先，又顺便求出了 y y y。

Code \Large\text{Code} Code

#include <iostream>
#include <cstdio>
using namespace std;

const int MAXN = 1e5 + 5;
const int INF = 0x7fffffff;

int cnt, Time;
int b[MAXN], a[MAXN], head[MAXN], fa[MAXN][18], lg[MAXN], dep[MAXN], siz[MAXN], son[MAXN], dfn[MAXN], top[MAXN];

struct edge
{
	int to, nxt;
}e[MAXN << 1];

void add(int u, int v)
{
	e[++cnt] = edge{v, head[u]};
	head[u] = cnt;
}

void dfs1(int u, int father)
{
	fa[u][0] = father;
	for (int i = 1; i <= 17; i++)
	{
		fa[u][i] = fa[fa[u][i - 1]][i - 1];
	}
	dep[u] = dep[father] + 1;
	siz[u] = 1;
	for (int i = head[u]; i; i = e[i].nxt)
	{
		int v = e[i].to;
		if (v == father)
		{
			continue;
		}
		dfs1(v, u);
		siz[u] += siz[v];
		if (siz[v] > siz[son[u]])
		{
			son[u] = v;
		}
	}
}

void dfs2(int u, int topp)
{
	dfn[u] = ++Time;
	a[Time] = b[u];
	top[u] = topp;
	if (son[u])
	{
		dfs2(son[u], topp);
	}
	for (int i = head[u]; i; i = e[i].nxt)
	{
		int v = e[i].to;
		if (top[v])
		{
			continue;
		}
		dfs2(v, v);
	}
}

int getfa(int x, int k)
{
	for (int i = lg[k]; i >= 0; i--)
	{
		if (k >= (1 << i))
		{
			x = fa[x][i];
			k -= (1 << i);
		}
	}
	return x;
}

#define lson pos << 1
#define rson pos << 1 | 1

struct tree
{
	int l, r, val = INF, tag;
}t[MAXN << 2];

void pushup(int pos)
{
	t[pos].val = min(t[lson].val, t[rson].val);
}

void pushdown(int pos)
{
	if (t[pos].tag)
	{
		t[lson].val = t[lson].tag = t[rson].val = t[rson].tag = t[pos].tag;
		t[pos].tag = 0;
	}
}

void build(int pos, int l, int r)
{
	t[pos].l = l, t[pos].r = r;
	if (l == r)
	{
		t[pos].val = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}

void update(int pos, int L, int R, int k)
{
	int l = t[pos].l, r = t[pos].r;
	if (l >= L && r <= R)
	{
		t[pos].val = t[pos].tag = k;
		return;
	}
	pushdown(pos);
	int mid = (l + r) >> 1;
	if (L <= mid)
	{
		update(lson, L, R, k);
	}
	if (R > mid)
	{
		update(rson, L, R, k);
	}
	pushup(pos);
}

int query(int pos, int L, int R)
{
	int l = t[pos].l, r = t[pos].r;
	if (l >= L && r <= R)
	{
		return t[pos].val;
	}
	pushdown(pos);
	int mid = (l + r) >> 1, res = INF;
	if (L <= mid)
	{
		res = query(lson, L, R);
	}
	if (R > mid)
	{
		res = min(res, query(rson, L, R));
	}
	return res;
}

void update_path(int x, int y, int v)
{
	while (top[x] != top[y])
	{
		if (dep[top[x]] < dep[top[y]])
		{
			swap(x, y);
		}
		update(1, dfn[top[x]], dfn[x], v);
		x = fa[top[x]][0];
	}
	if (dep[x] < dep[y])
	{
		swap(x, y);
	}
	update(1, dfn[y], dfn[x], v);
}

int query_subtree(int x)
{
	return query(1, dfn[x], dfn[x] + siz[x] - 1);
}

int main()
{
	int n, m, u, v, rt, op, x, y;
	scanf("%d%d", &n, &m);
	for (int i = 2; i <= n; i++)
	{
		lg[i] = lg[i >> 1] + 1;
	}
	for (int i = 1; i < n; i++)
	{
		scanf("%d%d", &u, &v);
		add(u, v);
		add(v, u);
	}
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", b + i);
	}
	dfs1(1, 0);
	dfs2(1, 1);
	build(1, 1, n);
	scanf("%d", &rt);
	while (m--)
	{
		scanf("%d", &op);
		if (op == 1)
		{
			scanf("%d", &rt);
		}
		else if (op == 2)
		{
			scanf("%d%d%d", &x, &y, &v);
			update_path(x, y, v);
		}
		else
		{
			scanf("%d", &x);
			if (x == rt)
			{
				printf("%d\n", t[1].val);
			}
			else if (dep[x] < dep[rt] && fa[y = getfa(rt, dep[rt] - dep[x] - 1)][0] == x)
			{
				if (dfn[u] + siz[u] <= n)
				{
					printf("%d\n", min(query(1, 1, dfn[y] - 1), query(1, dfn[y] + siz[y], n))); //y的子树不要
				}
				else
				{
					printf("%d\n", query(1, 1, dfn[y] - 1));
				}
			}
			else
			{
				printf("%d\n", query_subtree(x));
			}
		}
	}
	return 0;
}

CF916E Jamie and Tree

  1. 给定一个点 v v v，将整颗树的根变为 v v v；
  2. 给定两个点 u , v u, v u,v，将 l c a ( u , v ) lca(u, v) lca(u,v) 所在的子树都加上 x x x；
  3. 给定一个点 v v v，回答以 v v v 所在的子树的权值和。

这道题的操作 1 1 1 和 3 3 3 都和上一题一样，只是操作 2 2 2 变成了子树修改，所以也要分类讨论：

  1. l c a = r t lca=rt lca=rt：直接将全局和加上 x x x；
  2. l c a lca lca 是 r t rt rt 的祖先：同查询，记 l c a lca lca 到 r t rt rt 这条路径上 l c a lca lca 的儿子为 s o n son son，我们可以先将全局和加上 x x x，再将 s o n son son 的子树和减去 x x x，这样相当于 s o n son son 的子树都没加。
  3. 其他情况下直接将 l c a lca lca 的子树和加 x x x。

但是还有一个坑，就是 l c a lca lca 也会根据 r t rt rt 的位置而改变！

  1. u u u 和 v v v 都在 r t rt rt 的子树内： l c a ← LCA(u,v) ⁡ lca\gets\operatorname{LCA(u,v)} lca←LCA(u,v)；
  2. 其中一个在 r t rt rt 的子树内： l c a ← r t lca\gets rt lca←rt；
  3. u u u 和 v v v 都不在 r t rt rt 的子树内： l c a lca lca 为 LCA(u,rt) ⁡ \operatorname{LCA(u,rt)} LCA(u,rt) 和 LCA(v,rt) ⁡ \operatorname{LCA(v,rt)} LCA(v,rt) 中深度较大的。

综上，可以发现，以上 3 3 3 种情况的 l c a lca lca 都满足是 LCA(u,v) ⁡ , LCA(u,rt) ⁡ \operatorname{LCA(u,v)},\operatorname{LCA(u,rt)} LCA(u,v),LCA(u,rt) 和 LCA(v,rt) ⁡ \operatorname{LCA(v,rt)} LCA(v,rt) 中深度最大的那个。

Code \Large\text{Code} Code

#include <iostream>
#include <cstdio>
#define int long long
#define re register
using namespace std;

inline int read()
{
	re int x = 0, f = 0;
	re char c = getchar();
	while (c < '0' || c > '9')
	{
		f |= c == '-';
		c = getchar();
	}
	while (c >= '0' && c <= '9')
	{
		x = (x << 3) + (x << 1) + (c ^ 48);
		c = getchar();
	}
	return f ? -x : x;
}

inline void write(int x)
{
	if (x < 0)
	{
		putchar('-');
		x = -x;
	}
	if (x > 9)
	{
		write(x / 10);
	}
	putchar(x % 10 ^ '0');
}

inline void swap2(int &x, int &y)
{
	x ^= y ^= x ^= y;
}

inline int min2(int x, int y)
{
	return x < y ? x : y;
}
//--------------------------------------------
const int MAXN = 1e5 + 5;

int cnt, Time;
int a[MAXN], b[MAXN], head[MAXN], fa[MAXN][18], lg[MAXN], dep[MAXN], siz[MAXN], son[MAXN], dfn[MAXN], top[MAXN];

struct edge
{
	int to, nxt;
}e[MAXN << 1];

void add(int u, int v)
{
	e[++cnt] = edge{v, head[u]};
	head[u] = cnt;
}

void dfs1(int u, int father)
{
	fa[u][0] = father;
	dep[u] = dep[father] + 1;
	siz[u] = 1;
	for (re int i = 1; i <= 17; i++)
	{
		fa[u][i] = fa[fa[u][i - 1]][i - 1];
	}
	for (re int i = head[u]; i; i = e[i].nxt)
	{
		int v = e[i].to;
		if (v == father)
		{
			continue;
		}
		dfs1(v, u);
		siz[u] += siz[v];
		if (siz[v] > siz[son[u]])
		{
			son[u] = v;
		}
	}
}

void dfs2(int u, int topp)
{
	dfn[u] = ++Time;
	a[Time] = b[u];
	top[u] = topp;
	if (son[u])
	{
		dfs2(son[u], topp);
	}
	for (re int i = head[u]; i; i = e[i].nxt)
	{
		int v = e[i].to;
		if (top[v])
		{
			continue;
		}
		dfs2(v, v);
	}
}

int lca(int x, int y)
{
	if (dep[x] < dep[y])
	{
		swap2(x, y);
	}
	while (dep[x] > dep[y])
	{
		x = fa[x][lg[dep[x] - dep[y]]];
	}
	if (x == y)
	{
		return x;
	}
	for (re int i = 17; i >= 0; i--)
	{
		if (fa[x][i] != fa[y][i])
		{
			x = fa[x][i];
			y = fa[y][i];
		}
	}
	return fa[x][0];
}

int getfa(int x, int k)
{
	for (re int i = lg[k]; i >= 0; i--)
	{
		if (k >= (1 << i))
		{
			x = fa[x][i];
			k -= (1 << i);
		}
	}
	return x;
}

#define lson pos << 1
#define rson pos << 1 | 1

struct tree
{
	int l, r, siz, val, tag;
}t[MAXN << 2];

void pushup(int pos)
{
	t[pos].val = t[lson].val + t[rson].val;
}

void cal(int pos, int val)
{
	t[pos].val += val * t[pos].siz;
	t[pos].tag += val;
}

void pushdown(int pos)
{
	if (t[pos].tag)
	{
		cal(lson, t[pos].tag);
		cal(rson, t[pos].tag);
		t[pos].tag = 0;
	}
}

void build(int pos, int l, int r)
{
	t[pos].l = l, t[pos].r = r, t[pos].siz = r - l + 1;
	if (l == r)
	{
		t[pos].val = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(pos);
}

void update(int pos, int L, int R, int k)
{
	int l = t[pos].l, r = t[pos].r;
	if (L <= l && r <= R)
	{
		cal(pos, k);
		return;
	}
	pushdown(pos);
	int mid = (l + r) >> 1;
	if (L <= mid)
	{
		update(lson, L, R, k);
	}
	if (R > mid)
	{
		update(rson, L, R, k);
	}
	pushup(pos);
}

int query(int pos, int L, int R)
{
	int l = t[pos].l, r = t[pos].r;
	if (L <= l && r <= R)
	{
		return t[pos].val;
	}
	pushdown(pos);
	int mid = (l + r) >> 1, res = 0;
	if (L <= mid)
	{
		res = query(lson, L, R);
	}
	if (R > mid)
	{
		res += query(rson, L, R);
	}
	return res;
}

void update_subtree(int x, int k)
{
	update(1, dfn[x], dfn[x] + siz[x] - 1, k);
}

int query_subtree(int x)
{
	return query(1, dfn[x], dfn[x] + siz[x] - 1);
}

int getlca(int x, int y, int z) //3个lca中深度最大的
{
	int a = lca(x, y), b = lca(x, z), c = lca(y, z);
	if (dep[a] < dep[b])
	{
		a = b;
	}
	if (dep[a] < dep[c])
	{
		a = c;
	}
	return a;
}

signed main()
{
	int n = read(), q = read(), rt = 1;
	for (re int i = 2; i <= n; i++)
	{
		lg[i] = lg[i >> 1] + 1;
	}
	for (re int i = 1; i <= n; i++)
	{
		b[i] = read();
	}
	for (re int i = 1; i < n; i++)
	{
		int u = read(), v = read();
		add(u, v);
		add(v, u);
	}
	dfs1(1, 0);
	dfs2(1, 1);
	build(1, 1, n);
	while (q--)
	{
		int op = read(), u = read(), v, x, p, q;
		switch (op)
		{
			case 1:
				rt = u;
				break;
			case 2:
				v = read(), x = read();
				u = getlca(u, v, rt);
				if (u == rt)
				{
					update(1, 1, n, x);
				}
				else if (lca(u, rt) == u)
				{
					v = getfa(rt, dep[rt] - dep[u] - 1);
					update(1, 1, n, x);
					update_subtree(v, -x); //将v的子树减掉
				}
				else
				{
					update_subtree(u, x);
				}
				break;
			case 3:
				if (u == rt)
				{
					write(query(1, 1, n));
				}
				else if (lca(rt, u) == u)
				{
					v = getfa(rt, dep[rt] - dep[u] - 1);
					write(query(1, 1, n) - query_subtree(v));
				}
				else
				{
					write(query_subtree(u));
				}
				putchar('\n');
				break;
		}
	}
	return 0;
}
mango114514
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的操作（换根树剖）
苟为蒟蒻又何妨
06-30 1103
描述 XXX和 YYY在愉快地刷题。有一道题是这样的：给你一棵 n 个节点的有根树，每个节点有 一个权植。你要支持两种操作：查询以某棵树为根的子树的权值和，给以某个节点为根的整 棵子树的所有点的权值都加上一个值。机智的 XXX 很开心地用LLL教授 讲过的某些东西水水水水过了这道题。 但是可怕的出题人又增加了一种操作：将根节点改为第 u 号节点。于是XXX和YYY 就不会 做了。按照一惯的逻辑...
[bzoj3083]遥远的国度
Vampire
10-25 609
3083: 遥远的国度Time Limit: 10 Sec Memory Limit: 1280 MB Submit: 1733 Solved: 429 [Submit][Status][Discuss] Description描述 zcwwzdjn在追杀十分sb的zhx，而zhx逃入了一个遥远的国度。当zcwwzdjn准备进入遥远的国度继续追杀时，守护神RapiD阻拦了zcwwzdjn
换根
10-19 275
这是一道模板题。 给定一棵nnn个节点的树，初始时该树的根为111号节点，每个节点有一个给定的权值。下面依次进行mmm个操作，操作分为如下五种类型： 换根：将一个指定的节点设置为树的新根。 修改路径权值：给定两个节点，将这两个节点间路径上的所有节点权值（含这两个节点）增加一个给定的值。 修改子树权值：给定一个节点，将以该节点为根的子树内的所有节...
换根树剖模板
romiqi
01-23 305
换根其实很简单，我们考虑换根对答案的影响，换根不会对链上信息有任何影响，所以我们只考虑子树方面 1.当前的根root不在询问点u的子树中，表示虽然换了根，但u在以root为根的树中的子树就和在以最初的根的树中的子树一样 2.当前的根在询问点u的子树中，那么u在以root为根的树中的子树就是u到root路径上第一个点在以最初的根的树中的子树之外的部分 这两个部分画图好理解 特判一下u=root 的情...
2018.10.19【NOIP练习】树链剖分（换根树剖）
zxyoi_dreamer的博客（不定期诈尸）
10-19 833
传送门 解析： 其实说是换根，并不会真正的换根，不然怎么维护原来轻重链剖分的 代码： #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; #define ll long long #define re register #define gc getchar #define pc putchar #define cs const inline ...
树分治_黄哲威.pdf
09-14
【点分治】是树分治的一种形式，它首先选择一个节点，将无根树转化为有根树，然后递归地处理以该根节点的子节点为根的每一棵子树。这一过程的核心是通过选取合适的节点，使得问题能够被有效地分解，并且每次操作都能...
有关于最小生成树的介绍
05-15
在更复杂的问题中，例如动态更新和查询树上的信息，可能需要更高级的数据结构和算法，比如平衡二叉查找树（AVL、红黑树等）、树剖、树链剖分等。在处理这类问题时，我们需要根据问题的特点选择合适的方法，以达到...
第5章 树链剖分 测试数据.rar
12-02
一旦树被剖分成多个链，我们可以对每个节点维护两个关键的数据结构：一是指向最近的“重儿子”的指针，这里的“重儿子”是指子节点中深度最大的一个；二是链表，包含该节点的所有轻儿子，即除重儿子外的其他子节点。...
大班科学大树的隐秘.docx
11-06
活动中，教师会利用道具（如树枝、树皮、树叶等）和多媒体工具（如电子大书、树的剖切面图片）引导孩子们探索。通过闻、摸、猜的游戏方式，激发孩子们的兴趣，让他们在玩耍中学习。教师会解释不同部分的作用，比如...
【模版】最近公共祖先LCA(链剖)
01-07
给定一棵 以 sss 为根节点，共有 nnn 个点的树。 有 mmm 次查询 每次查询 u,vu ,vu,v 的最近公共祖先。 算法流程 111.根据连边的信息建图（邻接表）。代码就不贴了，注意建立双向边。 222.dfs1dfs1dfs1 ，从给定的...
2018.10.30 NOIP训练 【模板】树链剖分（换根树剖）
苟为蒟蒻又何妨
10-31 305
传送门 纯粹是为了熟悉板子。 然后发现自己手生了足足写了差不多25min而且输出的时候因为没开long longWA了三次还不知所云 代码
树的换根(重心)
Sillver_的博客
04-01 655
题目链接： https://ac.nowcoder.com/acm/contest/4479/C 思想：树的换根 在一个树中，首先任意选一个点作为根开始深搜，计算每个子树的节点数量，和这个根节点的深度和，之后从邻接点依次转移，取最小值。 树根转换公式：dp[邻接点深度和]=dp[该点深度和]-num[该点为根的子树的节点数量]+(n-num[ ])； 公式来源：一个树的所有儿子节点的深度和可以通过...
【dfs序】【线段树】树链剖分换根
weixin_44111457的博客
03-16 519
【题目描述】 给定一棵大小为 n 的有根点权树,支持以下操作: • 换根 • 修改点权 • 查询子树最小值 【输入】 第一行两个整数 n, Q ,分别表示树的大小和操作数。 接下来n行,每行两个整数f,v,第i+1行的两个数表示点i的父亲和点i的权。保 证f &amp;lt; i。如 果f = 0,那么i为根。输入数据保证只有i = 1时,f = 0。 接下来 m 行,为以下格式中的一种: • V x y...
cqyz oj |【训练题】树的换根操作 | 模板题
banla3330的博客
07-24 230
Description 我们知道：N个点的无向图，满足下列三个条件中任意两个，那么就是一棵无根树： (1)、连通； (2)、有N-1条边； (3)、任意两点有且仅有一条路径 我们也知道，一棵无根树中，任意一个点都可以作为根。现在的问题是，给出一棵含N个结点的无根树（结点编号为1..N），然后给出若干查询：query x y，其含义为：当以x为根时，y的父亲是谁（若无父亲，则输出0,，和以...
树链剖分换根模板
EPSILON的博客
09-23 435
树链剖分换根模板 具体思想： 换根后，一条链上的信息不回被改变。 在下图中2-1-3-7-8这条链不管是哪一个点事根节点，就可以是2-1-3-7-8 但是子树的信息会被改变。 以下图为例， 假设有一颗树，最初始的根为1 现在进行一次换根操作，将1换为rootrootroot，查询以3为根的子树的权值和。 有以下三种情况： 当root=3root=3root=3时：ans=ans=ans=所有点的...
P3979 遥远的国度(换根树剖)
jziwjxjd的博客
10-02 281
遥远的国度 肯定不可能对每次换根重新树剖一次 那就是只以根111剖一次来换根 其中rootrootroot表示当前的根,uuu表示询问uuu子树内的最小值 分情况讨论 Ⅰ.若u==rootⅠ.若u==rootⅠ.若u==root,明显所输出a[1]a[1]a[1],全局最小值 Ⅱ.若u的深度大于root且u在1到root的链上,那么开始换根Ⅱ.若u的深度大于root且u在1到root的链上,那么开始换根Ⅱ.若u的深度大于root且u在1到root的链上,那么开始换根 此时我们找到在root到u的链上的v是u
『树形DP·换根』The Crazy Tree(毒瘤)
Ronaldo7_ZYB的博客
06-17 687
题目描述 给定一棵 nnn 个结点的树，结点编号为 1−n1-n1−n，iii号结点的权重记为 wiwiwi（每个点的权值各不相同）。我们定义一个“疯子树”为： 1. 是一个联通子图。 2. 我们将子图内的点按照权重从小到大排序后序列为 b1,b2,…,bmb1,b2,…,bmb1,b2,…,bm，对于任意的i(i&lt;m)i(i&lt;m)i(i<m),bibibi到bi...
1021 - 【模板】树链剖分+换根
Faithfully-xly的博客
10-21 1239
树链剖分 描述 给定一棵 n 个节点的树，初始时该树的根为 1 号节点，每个节点有一个给定的权值。下面依次进行 m 个操作，操作分为如下五种类型： 换根：将一个指定的节点设置为树的新根。 修改路径权值：给定两个节点，将这两个节点间路径上的所有节点权值（含这两个节点）增加一个给定的值。 修改子树权值：给定一个节点，将以该节点为根的子树内的所有节点权值增加一个给定的值。 询问路径：询问某条路径上节点的...
树链剖分换根
C202044zxy的博客
09-15 1041
一、题目 电磁看题 二、解法 这道题总体很板，不过换根的操作很清奇，我们来详细讨论一下。 可以发现换根对路径查询&修改没有影响。 我们考虑不改变树的形状，分类讨论换根对子树查询&修改的影响: 1、如果u=rootu=rootu=root，则直接操作整棵树。 2、如果lca(u,root)̸=ulca(u,root)\not=ulca(u,root)̸​=u，即根不在uuu的子树内，...
threejs 剖切
最新发布
07-27
Three.js中的剖切功能可以通过设置剪裁平面对象来实现。通过WebGL渲染器的.clippingPlanes属性设置的剪裁平面对象Plane可以剪裁场景中的所有模型对象。如果你只想剪裁特定的模型对象，可以通过Three.js材质对象的....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值