bzoj4372. 烁烁的游戏【动态点分治】

于 2021-09-01 17:47:37 发布
阅读量246 收藏 1
点赞数
分类专栏： 动态点分治 线段树 树形结构 文章标签： 动态点分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45754027/article/details/119861112
版权

传送门
背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。
题意：
给定一颗 n n n个节点的树，边权均为 1 1 1，初始树上没有皮皮鼠。
烁烁他每次会跳到一个节点 u u u，把周围与他距离不超过d的节点各吸引出 w w w只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。
烁烁很好奇，在当前时刻，节点 u u u 有多少个他的好朋友—皮皮鼠。
大意：
给一颗 n n n个节点的树，边权均为 1 1 1，初始点权均为 0 0 0， m m m 次操作：
Q Q Q x x x：询问 x x x 的点权。
M M M x x x d d d w w w：将树上与节点 x x x 距离不超过 d d d 的节点的点权均加上 w w w。

分析

涉及某个点到其它点的路径，且要支持修改，考虑动态点分治
动态点分治这里有详解P6329 【模板】点分树 | 震波【动态点分治】详解

对于这题来说
按照动态点分治，构建出 f a t h e r father father 数组

之后对于每个 Q Q Q，查询从当前节点开始，往上跳 f a fa fa，找到相对距离不超过 d d d的权值，减去 去重信息 里面的数

对于每个 M M M，同样从当前节点开始，往上跳 f a fa fa，给相对距离不超过 d d d 的节点加上权值，同时更新 去重信息

代码

普通区间加线段树

通过样例详情

//P6329-solve
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("1.in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;
int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt;
}edge[MAX_N];

void addEdge(int u, int v) {
	edge[tot].nxt = head[u];
	edge[tot].to = v;
	head[u] = tot++;
	edge[tot].nxt = head[v];
	edge[tot].to = u;
	head[v] = tot++;
}

int parent[MAX_N];
int sz[MAX_N];
int dep[MAX_N];
int top[MAX_N];
int son[MAX_N];

void dfs1(int u, int from) {
	parent[u] = from;
	dep[u] = dep[from] + 1;
	son[u] = 0;
	sz[u] = 1;
	
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u);
		sz[u] += sz[v];
		if (sz[v] > sz[son[u]]) {
			son[u] = v;
		}
	}
}

void dfs2(int u, int tp) {
	top[u] = tp;
	if (son[u]) dfs2(son[u], tp);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == son[u] || v == parent[u]) continue;
		dfs2(v, v);
	}
}

int LCA(int x, int y) {
	while (top[x] != top[y]) {
		if (dep[top[x]] < dep[top[y]]) swap(x, y);
		x = parent[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

int dis(int x, int y) {
	int lca = LCA(x, y);
	return dep[x] + dep[y] - 2 * dep[lca];
}

int maxx[MAX_N];
bool vis[MAX_N];

void root(int u, int from, int& rt, int sum) {
	sz[u] = 1;
	maxx[u] = 0;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		root(v, u, rt, sum);
		sz[u] += sz[v];
		maxx[u] = max(maxx[u], sz[v]);
	}
	maxx[u] = max(maxx[u], sum - sz[u]);
	if (maxx[u] < maxx[rt]) {
		rt = u;
	}
}

int dsz[MAX_N];
int father[MAX_N];

void divide(int u, int sum) {
	vis[u] = 1;
	dsz[u] = sum;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if (vis[v=edge[i].to]) continue;
		int rt = 0;
		int vsz = sz[v] < sz[u] ? sz[v] : sum - sz[u];
		root(v, u, rt, vsz);
		father[rt] = u;
		divide(rt, vsz);
	}
}

struct Tr {
	int k, l, r, add;
}tr[MAX_N<<4];
int indx = 0;

int mk() {
	return ++indx;
}

void calc(int& rt, int len, int k) {
	if (!rt) rt = mk();
	tr[rt].k += len * k;
	tr[rt].add += k;
}

void push_down(int rt, int l, int r) {
	if (!tr[rt].add) return;
	int mid = l + ((r-l)>>1);
	calc(tr[rt].l, mid - l + 1, tr[rt].add);
	calc(tr[rt].r, r - mid, tr[rt].add);
	tr[rt].add = 0;
}

void update(int &rt, int l, int r, int x, int y, int k) {
	if (!rt) rt = mk();
	if (x <= l && r <= y) {
		calc(rt, r - l + 1, k);
		return;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, y, k);
	if (y  > mid) update(tr[rt].r, mid+1, r, x, y, k);
}

int query(int rt, int l, int r, int x) {
	if (!rt) return 0;
	if (l == r) {
		return tr[rt].k;
	}
	push_down(rt, l, r);
	int mid = l + ((r-l)>>1);
	if (x <= mid) return query(tr[rt].l, l, mid, x);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x);
}

int A[MAX_N], B[MAX_N];

void modify(int x, int k, int w) {
	int d;

	for (int i = x; i; i = father[i]) {
		if (dis(x, i) <= k) {
			update(A[i], 1, dsz[i] + 1, 1, k - dis(x, i) + 1, w);
		}
		if (father[i] && dis(x, father[i]) <= k) {
			update(B[i], 1, dsz[father[i]] + 1, 1, k - dis(x, father[i]) + 1, w);
		}
	}
}

int ask(int x) {
	int res = 0;
	for (int i = x; i; i = father[i]) {
		res += query(A[i], 1, dsz[i] + 1, dis(x, i) + 1);
		if (father[i]) res -= query(B[i], 1, dsz[father[i]] + 1, dis(x, father[i]) + 1);
	}
	return res;
}

int arr[MAX_N];

void init() {
	memset(head, -1, sizeof head);
	tot = 0;
}

void solve(){
	init();
	sc("%d%d", &N, &M);
	int u, v;
	
	for (int i = 1; i < N; ++i) {
		sc("%d%d", &u, &v); 
		addEdge(u, v);
	}
	
	dfs1(1, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[0] = 1e8;
	root(1, 0, rt, N);
	divide(rt, N);

	char opt[5];
	int x, y, k;
	for (int i = 1; i <= M; ++i) {
		sc("%s", opt);
		if (*opt == 'M') {
			sc("%d%d%d", &x, &y, &k);
			modify(x, y, k);
		} else {
			sc("%d", &x);
			pr("%d\n", ask(x));
		}
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}

逻辑上差分优化后的线段树

通过样例结果

//P6329-solve
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("1.in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;
int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt;
}edge[MAX_N];

void addEdge(int u, int v) {
	edge[tot].nxt = head[u];
	edge[tot].to = v;
	head[u] = tot++;
	edge[tot].nxt = head[v];
	edge[tot].to = u;
	head[v] = tot++;
}

int parent[MAX_N];
int sz[MAX_N];
int dep[MAX_N];
int top[MAX_N];
int son[MAX_N];

void dfs1(int u, int from) {
	parent[u] = from;
	dep[u] = dep[from] + 1;
	son[u] = 0;
	sz[u] = 1;
	
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u);
		sz[u] += sz[v];
		if (sz[v] > sz[son[u]]) {
			son[u] = v;
		}
	}
}

void dfs2(int u, int tp) {
	top[u] = tp;
	if (son[u]) dfs2(son[u], tp);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == son[u] || v == parent[u]) continue;
		dfs2(v, v);
	}
}

int LCA(int x, int y) {
	while (top[x] != top[y]) {
		if (dep[top[x]] < dep[top[y]]) swap(x, y);
		x = parent[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

int dis(int x, int y) {
	int lca = LCA(x, y);
	return dep[x] + dep[y] - 2 * dep[lca];
}

int maxx[MAX_N];
bool vis[MAX_N];

void root(int u, int from, int& rt, int sum) {
	sz[u] = 1;
	maxx[u] = 0;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		root(v, u, rt, sum);
		sz[u] += sz[v];
		maxx[u] = max(maxx[u], sz[v]);
	}
	maxx[u] = max(maxx[u], sum - sz[u]);
	if (maxx[u] < maxx[rt]) {
		rt = u;
	}
}

int dsz[MAX_N];
int father[MAX_N];

void divide(int u, int sum) {
	vis[u] = 1;
	dsz[u] = sum;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if (vis[v=edge[i].to]) continue;
		int rt = 0;
		int vsz = sz[v] < sz[u] ? sz[v] : sum - sz[u];
		root(v, u, rt, vsz);
		father[rt] = u;
		divide(rt, vsz);
	}
}

struct Tr {
	int k, l, r, add;
}tr[MAX_N<<4];
int indx = 0;

int mk() {
	return ++indx;
}

void update(int& rt, int l, int r, int x, int k) {
	if (!rt) rt = mk();
	tr[rt].k += k;
	if (l == r) return;
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, k);
	if (x  > mid) update(tr[rt].r, mid+1, r, x, k);
}

int query(int rt, int l, int r, int x) {
	if (!rt) return 0;
	if (l == r) {
		return tr[rt].k;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) return tr[tr[rt].r].k + query(tr[rt].l, l, mid, x);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x);
} 

int A[MAX_N], B[MAX_N];

void modify(int x, int k, int w) {
	int d;

	for (int i = x; i; i = father[i]) {
		if (dis(x, i) <= k) {
			update(A[i], 1, dsz[i] + 1, k - dis(x, i) + 1, w);
		}
		if (father[i] && dis(x, father[i]) <= k) {
			update(B[i], 1, dsz[father[i]] + 1, k - dis(x, father[i]) + 1, w);
		}
	}
}

int ask(int x) {
	int res = 0;
	for (int i = x; i; i = father[i]) {
		res += query(A[i], 1, dsz[i] + 1, dis(x, i) + 1);
		if (father[i]) res -= query(B[i], 1, dsz[father[i]] + 1, dis(x, father[i]) + 1);
	}
	return res;
}

int arr[MAX_N];

void init() {
	memset(head, -1, sizeof head);
	tot = 0;
}

void solve(){
	init();
	sc("%d%d", &N, &M);
	int u, v;
	
	for (int i = 1; i < N; ++i) {
		sc("%d%d", &u, &v); 
		addEdge(u, v);
	}
	
	dfs1(1, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[0] = 1e8;
	root(1, 0, rt, N);
	divide(rt, N);

	char opt[5];
	int x, y, k;
	for (int i = 1; i <= M; ++i) {
		sc("%s", opt);
		if (*opt == 'M') {
			sc("%d%d%d", &x, &y, &k);
			modify(x, y, k);
		} else {
			sc("%d", &x);
			pr("%d\n", ask(x));
		}
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}
Hexrt
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
bzoj4372 烁烁的游戏（点分治+线段树）
Icefox的博客
07-14 1747
无限CE…一丝丝怀疑人生qaq 考虑点分树维护这个东西。每个节点x开一颗线段树，每个叶子节点i记录距离x距离为i的点加了多少。每次修改/询问在点分树上跳父亲就好了。然后还要容斥一下多加的部分，因此需要每个点再开一颗线段树表示到fa[x]距离为i的要减掉多少。 可以吧前缀加单点询问变成单点加后缀询问，这样节点可以少一些。 复杂度O(nlog2n)O(nlog2n)O(nlog^2n) 空间应...
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的...
BZOJ4372: 烁烁的游戏【动态点分治】
weixin_30809173的博客
12-02 80
Description 背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。 题意： 给定一颗n个节点的树，边权均为1，初始树上没有皮皮鼠。 烁烁他每次会跳到一个节点u，把周围与他距离不超过d的节点各吸引出w只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。 烁烁很好奇，在当前时刻，节点u有多少个他的好朋友---皮皮鼠。 大意： 给一颗n个节点的树，边权均为1，初始点权均为0，m次操作： Q x：询...
【BZOJ4372】烁烁的游戏 动态树分治
鲜衣怒马少年郎
05-12 1271
讲道理我第一次看到动态树分治以为和那个动态树LCT有关QAQ 然而正确的读法是【动态（树分治）】 这就很尴尬了。 题目大意就是给定一棵树，每个点初始权值是0，维护两个操作，一是将和某一个点距离不超过d的点的权值都加上v，二是查询某两个点之间的权值。 首先用点分治建出新的树结构，利用标记永久化的思想为每个点建立一棵线段树记录距离这个点距离为d的点的权值之和，统计的时候再求一下和即可。 唯一
[点分树] BZOJ 4372: 烁烁的游戏
Vectorxj的博客
12-07 1123
DescriptionDescription给定一颗nn个节点的树，边权均为11，初始树上没有皮皮鼠。 烁烁他每次会跳到一个节点uu，把周围与他距离不超过dd的节点各吸引出ww只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。 烁烁很好奇，在当前时刻，节点uu有多少个他的好朋友—皮皮鼠。 大意： 给一颗nn个节点的树，边权均为11，初始点权均为00，mm次操作： Q xQ~x：询问x
[BZOJ4372]烁烁的游戏
abcyan1235的博客
01-13 107
题面戳我 题意： 给一颗n个节点的树，边权均为1，初始点权均为0，m次操作： Q x：询问x的点权。 M x d w：将树上与节点x距离不超过d的节点的点权均加上w。 \(1≤n≤10^5\) sol 和前一题是一样的[BZOJ3730]震波 这里是线段树的区间修改+单点查询。标记永久化就很舒服（不用pushup和pushdown） code #include<cstdio>...
wangjunrui666#bzoj-problem##2319. 黑白棋游戏1
07-25
第一行一个数N 第二行N个数，第i个数表示第i个01序列中黑棋的个数 第三行N个数，第i个数表示第i个01序列中白棋的个数
wangjunrui666#bzoj-problem##3255. 一个关于序列的游戏1
07-25
第一行一个整数N，表示序列长度 第二行N个数，V1、V2VN，代表每个长度对应的分数 第三行N个数，A1、A2AN，代表初始序列的每个元素
BZOJ第一部分
11-03
在学习和使用BZOJ的过程中，有几个关键知识点是必须要掌握的： 1. **基础编程语言**：BZOJ支持C、C++、Java、Python等多种编程语言，理解每种语言的基本语法和特性是必不可少的。 2. **数据结构**：数组、链表、栈...
BZOJ泡泡堂题解.doc
09-29
### BZOJ1034 题解分析 #### 题目概述 题目编号为BZOJ1034的问题，通过一种独特的贪心算法进行解答。本题涉及两个队伍之间的对抗，每个队伍都有自己的实力排序。目标是最大化己方得分。 #### 解题思路与核心代码...
bzoj 4372（点分树+动态开点线段树
weixin_45539557的博客
04-15 131
bzoj 4372（点分树+动态开点线段树 题意： 1.将树上与节点x距离不超过d的节点加上w 2.单点询问 思路： 多次与某点相关的连通块问题，点分树套路题 每个点建两颗权值线段树，一个维护自己分治区域中对应距离的标记，一个维护自己对父亲分治区域对应距离的标记，计算的时候容斥一下就好了，非常套路 #include<bits/stdc++.h> #define ls lc[p] #define rs rc[p] #define lson lc[p],l,mid #define rson rc[
BZOJ4372: 烁烁的游戏
12-23 110
BZOJ4372: 烁烁的游戏 https://lydsy.com/JudgeOnline/problem.php?id=4372 分析: 不是很难想的一道题，用树状数组维护点分树上每一层分治中心的点分序即可。 代码: #include <cstdio> #include <cstring> #include <algorithm> #includ...
【BZOJ4372】烁烁的游戏（动态点分治）
小蒟蒻yyb的博客
01-13 419
题面BZOJ 大意： 每次在一棵书上进行操作 1.将离某个点u的距离不超过d的点的权值加上w 2.询问单点权值题解这题和前面那一道震波几乎是一模一样的 只不过把两个操作的区间问题给换了一下 现在是区间修改，单点询问而已#include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #include<cmath
[BZOJ4372][动态树分治(点分树)][动态开点线段树]烁烁的游戏
CE玩家
02-28 800
题意给一颗n个节点的树，边权均为1，初始点权均为0，m次操作： Q x：询问x的点权 M x d w：将树上与节点x距离不超过d的节点的点权均加上wdfs出点分树每个重心要记录这个重心以下的子点分树的修改信息，可以用区间覆盖单店查询的线段树维护，因为会有重复的部分，每个重心还要再开一棵线段树记录重复的部分#include <cstdio> #include <iostream> #include
[bzoj4372]烁烁的游戏
jerome_wei的博客
10-15 190
[bzoj4372]烁烁的游戏 动态点分，需要注意的是我们对于每个点要开两个数组，另外一个相当于一个容斥，即把他父亲上的减掉。 代码 #include&lt;bits/stdc++.h&gt; using namespace std; const int N=2e5+5,inf=1e9; char getopt(){ char x=0;while(x&lt;'A'||x&gt;'Z')...
【BZOJ4372】烁烁的游戏（动态点分治）（树状数组）
zxyoi_dreamer的博客（不定期诈尸）
09-27 171
传送门 题解： 建立点分树，每个分治中心开一个树状数组，表示它对所有到它距离为ttt的点的贡献 每次修改直接暴跳分治树父亲修改，发现父子分治中心会对一些点有重复贡献，每个儿子开一个树状表示它的连通块内距离父亲不超过ttt的点被重复贡献了多少。 询问暴跳点分树查每一个分治中心的树状数组即可。 代码： #include<bits/stdc++.h> #define ll long lo...
【bzoj4372】 烁烁的游戏【动态树分治】
2016gdgzoi471
12-20 1477
烁烁的游戏 Description 背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。 题意： 给定一颗n个节点的树，边权均为1，初始树上没有皮皮鼠。 烁烁他每次会跳到一个节点u，把周围与他距离不超过d的节点各吸引出w只皮皮鼠。皮皮鼠会被烁烁吸引，所以会一直待在节点上不动。 烁烁很好奇，在当前时刻，节点u有多少个他的好朋友—皮皮鼠。 大意： 给一颗n个节点的树，边权均为1，初始点权均...
bzoj 4372: 烁烁的游戏 （动态点分治+线段树+LCA）
clover_hxy的博客
06-05 1084
题目描述传送门题目大意：给一颗n个节点的树，边权均为1，初始点权均为0，m次操作： Q x：询问x的点权。 M x d w：将树上与节点x距离不超过d的节点的点权均加上w题解对于每个点开一棵线段树，线段树中维护到这个点距离为x的所有增量。 修改一个点的时候需要修改这个点到点分树的根路径上所有点的答案。 查询的时候也是一样。代码#include<iostream> #include<cstdi
bzoj.org俄罗斯方块
最新发布
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。...bzoj.org俄罗斯方块不仅仅是一款游戏，更是一个很好的算法练习平台，你可以通过该游戏来学习和研究游戏算法问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hexrt

客官，请不要给我小费！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值