[Wc2010]重建计划 （二分 + 长链剖分 + 线段树）

于 2021-03-01 22:16:19 发布
阅读量175 收藏
点赞数 1
分类专栏： 树 二分/倍增 线段树 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43960414/article/details/114268487
版权
树 同时被 3 个专栏收录
57 篇文章 0 订阅
订阅专栏
线段树
53 篇文章 0 订阅
订阅专栏
二分/倍增
20 篇文章 0 订阅
订阅专栏

题面

在这里插入图片描述

Input

第一行包含一个正整数N，表示X国的城市个数. 第二行包含两个正整数L和U，表示政策要求的第一期重建方案中修建道路数的上下限 接下来的N-1行描述重建小组的原有方案，每行三个正整数Ai,Bi,Vi分别表示道路(Ai,Bi),其价值为Vi 其中城市由1…N进行标号

Output

输出最大平均估值，保留三位小数

Sample Input

4
2 3
1 2 1
1 3 2
1 4 3

Sample Output

2.500

Hint

N<=100000,1<=L<=U<=N-1,Vi<=1000000

Source

BZOJ1758 【Wc2010】重建计划

题解

首先我们可以想到一个 O ( n 2 log ⁡ n ) O(n^2\log n) O(n2logn) 的树形DP做法：

  • 先用0/1分数规划二分答案，把每条边权减去答案，找边权和大于等于 0 的路径。
  • 然后 d p i , j dp_{i,j} dpi,j​ 表示 i i i 点向下延伸的一条长为 j j j 的链的最大边权和，合并儿子时判断是否存在合法的路径，计算完后再判断一下 i i i 向下延伸是否存在合法路。
  • 把 d p i , j dp_{i,j} dpi,j​ 抽象成 i i i 子树内距离 i i i 为 j j j 的点，那么最多就是每两个点在 l c a lca lca 处产生一次合法判断，且每个点都要算自己所有DP值，证明复杂度是 O ( n 2 ) O(n^2) O(n2) 的。
  • 总复杂度算上二分 O ( n 2 log ⁡ n ) O(n^2\log n) O(n2logn) 。

这个做法是可以优化的，因为我们发现，遍历到第一个儿子的时候，原先的 “ d p i , ⋯ dp_{i,\cdots} dpi,⋯​” 并没有值，因此可以直接从第一个儿子处承接过来（说继承不太好），我们只要安排一个儿子先 d  ⁣ f  ⁣ s d\!f\!s dfs ，然后承接过来，再和其他儿子暴力合并就能优化。

但是如果重链剖分的话，可能每次合并儿子时还要新扩展一些值，且复杂度得不到保证（因为笔者证不出来 😕）。

所以我们可以用长链剖分，用线段树维护每条长链的DP值的最大值，方便判断合法路径，转移时是单点修改，继承承接时则是整条链的区间加和一个单点修改。

为了不写懒标记（好调试，代码短），优化线段树单点查询的复杂度到 O ( 1 ) O(1) O(1) （无懒标记的zkw线段树单点查询和全局查询都是 O ( 1 ) O(1) O(1) 的），可以在每条链顶存一个全局加的标记（我们一般叫它 t a g tag tag）。

长链剖分下，除了长儿子以外的儿子在合并过来时，最长的链都不会比长儿子长，就不会访问到没计算过的DP值，只会访问到 短链长度 个DP值，由于其他儿子都是一条长链的链顶，所以相当于每条长链都只会在承接的过程中被构造一次，在链顶被遍历一次，复杂度就为 O ( 总 链 长 ⋅ log ⁡ n ) O(总链长\cdot\log n) O(总链长⋅logn) ，即 O ( n log ⁡ n ) O(n\log n) O(nlogn) 。

总复杂度算上二分 O ( n log ⁡ 2 n ) O(n\log^2 n) O(nlog2n) 。

CODE

#include<map>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 100005
#define LL long long
#define ULL unsigned long long
#define DB double
#define ENDL putchar('\n')
#define eps 1e-5
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s == '-')f=-f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
const int MOD = 1000000007;
int n,m,i,j,s,o,k,L,U;
DB tre[MAXN<<2];
int M;
void maketree(int n) {
	M=1;while(M<n+2)M<<=1;
	for(int i = 1;i < (M<<1);i ++) tre[i] = -1e13;
}
void addtree(int x,DB y) {
	int s = M+x;tre[s] = y;s >>= 1;
	while(s) tre[s] = max(tre[s<<1],tre[s<<1|1]),s >>= 1;
}
DB findtree(int l,int r) {
	if(l > r) return -1e13;
	int s = M+l-1,t = M+r+1; DB as = -1e13;
	while(s || t) {
		if((s>>1) ^ (t>>1)) {
			if(!(s&1)) as = max(as,tre[s^1]);
			if(t & 1) as = max(as,tre[t^1]);
		}else break;
		s >>= 1;t >>= 1;
	}return as;
}
struct it{
	int v,w; it(){v=w=0;}
	it(int V,int W){v=V;w=W;}
};
vector<it> g[MAXN];
int d[MAXN],len[MAXN],se[MAXN],son[MAXN],tp[MAXN],ll[MAXN],rr[MAXN],tim;
DB lz[MAXN];
void dfs0(int x,int fa) {//d[],len[],son[],se[]
	d[x] = d[fa] + 1;
	len[x] = 1; son[x] = 0;
	for(int i = 0;i < (int)g[x].size();i ++) {
		int y = g[x][i].v;
		if(y != fa) {
			dfs0(y,x);
			if(len[y] > len[son[x]]) son[x] = y,se[x] = g[x][i].w;
			len[x] = max(len[x],len[y]+1);
		}
	}return ;
}
void dfs1(int x,int fa) {//tp[],ll[],rr[]
	if(son[fa] == x) tp[x] = tp[fa];
	else tp[x] = x;
	if(tp[x] == x) {
		ll[x] = tim + 1;
		rr[x] = tim + len[x];
		tim += len[x];
	}
	for(int i = 0;i < (int)g[x].size();i ++) {
		int y = g[x][i].v;
		if(y != fa) {
			dfs1(y,x);
		}
	}return ;
}
bool flag;
DB sub;
void dfs(int x,int fa) {
	int st = ll[tp[x]] + d[x] - d[tp[x]];
	if(!son[x]) {
		addtree(st,-lz[tp[x]]);
		return ;
	}
	dfs(son[x],x);
	lz[tp[x]] += (DB)se[x]-sub;
	addtree(st,-lz[tp[x]]);
	for(int i = 0;i < (int)g[x].size();i ++) {
		int y = g[x][i].v;
		if(y != fa && y != son[x]) {
			dfs(y,x);
			DB ady = (DB)g[x][i].w-sub;
			for(int j = len[y]-1;j >= 0;j --) {
				if(j+1 <= U && j+len[x] >= L) {
					int rd = min(len[x]-1,U-j-1);
					int ld = max(0,L-j-1);
					if(findtree(st+ld,st+rd) + lz[tp[x]] + findtree(ll[y]+j,ll[y]+j) + lz[y] + ady >= 0)
						flag = 1;
				}
			}
			for(int j = len[y]-1;j >= 0;j --) {
				DB nm = findtree(ll[y]+j,ll[y]+j)+lz[y]+ady;
				DB nm2 = findtree(st+j+1,st+j+1)+lz[tp[x]];
				addtree(st+j+1,max(nm,nm2)-lz[tp[x]]);
			}
		}
	}
	if(findtree(st+L,st+min(len[x]-1,U))+lz[tp[x]] >= 0) flag = 1;
	return ;
}
bool check(DB md) {
	maketree(tim);
	flag = 0;sub = md;
	for(int i = 1;i <= n;i ++) lz[i] = 0.0;
	dfs(1,0);
	return flag;
}
int main() {
	n = read();
	L = read();U = read();
	for(int i = 1;i < n;i ++) {
		s = read();o = read();k = read();
		g[s].push_back(it(o,k));
		g[o].push_back(it(s,k));
	}
	dfs0(1,0);
	dfs1(1,0);
	DB l = 0,r = 1000000.0,mid;
	while(r-l >= eps) {
		mid = (l + r) / 2.0;
		if(check(mid)) l = mid;
		else r = mid;
	}
	printf("%.3f\n",l);
	return 0;
}

2021/11/9 Update：精简版代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 100005
#define LL long long
#define DB double
#define ENDL putchar('\n')
#define lowbit(x) (-(x) & (x))
LL read() {
	LL f=1,x=0;int s = getchar();
	while(s < '0' || s > '9') {if(s<0)return -1;if(s=='-')f=-f;s=getchar();}
	while(s >= '0' && s <= '9') {x = (x<<3) + (x<<1) + (s^48);s = getchar();}
	return f * x;
}
int n,m,s,o,k,M,L,R;
DB tre[MAXN<<2];
void maketree(int n) {M=1;while(M<n+2)M<<=1;for(int i=1;i<(M<<1);i++)tre[i]=-1e13;}
void addtree(int x,DB y) {for(int s = M+x;s > 0;s >>= 1) tre[s] = max(tre[s],y);}
DB findtree(int l,int r) {
	DB as = -1e13; if(l > r) return -1e13;
	for(int s = M+l-1,t = M+r+1;(s>>1) != (t>>1);s >>= 1,t >>= 1) {
		if(!(s&1)) as = max(as,tre[s^1]);
		if(t & 1) as = max(as,tre[t^1]);
	}return as;
}
DB FDP(int x) {return tre[M+x];}
int hd[MAXN],v[MAXN<<1],nx[MAXN<<1],cne,w[MAXN<<1];
void ins(int x,int y,int z) {nx[++ cne] = hd[x]; v[cne] = y; hd[x] = cne; w[cne] = z;}
int d[MAXN],le[MAXN],son[MAXN],si[MAXN],dfn[MAXN],tim;
void dfs0(int x,int ff) { // *d , *le , *son , *si , tim
	d[x] = d[ff] + 1; le[x] = 0; son[x] = 0; tim = 0;
	for(int i = hd[x],y = v[i];i;i = nx[i],y = v[i]) 
		if(y != ff) {
			dfs0(y,x);  le[x] = max(le[x],le[y] + 1);
			if(!son[x] || le[y] > le[son[x]]) son[x] = y,si[x] = i;
		}
	return ;
}
void dfs1(int x,int ff) { // *dfn
	dfn[x] = ++ tim;
	if(son[x]) dfs1(son[x],x);
	for(int i = hd[x];i;i = nx[i]) 
		if(v[i] != ff && v[i] != son[x])
			dfs1(v[i],x);
	return ;
}
DB lz[MAXN],w2[MAXN<<1],ans;
void dfs(int x,int ff) { // calculate
	lz[x] = 0;
	if(son[x]) {dfs(son[x],x); lz[x] = lz[son[x]] + w2[si[x]];}
	addtree(dfn[x],-lz[x]);
	ans = max(ans,findtree(dfn[x] + L,dfn[x] + min(R,le[x])) + lz[x]);
	for(int i = hd[x],y = v[i];i;i = nx[i],y = v[i])
		if(y != ff && y != son[x]) {
			dfs(y,x);
			for(int j = dfn[y];j <= dfn[y] + le[y];j ++) {
				int lt = j - dfn[y] + 1;
				DB wt = FDP(j) + lz[y] + w2[i];
				ans = max(ans,wt + findtree(dfn[x] + max(0,L-lt),dfn[x] + min(le[x],R-lt)) + lz[x]);
			}
			for(int j = dfn[y];j <= dfn[y] + le[y];j ++) {
				int lt = j - dfn[y] + 1;
				DB wt = FDP(j) + lz[y] + w2[i];
				addtree(dfn[x] + lt,wt - lz[x]);
			}
		}
	return ;
}
bool check(DB m) {
	for(int i = 1;i <= cne;i ++) w2[i] = (DB)w[i] - m;
	maketree(n); ans = -1e13; dfs(1,0);
	return ans >= 0.0;
}
int main() {
	n = read();L = read();R = read();
	for(int i = 1;i < n;i ++) {
		s = read();o = read();k = read();ins(s,o,k);ins(o,s,k);
	}
	dfs0(1,0); dfs1(1,0);
	DB l = 0,r = 1e6,mid;
	while(l < r-1e-9) {
		mid = (l + r) / 2;
		if(check(mid)) l = mid;
		else r = mid;
	}
	printf("%.3f\n",r);
	return 0;
}
DD(XYX)
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
长链剖分算法完整总结
Gene_I must wait for the sunrise
08-17 1705
长链剖分概述 一、适用问题 涉及深度的树形 DP\text{DP}DP，长链剖分可以将其复杂度从 O(n2)O(n^2)O(n2) 优化到 O(n)O(n)O(n)，基本思想是采用了指针偏移直接从重 (长) 儿子处继承了大量信息。 长链剖分优化树形 DP\text{DP}DP 可以解决的问题与点分治以及树上启发式合并具有一定的重复性。 通常解决的题目只有一次询问，如果有多次询问，需要离线操作。 二...
线段树（合并/分治）&&重/长链剖分&&主席树专题（持续更新中）
苟为蒟蒻又何妨
07-28 3193
常规线段树（简单） 模板 树剖区间取负，单点修改维护最大最小总和 单点修改维护根节点乘积 维护区间连续(0/1)(0/1)(0/1)的长度 根据逆序对数还原排列 双指针+线段树永久化标记 505050多棵线段树动态开点 线段树（树状数组）求逆序对 单点插入区间查询 区间开根区间求和 单点修改区间最大连续和 线段树与算法（简单） 优化dpdpdp 线段树合并 李超线...
2019.01.26-bzoj1758: [Wc2010]重建计划
dengrong849567的博客
01-27 126
题目描述： 算法标签：点分治，二分，分数规划 思路： 考虑二分出答案，于是对于每一个点把他的权值减去二分出的答案的和相加大于0，且长度适宜，则满足。 于是用点分治判断是否存在这样的路径。 以下代码： #include<bits/stdc++.h> #define il inline #define db double #define LL lon...
[bzoj 1758] [Wc2010]重建计划
chrt's blog
04-09 1018
如果莫名地TLE了可以看一看本文. 数据经过加强后, 以前许多AC代码会超时. 新站没被百度收录, 所以在这里复制一份, 希望能帮到您. https://chrt.github.io/2017/04/09/bzoj1758-rebuild/ 一棵n个结点, 边带权的无根树, 求包含[L,U]条边的简单路径的最大平均权值 (权值和/边数), 保留3位小数. (n≤10^5)
bzoj1758 [Wc2010]重建计划
整型的映山红
12-19 256
Description 题面写的晦涩难懂，简单说一下题意，给出一棵树，有边权，找出其中一条包含了不少于 LL ，不多于 RR 条边的路径，使得 Average(v(e))Average(v(e)) 最大，上式表示所有选择的边的平均权值。 Input 第一行包含一个正整数 NN， 表示 XX 国的城市个数. 第二行包含两个正整数 LL 和 UU ，表示政策要求的第一期重建方案中修建道路数的
[Wc2010]重建计划
tomyking2005的博客
01-14 221
                                  [Wc2010]重建计划   Description Input 第一行包含一个正整数N，表示X国的城市个数. 第二行包含两个正整数L和U，表示政策要求的第一期重建方案中修建道路数的上下限 接下来的N-1行描述重建小组的原有方案，每行三个正整数AiBiVi分别表示道路(AiBi)其价值为Vi 其中城市由1..N进行标号...
BZOJ1758 [WC2010]重建计划
Log_x's Blog
06-29 447
Solution 容易想到二分答案 midmidmid，将树上每条边减去 midmidmid，原问题被转化为求树上是否存在一条价值和大于等于 000 的路径，可以用点分治来做。 因为题目对路径长度有限制，记录之前处理的子树中某一长度的路径价值和的最大值。 对重心的每一棵子树 BFSBFSBFS，则按照 BFSBFSBFS 序枚举点，路径的长度递增。 枚举之前处理的子树中的路径长度，则对于当...
【hdu 6634 Salty Fish】【最小割+长链剖分】
beginend
11-16 381
题意 给一棵nnn个节点的有根树，点有点权。有mmm个摄像机，第iii个摄像机会覆盖到以xix_ixi​为根的子树中距离xix_ixi​不超过kik_iki​的点，并且可以用cic_ici​的代价使该摄像机无效。问未被覆盖点权和-总花费的最大值。 n,m≤300000n,m\le300000n,m≤300000 分析 首先可以最小割建图：sss往摄像头连流量为费用的边，摄像头往能覆盖的点连流量为i...
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
路人黑的纸巾
10-18 10000
一篇从浅到深探究一些树上算法的博客
bzoj3252: 攻略（长链剖分+贪心）
苟为蒟蒻又何妨
01-19 288
传送门 长链剖分好题。 题意：给一棵带点权的树，可以从根节点到任一叶节点走kkk次，走过的点只能计算一次，问kkk次走过的点点权值和最大值。 思路： 考虑将整棵树带权长链剖分，这样链与链之间是不会重复选择的。 然后每条链都对应一种方案，我们贪心选择前kkk大即可。 代码： #include&lt;bits/stdc++.h&gt; #define ri register int using na...
[WC2010]重建计划（长链剖分版）
weixin_34302798的博客
04-06 103
传送门 Description Solution 时隔多年，补上了这题的长链剖分写法 感觉比点分治要好写的多 我们假设\(pos\)是当前点的\(dfn\)，它距离所在链的底端的边的数量是\(len\)，距离是\(siz\) 那么我们要求得\(g[pos...pos+len]\) 其中\(g[pos+i]+siz\)表示的是当前点往下长度为\(i\)的最长链的大小 初始情况下，\...
[WC2010]重建计划
StaroForgin的博客
02-16 238
重建计划 题解 看到这道题首先应该是很容易想到0/1分数规划的。毕竟那里明摆着一个∑i=1k−1vali∣S∣\frac{\sum_{i=1}^{k-1}val_{i}}{|S|}∣S∣∑i=1k−1​vali​​。 我们只需要将下面的分母当做111即可，所以当二分到midmidmid时，若midmidmid可呗构造出来，有∑i=1k−1vali∣S∣≥mid⟺∑i=1k−1(vali−mid)≥0\frac{\sum_{i=1}^{k-1}val_{i}}{|S|}\geq mid\Longleftrig
[长链剖分 & 线段树] BZOJ1758[Wc2010] 重建计划
CE玩家
01-02 464
学一发长链剖分 原来以前在ATCODER上做的一题就是这个套路…#include <cstdio> #include <iostream> #include <algorithm>using namespace std;const int N=100010;int n,U,D,cnt,dpt[N],d[N],G[N],son[N],fa[N]; struct edge{ int t,nx;
[WC2010]重建计划(分数规划+点分治+单调队列）
weixin_33797791的博客
12-22 94
题目大意：给定一棵树，求一条长度在L到R的一条路径，使得边权的平均值最大。 题解 树上路径最优化问题，不难想到点分治。 如果没有长度限制，我们可以套上01分数规划的模型，让所有边权减去mid，求一条路径长度非负。 现在考虑有L和R的限制，就是我们在拼接两条路径的时候，每条路径能够匹配的是按深度排序后一段连续区间，我们只需要维护区间最大值。 然后随着深度的单调变化，这个区间在滑动，这就变成...
Bzoj1758: [Wc2010]重建计划
Cyhlnj
02-25 329
题面 传送门 Sol 题意就是给你一棵树，有边权 求边数在[L,U][L,U][L, U]内的一条路径，使得边权和除以边数最大，输出这个最大值 二分答案+点分治+单调队列 二分一个答案midmidmid，把所有的边权减去这个midmidmid就是checkcheckcheck是否有一条边数满足要求的大于等于零的路径 bfsbfsbfs求出当前每个点到根的disdisdis和d...
【BZOJ1758】【WC2010】重建计划
cz_xuyixuan的博客
01-18 429
【题目链接】点击打开链接【思路要点】首先，题目要求求解平均值的最大值，考虑分数规划。二分答案\(Mid\)，将树上每条边权减去\(Mid\)，问题变为树上是否存在边数在\(L\)到\(R\)之间的权值之和非负的路径。考虑点分治。记录\(Dist\)数组，\(Dist_{i}\)表示边数为\(i\)的从分治根节点出发的路径的最大权值。对于每一个分治子树进行BFS，记当前BFS深度为\(i\)，在\(
bzoj 1758: [Wc2010]重建计划
lqybzx的专栏
05-18 1066
Description Input 第一行包含一个正整数N，表示X国的城市个数. 第二行包含两个正整数L和U，表示政策要求的第一期重建方案中修建道路数的上下限 接下来的N-1行描述重建小组的原有方案，每行三个正整数Ai,Bi,Vi分别表示道路(Ai,Bi),其价值为Vi 其中城市由1..N进行标号 Output 输出最大平均估值，保留三位小数 Sample Input
1758: [Wc2010]重建计划
wamach的博客
08-15 271
#pragma GCC optimize("O2") #include #include #include #include using namespace std; #define rep(i,j,k) for(i=j;i<=k;++i) #define per(i,j,k) for(i=j;i>=k;--i) #define sqr(x) ((x)*(x)) #define G getchar
叶诗富教练详解树形动态规划： longest chain问题与应用
"树形动规初探-叶诗富.pptx"是由金牌教练叶诗富在WC2015期间分享的讲义，主要探讨了树形动态规划这一重要概念及其应用。动态规划是一种在优化问题中寻找最优解的方法，特别适用于具有重叠子问题和最优子结构的问题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值