bzoj2051. A Problem For Fun 【动态点分治】+【动态开点权值线段树】

于 2021-08-29 13:42:10 发布
阅读量148 收藏 1
点赞数
分类专栏： 动态点分治 题解 二分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45754027/article/details/119911229
版权

动态点分治 树结构 距离查询 权值线段树 二分查找
关键词由CSDN通过智能技术生成
题解 同时被 3 个专栏收录
36 篇文章 0 订阅
订阅专栏
二分
6 篇文章 0 订阅
订阅专栏
动态点分治
4 篇文章 0 订阅
订阅专栏

传送门
给出一个 N N N个结点的树，每条边有一个正整数权值，定义两个结点的距离为连接这两个结点路径上边权的和。对于每个结点 i i i，它到其他 N − 1 N-1 N−1个结点都有一个距离，将这些距离从小到大排序，输出第 K K K个距离。
三倍经验
bzoj2117. [2010国家集训队]Crash的旅游计划
bzoj4317. Atm的树
（后面有这两题的代码）

分析

  1. 对于某个点到其它的点的所有距离可以通过，动态点分治来进行查询
  2. 对于第 K K K大，通常通过数据结构维护，或者直接暴力二分

动态点分治

这里有篇介绍【动态淀粉质】的详解，可以看一下思想
对于每个点，我们需要存储当前节点管辖的区间，该节点到所有点的距离
维护这个距离，且维护的数据能够在 l o g log log左右的时间复杂度内查询类似于第 K K K大或者比 x x x大的个数的操作，支持这种操作的可以用【数组(vector)】【权值线段树】【平衡树】等
注意，数组来写或许会更方便。这里采用权值线段树维护(动态开点)，主要是练习一下使用动态开点。

对于当前区间维护的所有点的距离维护好了，我们查询的时候是往上跳父节点，这里需要简单去重容斥一下。
因为：我们在父节点找数据的时候，会囊括当前节点管辖的区间，需要去重（消去当前节点已经计算过的对父节点的影响）。

二分答案

在动态点分治完成后，对于每一个节点，对第 K K K大进行二分
假设当前二分的答案为 x x x
我们在动态点分树上进行查找，所有小于等于 x x x的距离个数，记为 c n t cnt cnt
如果 c n t > = K cnt>=K cnt>=K说明正确的答案更小，反之同理

代码

//bz2051 
/*
  @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 = 2e6+5;
const ll MOD = 1e9+7;
int N, M, K;

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

int mk() {
	return ++indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

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

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

int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt, w;
}edge[MAX_N];

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

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

void dfs1(int u, int from, int k) {
	parent[u] = from;
	len[u] = k;
	sz[u] = 1;
	son[u] = 0;
	dep[u] = dep[from] + 1;
	
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u, k + edge[i].w);
		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 len[x] + len[y] - 2 * len[lca];
}

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

void dfs(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;
		dfs(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 A[MAX_N];
int B[MAX_N];
int range[MAX_N];

void get_ra(int rt, int u, int from, int w) {
	range[rt] = max(range[rt], w);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		get_ra(rt, v, u, w + edge[i].w);
	}
}

void divide(int u, int sum) {
	range[u] = 0;
	get_ra(u, u, 0, 0);
	vis[u] = 1;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if (vis[v=edge[i].to]) continue;
		int rt = 0;
		dfs(v, u, rt, sz[v]);
		father[rt] = u;
		divide(rt, sz[v]);
	}
}

int count(int x, int limit) {
	int res = 0, pre = 0, d = 0;
	for (int i = x; i; pre = i, i = father[i]) {
		if ((d = dis(x, i)) > limit) continue;
		res += query(A[i], 1, range[i] + 1, 1, limit - d + 1);
		if (pre) res -= query(B[pre], 1, range[i] + 1, 1, limit - d + 1);
	}
	return res;
}

void modify(int x) {
	int d;
	for (int i = x; i; i = father[i]) {
		update(A[i], 1, range[i] + 1, dis(x, i) + 1);
		if (father[i]) update(B[i], 1, range[father[i]] + 1, dis(x, father[i]) + 1);
	}
}

int calc(int x) {
	int l = 0, r = 1e9, mid = 0, ans = 0;
	while (l <= r) {
		mid = l + ((r-l)>>1);
		if (count(x, mid) >= K) {
			ans = mid;
			r = mid - 1;
		} else {
			l = mid + 1;
		}
	}
	return ans;
}

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

int arr[MAX_N];

void solve(){
	init();
	sc("%d%d", &N, &K);
	int u, v, w;
	
	for (int i = 1; i < N; ++i) {
		sc("%d%d%d", &u, &v, &w);
		addEdge(u, v, w);
	}
	
	dfs1(1, 0, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[rt] = 1e10;
	dfs(1, 0, rt, N);
	divide(rt, N);
	
	for (int i = 1; i <= N; ++i) {
		modify(i);
	}
	
	++K;
	
	for (int i = 1; i <= N; ++i) {
		pr("%d\n", calc(i));
	}
}

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

	return AC;
}

bzoj2117 [2010国家集训队]Crash的旅游计划

//bz2051 
/*
  @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 = 2e6+5;
const ll MOD = 1e9+7;
int N, M, K;

struct Tr {
	int k, l, r;
}tr[MAX_N*30];
int indx = 0;

int mk() {
	if (indx > (MAX_N*30) - 10) {
		pr("%d", indx);
		exit(0);
	}
	return ++indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

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

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

int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt, w;
}edge[MAX_N];

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

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

void dfs1(int u, int from, int k) {
	parent[u] = from;
	len[u] = k;
	sz[u] = 1;
	son[u] = 0;
	dep[u] = dep[from] + 1;
	
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u, k + edge[i].w);
		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 len[x] + len[y] - 2 * len[lca];
}

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

void dfs(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;
		dfs(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 A[MAX_N];
int B[MAX_N];
int range[MAX_N];

void get_ra(int rt, int u, int from, int w) {
	range[rt] = max(range[rt], w);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		get_ra(rt, v, u, w + edge[i].w);
	}
}

void divide(int u, int sum) {
	range[u] = 0;
	get_ra(u, u, 0, 0);
	vis[u] = 1;
	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[u] > sz[v] ? sz[v] : sum - sz[u];
		dfs(v, u, rt, vsz);
		father[rt] = u;
		divide(rt, vsz);
	}
}

int count(int x, int limit) {
	int res = 0, pre = 0, d = 0;
	for (int i = x; i; pre = i, i = father[i]) {
		if ((d = dis(x, i)) > limit) continue;
		res += query(A[i], 1, range[i] + 1, 1, limit - d + 1);
		if (pre) res -= query(B[pre], 1, range[i] + 1, 1, limit - d + 1);
	}
	return res;
}

void modify(int x) {
	int d;
	for (int i = x; i; i = father[i]) {
		update(A[i], 1, range[i] + 1, dis(x, i) + 1);
		if (father[i]) update(B[i], 1, range[father[i]] + 1, dis(x, father[i]) + 1);
	}
}

int calc(int x) {
	int l = 0, r = 1e9, mid = 0, ans = 0;
	while (l <= r) {
		mid = l + ((r-l)>>1);
		if (count(x, mid) >= K) {
			ans = mid;
			r = mid - 1;
		} else {
			l = mid + 1;
		}
	}
	return ans;
}

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

int arr[MAX_N];

void solve(){
	init();
	getchar();
	sc("%d%d", &N, &K);
	int u, v, w;
	
	for (int i = 1; i < N; ++i) {
		sc("%d%d%d", &u, &v, &w);
		addEdge(u, v, w);
	}
	
	dfs1(1, 0, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[rt] = 1e9;
	dfs(1, 0, rt, N);
	divide(rt, N);
	
	for (int i = 1; i <= N; ++i) {
		modify(i);
	}
	
	++K;
	
	for (int i = 1; i <= N; ++i) {
		pr("%d\n", calc(i));
	}
}

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

	return AC;
}

bzoj4317Atm的树

//bz2051 
/*
  @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 = 2e6+5;
const ll MOD = 1e9+7;
int N, M, K;

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

int mk() {
	return ++indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

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

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

int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt, w;
}edge[MAX_N];

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

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

void dfs1(int u, int from, int k) {
	parent[u] = from;
	len[u] = k;
	sz[u] = 1;
	son[u] = 0;
	dep[u] = dep[from] + 1;
	
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u, k + edge[i].w);
		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 len[x] + len[y] - 2 * len[lca];
}

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

void dfs(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;
		dfs(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 A[MAX_N];
int B[MAX_N];
int range[MAX_N];

void get_ra(int rt, int u, int from, int w) {
	range[rt] = max(range[rt], w);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		get_ra(rt, v, u, w + edge[i].w);
	}
}

void divide(int u, int sum) {
	range[u] = 0;
	get_ra(u, u, 0, 0);
	vis[u] = 1;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if (vis[v=edge[i].to]) continue;
		int rt = 0;
		dfs(v, u, rt, sz[v]);
		father[rt] = u;
		divide(rt, sz[v]);
	}
}

int count(int x, int limit) {
	int res = 0, pre = 0, d = 0;
	for (int i = x; i; pre = i, i = father[i]) {
		if ((d = dis(x, i)) > limit) continue;
		res += query(A[i], 1, range[i] + 1, 1, limit - d + 1);
		if (pre) res -= query(B[pre], 1, range[i] + 1, 1, limit - d + 1);
	}
	return res;
}

void modify(int x) {
	int d;
	for (int i = x; i; i = father[i]) {
		update(A[i], 1, range[i] + 1, dis(x, i) + 1);
		if (father[i]) update(B[i], 1, range[father[i]] + 1, dis(x, father[i]) + 1);
	}
}

int calc(int x) {
	int l = 0, r = 1e9, mid = 0, ans = 0;
	while (l <= r) {
		mid = l + ((r-l)>>1);
		if (count(x, mid) >= K) {
			ans = mid;
			r = mid - 1;
		} else {
			l = mid + 1;
		}
	}
	return ans;
}

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

int arr[MAX_N];

void solve(){
	init();
	sc("%d%d", &N, &K);
	int u, v, w;
	
	for (int i = 1; i < N; ++i) {
		sc("%d%d%d", &u, &v, &w);
		addEdge(u, v, w);
	}
	
	dfs1(1, 0, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[rt] = 1e9;
	dfs(1, 0, rt, N);
	divide(rt, N);
	
	for (int i = 1; i <= N; ++i) {
		modify(i);
	}
	
	++K;
	
	for (int i = 1; i <= N; ++i) {
		pr("%d\n", calc(i));
	}
}

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

	return AC;
}
Hexrt
关注
专栏目录
[点分树][二分] [BZOJ4317]Atm的树 && [BZOJ2117][2010国家集训队]Crash的旅游计划 &&[BZOJ2051]A Problem For Fun
CE玩家
03-14 908
题意求一棵树上，以每个点为起点的第k短路径双倍经验对于每一个点，二分答案，那么只要判断与当前点距离小于等于二分出来的答案的点的个数是否等于k就行了复杂度nlog^3n，数据点应该不多……表示树上倍增常数太大了……#include <cstdio> #include <iostream> #include <algorithm> #include <vector> #include <queue> #
bzoj4372 烁烁的游戏（点分治+线段树）
Icefox的博客
07-14 1763
无限CE…一丝丝怀疑人生qaq 考虑点分树维护这个东西。每个节点x开一颗线段树，每个叶子节点i记录距离x距离为i的点加了多少。每次修改/询问在点分树上跳父亲就好了。然后还要容斥一下多加的部分，因此需要每个点再开一颗线段树表示到fa[x]距离为i的要减掉多少。 可以吧前缀加单点询问变成单点加后缀询问，这样节点可以少一些。 复杂度O(nlog2n)O(nlog2n)O(nlog^2n) 空间应...
BZOJ1095 动态点分治(点分树)
weixin_30486037的博客
09-16 179
题意： 操作1.修改一个点的颜色（黑白互换） 操作2.询问所有黑色点之间最远距离 点分树：当我们可以形如点分治一样的统计答案，即每次确定一个重心，然后计算他们子树之间的贡献和得出答案的时候 我们可以将每个区域的重心作为其所有子树的重心的父亲，构成一颗新的树，显然这棵树的深度不会超过logn 每次对于单点（边）更新的时候，只要对其所有的父亲更新，就只需要更新log个点，这样...
BZOJ2051 : A Problem For Fun
weixin_33785972的博客
10-09 94
树的点分治，将点分治的过程记录下来，每一个分治结构按到分治中心的距离维护所有点。 对于一个点二分答案，然后在$O(\log n)$个分治结构中二分查找，时间复杂度$O(n\log^3n)$。   #include&lt;cstdio&gt; #include&lt;algorithm&gt; const int N=50010,M=1000010; int n,m,i,x,y,z,...
BZOJ4012【动态点分治】
Lethelody的专栏
05-02 802
/* I will wait for you*/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define make make_pair #define fi
BZOJ1095 [ZJOI2007]捉迷藏 动态点分治
liuguangzhe
04-11 3733
每次修改一个点的黑白状态，询问树上最远黑点距离 拿这个题做动态点分治模板题：（%%%PoPoQQQ大爷） 点分治的过程是对树块找重心之后分成多个小树块，降低规模分别处理的过程，把链的信息收到其中“最高重心”上，从所有的重心处像分治中的不同子树索取到重心的链，就可以覆盖所有链的信息。动态点分治就像把序列分治变成线段树一样，在分治的架子上加了信息维护，实现树链信息维护与查询。 需要什么？ 每个
BZOJ3730: 震波【动态点分治】
Master.Yi的博客
03-03 263
题目描述： 在一片土地上有N个城市，通过N-1条无向边互相连接，形成一棵树的结构，相邻两个城市的距离为1，其中第i个城市的价值为value[i]。 接下来你需要在线处理M次操作： 0 x k 表示发生了一次地震，震中城市为x，影响范围为k，所有与x距离不超过k的城市都将受到影响，该次地震造成的经济损失为所有受影响城市的价值和。 1 x y 表示第x个城市的价值变成了y。 为了体现程序的在线性，操作...
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献...
[BZOJ3339]Rmq Problem（离线+线段树）
zyf2000
04-27 1044
膝盖还在发抖，如同十二岁时的我 从教室后门偷溜出去 我不在乎被责备两次 等待对我这种人来说是浪费时间
BZOJ 4311: 向量（线段树分治+凸包+三分）
Ab.Ever
11-05 583
Description你要维护一个向量集合，支持以下操作： 1.插入一个向量(x,y) 2.删除插入的第i个向量 3.查询当前集合与(x,y)点积的最大值是多少。如果当前是空集输出0Input第一行输入一个整数n，表示操作个数 接下来n行，每行先是一个整数t表示类型，如果t=1，输入向量 (x,y)；如果t=2，输入id表示删除第id个向量；否则输入(x,y)，查询 与向量(x,y)点积
BZOJ 4372: 烁烁的游戏(动态点分治)
albertluf的博客
08-12 276
4372: 烁烁的游戏 Time Limit: 30 Sec  Memory Limit: 512 MB Submit: 804  Solved: 288 [Submit][Status][Discuss] Description 背景：烁烁很喜欢爬树，这吓坏了树上的皮皮鼠。 题意： 给定一颗n个节点的树，边权均为1，初始树上没有皮皮鼠。 烁烁他每次会跳到一个节点u，把周围与他距离不超过d的...
动态点分治:bzoj 3730,bzoj 1095
yfzcsc的博客
02-17 462
总结一下动态点分治的模板。。。 对于一个树，把它点分的同时记录每个点的所有父亲（logn个）并记录点距其父亲的距离。 具体实现就是dfs的时候fa[x][++dep[x]]=u,dis[x][dep[x]]=d; BZOJ1095: 您需要写一个程序支持反转点的颜色，求距离最远的黑色点对的距离。 解析：在每个点u存一个堆st记录该子树（分治中的）中点到fa[u]的距离再存一个堆son
bzoj-2051 A Problem For Fun
140142
11-26 1405
题意： 给出一棵n个结点的树，边上有权值； 对于每个点求离它第k小的距离； n 题解： 正解似乎是树分治维护距离，然后二分答案啥的，时间复杂度O(nlog^3)； 但是如果想不到树分治怎么办呢？那么就来写一个逗比做法吧！ 考虑从一个点转移到另外一个点，这个转移过程对于一些点是增加这条边的权值，另一些是减少这条边的权值； 而投影到DFS序上，就是对于子树区间的加减修改； 从
bzoj 4012. [HNOI2015]开店（动态点分治）
qq_41997978的博客
02-21 142
先考虑在点分树上如何处理一个弱化的问题：查询其它点到 uuu 点的距离之和。 在点分树上每个节点维护子树到它的距离和，为了方便向上合并其他节点的贡献，再维护每个节点到其父亲节点的距离和，每到一个父亲减一下就得到除这棵子树外其它点到父亲节点的距离和，再加上其到父亲节点的这条边的贡献即可。 维护三个数组：suma[v],sumb[v],siz[v]suma[v],sumb[v],siz[v]sum...
bzoj4012(动态点分治+卡常数)
running_in_dark的博客
02-08 611
这是一种类型的动态点分治   动态点分治，关键还是要在均摊n的空间复杂度内存下所有东西。这个就要充分利用stl，比如vector 每一个点存以这个点为根点分治的信息。   对于询问一个点的路径时，就是沿着点分治树，不断朝fa走，每走一层统计一下，因为分治树可以保证在log层内，时间复杂度同阶     #include #include #include #include #incl
BZOJ1095 & 动态点分治（好像应该叫点分树？）学习笔记
QWsin的博客
04-18 3782
神一般的点分治
【BZOJ4317】Atm的树
cz_xuyixuan的博客
05-21 319
【题目链接】点击打开链接【思路要点】补档博客，无题解。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; #define MAXN 100005 template &lt;typename T&gt; void read(T &amp;x) { x = 0; int f = 1; char c = getchar(); for (; ...
【BZOJ2051】A Problem For Fun
CreationAugust is 14 years old forever
10-10 1986
Description 给出一个N个结点的树，每条边有一个正整数权值，定义两个结点的距离为连接这两个结点路径上边权的和。对于每个结点i，它到其他N-1个结点都有一个距离，将这些距离从小到大排序，输出第K个距离。 Input 输入文件总共N行。第一行有两个正整数N和K。下面N-1行每行描述树的一条边（保证这些边可以构成一棵树），每行三个正整数u、v、w，表示从结点u到结点v有一条权值为w的边。输
[BZOJ4012][HNOI2015]开店（动态点分治）
女装的你，如此好看！
04-01 451
题目大意就是：一个 nnn 个节点的树，边和点都带权。每次询问点权在 [L,R][L,R][L,R] 范围内的所有点到 uuu 的距离之和，强制在线。 （注意下面所说的「父亲」「子节点」「子树」「祖先」等概念都是在分治树上的） 考虑动态点分治时对于每个点 uuu ，储存 uuu 的子树内所有点到 uuu 的父亲的距离。 但这样显然还不能满足我们的要求，因为我们每次查询的是点权在 [L,R][...
树形动态规划详解：二叉苹果树问题与策略
"树形动态规划是一种特殊的动态规划方法，主要应用于解决在树状结构上具有最优子结构的问题，包括计数问题、存在性问题和某些最优性问题。该PDF文件深入讲解了树形动态规划的基础概念、递归关系及其实现策略。 在树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hexrt

客官，请不要给我小费！

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

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

打赏作者

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

抵扣说明：

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

余额充值