HDU-5044、洛谷P3995 Tree 树上差分 好题

最新推荐文章于 2021-08-17 22:30:15 发布
最新推荐文章于 2021-08-17 22:30:15 发布
阅读量312 收藏 3
点赞数 1
分类专栏： ACM入门 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52383696/article/details/114294948
版权

HDU-5044 Tree 树上差分 好题

树上差分 运用 普通差分思想，在树上用一个数组模拟差分，能实现 区间修改 （边和点都可以）和 单点查询 操作，能比线段树快。
既然是模拟一维差分，实现的原理，就是在线段头部+1，线段尾部-1；这样能实现 O(1) 修改， O(n) 查询的功能。

先讲点权的区间修改：
比如 让 点u 到 v 之间路径上所有点+1，想象以 u-v 路径上深度最小的点（即最近公共祖先 lca ) 把线段分成两段，这样一条线段就分成了两个线段，这两个线段分别处于左子树和右子树；那么只需要让tree[u]+=1，tree[v]+=1，同时让tree[ lca(u,v) ] - = 1,
tree[ fa[ lca(u,v) ] ] - = 1;学过差分的同学应该容易想象，一个结点其子树包含自身的tree[ ]值和即为当前结点修改后的最终值，可以用dfs遍历的方式实现。

ll lca(ll x,ll y){
	while(top[x]!=top[y]){
		if(dep[top[x]]>dep[top[y]])swap(x,y);
		y=fa[top[y]];
	}
	if(dep[x]>dep[y])swap(x,y);
	return x;
}
void update1(ll x,ll y,ll k){
	tree1[x]+=k;tree1[y]+=k;
	tree1[lca(x,y)]-=k;
	tree1[fa[lca(x,y)]]-=k; 
} 
void sum1(ll x,ll pre){
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		sum1(z[i].e,x);
		tree1[x]+=tree1[z[i].e];
	}
}

再讲边权的区间修改：
这里的处理方式采用了，把边权下放给点权的方式，统一把边权给 这条边连接的两个点中 深度较大的点。
这样在差分的时候，只要令tree[ u ]+=1，tree[ v ]+=1;同时让
tree[ lca(u,v) ] - = 2；不难想象，在一次修改中，让 u-v 这条链上除了 lca 的所有点+1；结合点权的实际意义，lca 的值代表连接 lca 与其父亲这条边的边权，是不包含在 u-v 链中的。如此看来上面的操作正好实现了这个功能。

ll lca(ll x,ll y){
	while(top[x]!=top[y]){
		if(dep[top[x]]>dep[top[y]])swap(x,y);
		y=fa[top[y]];
	}
	if(dep[x]>dep[y])swap(x,y);
	return x;
}
void update2(ll x,ll y,ll k){
	tree2[x]+=k;tree2[y]+=k;
	tree2[lca(x,y)]-=2*k;
}
void sum2(ll x,ll pre){
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		sum2(z[i].e,x);
		tree2[x]+=tree2[z[i].e];
	}
}

这里给出例题 HDU-5044 是一道需要用树上差分同时维护 点权和边权的题目。题目大致意思是，有两种操作：1.令 u-v 链上所有结点的权值 +k； 2.令 u-v 链上所有边的权值 +k;

这里给出我的AC代码：

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
#include <iostream>
#pragma comment(linker, "/STACK:102400000,102400000")//此处采用手动扩栈，不然会T 呜呜呜~ 
using namespace std;
#define ll long long
#define pb push_back
#define rep(i,j,k) for(ll i=j;i<=k;i++)
#define per(i,j,k) for(ll i=j;i>=k;i--)
const ll mod=998244353;
const ll maxn=1e6+10;
ll qp(ll x,ll y){
	ll ans=1;
	while(y){
		if(y%2)ans=ans*x%mod;x=x*x%mod;y/=2;}return ans;}
inline ll qread(){
    ll s=0,w=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')w=-1;
    for (;ch>='0'&&ch<='9';ch=getchar())s=(s<<1)+(s<<3)+(ch^48);
    return (w==-1?-s:s);}

struct node{
	ll s,e,next;
}z[2*maxn];

ll n,m,len,cnt,num=1;
ll w[maxn],son[maxn],top[maxn],fa[maxn],dep[maxn],siz[maxn];
ll tree1[maxn],tree2[maxn],head[maxn];
void add(ll a,ll b){
	z[len].s=a;z[len].e=b;z[len].next=head[a];head[a]=len++;
}
void dfs1(ll x,ll pre){
	fa[x]=pre;dep[x]=dep[pre]+1;son[x]=0;
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		dfs1(z[i].e,x);
		siz[x]+=siz[z[i].e];
		if(siz[z[i].e]>=siz[son[x]])son[x]=z[i].e;
	}
}
void dfs2(ll x,ll pre){
	if(son[pre]==x)top[x]=top[pre];
	else top[x]=x;
	if(son[x])dfs2(son[x],x);
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		if(z[i].e==son[x])continue;
		dfs2(z[i].e,x);
	}
}
ll lca(ll x,ll y){
	while(top[x]!=top[y]){
		if(dep[top[x]]>dep[top[y]])swap(x,y);
		y=fa[top[y]];
	}
	if(dep[x]>dep[y])swap(x,y);
	return x;
}
void update1(ll x,ll y,ll k){
	tree1[x]+=k;tree1[y]+=k;
	tree1[lca(x,y)]-=k;
	tree1[fa[lca(x,y)]]-=k; 
} 
void update2(ll x,ll y,ll k){
	tree2[x]+=k;tree2[y]+=k;
	tree2[lca(x,y)]-=2*k;
}
void sum1(ll x,ll pre){
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		sum1(z[i].e,x);
		tree1[x]+=tree1[z[i].e];
	}
}
void sum2(ll x,ll pre){
	for(int i=head[x];i!=-1;i=z[i].next){
		if(z[i].e==pre)continue;
		sum2(z[i].e,x);
		tree2[x]+=tree2[z[i].e];
	}
}
int main(){
	ll t;
	scanf("%lld",&t);
	while(t--){
		printf("Case #%lld:\n",num++);
		len=0,cnt=0;
		scanf("%lld%lld",&n,&m);
		memset(head,-1,sizeof(head));
		rep(i,1,n-1){
			ll a,b;
			scanf("%lld%lld",&a,&b); 
			add(a,b);add(b,a);
			siz[i]=1;
		}
		siz[n]=1;
		dfs1(1,0);
		dfs2(1,0);
		memset(tree1,0,sizeof(tree1));
		memset(tree2,0,sizeof(tree2));
		rep(i,1,m){
			char op[10];
			scanf("%s",op);
			ll a,b,c;
			scanf("%lld%lld%lld",&a,&b,&c);
			if(op[3]=='1'){
				update1(a,b,c);
			}else{
				update2(a,b,c);
			} 
		}
		sum1(1,0);sum2(1,0);
		rep(i,1,n-1)printf("%lld ",tree1[i]);
		printf("%lld\n",tree1[n]);
		for(int i=0;i<len-2;i+=2){
			ll a=z[i].e;ll b=z[i].s;
			if(dep[a]>dep[b])swap(a,b);
			printf("%lld ",tree2[b]);
		}
		if(len!=0){
			ll a=z[len-2].e,b=z[len-2].s;
			if(dep[a]>dep[b])swap(a,b);
			printf("%lld",tree2[b]);
		}
		printf("\n");
	}
    return 0;
}

我的代码 4020ms 卡过的…亲测，这道题用线段树会T到死，然后开个手动扩栈，尽量少用数组初始化，然后这道题还卡了输出格式…很坑就对了0.0

洛谷P3995 树链剖分（伪模板）

简单讲解下题意， 已知 普通的树链剖分是以子树节点的个数为依据（即 siz【】）划分一个节点的中儿子与重链，题目会给出 1e5 个节点与 2e5 个询问，我们需要以一个新的法则来划分重链，使得对于所有询问的 从节点U到节点V的路径中轻链和重链的总数和 sum 最小。

这道题的第一想法就是贪心，令所有询问中，经过边数最多的边作为一条重链边。那么问题就转化为了找节点U到节点V之间的路径，以及使路径中所有的节点权值加1。这个功能怎么实现呢，找两点间的路径，我选择使用树链剖分的 top 数组来找到两点的LCA；至于区间修改嘛，我用的是树上差分，感觉用线段树可以的~~吧。
但是直接的树链剖分只能得82分，亲测。问题出在区间修改上。首先我们维护的是边权:
正常操作是：

	tree1[x]++,tree1[y]++,tree1[lca]-=2;

但是如果fa【U】||fa【V】==LCA；那么这条边不论是不是重链，都只会经过一次，那么就可以不用操作，避免影响最优解；

同时在最后一次dfs中，判断条件要变为： <=

	if(tree1[son[x]]<=tree1[t])son[x]=t;

如果用<那么，就有可能出现 非叶子节点没有重儿子的情况；

附上代码：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define ll long long
#define rep(i,j,k) for(ll i=j;i<=k;i++)
#define per(i,j,k) for(ll i=j;i>=k;i--)
const ll mod=1e9+7;
const ll maxn=1e6+5;
ll qp(ll x,ll y){
	ll ans=1;
	if(y<0)return 0;
	while(y){
		if(y%2)ans=ans*x%mod;x=x*x%mod;y/=2;}return ans;}
inline ll qread(){
    ll s=0,w=1;char ch=getchar();
    for(;!isdigit(ch);ch=getchar())if(ch=='-')w=-1;
    for (;ch>='0'&&ch<='9';ch=getchar())s=(s<<1)+(s<<3)+(ch^48);
    return (w==-1?-s:s);}

ll n,m,len=0;
ll siz[maxn],dep[maxn],fa[maxn],top[maxn]={0},son[maxn]={0};
ll head[maxn];
ll tree1[maxn]={0};
struct node{
	ll s,e,next;
}z[maxn];
void add(ll a,ll b){
	z[len].s=a;z[len].e=b;z[len].next=head[a];head[a]=len++;
}
void dfs1(ll x,ll pre){
	fa[x]=pre;dep[x]=dep[pre]+1;tree1[x]=0;
	son[x]=0; 
	for(int i=head[x];i!=-1;i=z[i].next){
		ll t=z[i].e;
		if(t==pre)continue;
		dfs1(t,x);
		siz[x]+=siz[t];
		if(siz[t]>siz[son[x]])son[x]=t;
	}
}
void dfs2(ll x,ll pre){
	if(son[pre]==x)top[x]=top[pre];
	else top[x]=x;
	if(son[x])dfs2(son[x],x);
	for(int i=head[x];i!=-1;i=z[i].next){
		ll t=z[i].e;
		if(t==pre)continue;
		if(t==son[x])continue;
		dfs2(t,x);
	}
}
ll lca(ll x,ll y){
	while(top[x]!=top[y]){
		if(dep[top[x]]>dep[top[y]])swap(x,y);
		y=fa[top[y]];
	}
	if(dep[x]>dep[y])swap(x,y);
	return x;
}
void update1(ll x,ll y){
	ll w=lca(x,y);
	if(fa[x]!=w)tree1[x]++,tree1[w]--;
	if(fa[y]!=w)tree1[y]++,tree1[w]--;
}
void sum1(ll x,ll pre){
	son[x]=0;
	for(int i=head[x];i!=-1;i=z[i].next){
		ll t=z[i].e;
		if(t==pre)continue;
		sum1(t,x);
		tree1[x]+=tree1[t];
		if(tree1[son[x]]<=tree1[t])son[x]=t;
	}
}
int main(){
	n=qread(),m=qread();
	memset(head,-1,sizeof(head));
	rep(i,1,n-1){
		ll a,b;
		scanf("%lld%lld",&a,&b); 
		add(a,b);add(b,a);
		siz[i]=1;
	}
	siz[n]=1;
	dfs1(1,0);dfs2(1,0);
	for(int i=1;i<=m;i++){
		ll a=qread(),b=qread();
		update1(a,b);
	}
	sum1(1,0);
	for(int i=1;i<=n;i++){
		printf("%lld\n",son[i]);
	}
	return 0;
}

我试过用vector存边，但是只能拿82分，但是用链式前向星就100 了，这里存疑。
对于链式前向星和vector的区别，我也不是很明白，之前做到过一道题目，用 vector 就是会T，但是链式前向星就过了，吸取教训，以后都用链式前向星存边吧。

dplovetree
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
树上差分（LUOGU3128）
Free Loop~~~跳动的音符
05-25 151
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int inf = 0x3f3f3f3f; const int mod = 1e8; const int Max = 5e4 + 10; const int Max2 = 5e3 + 10; struct Edge{ int to, next; }edge[Max<<1]; int n, k; int head[Max], tot;
「洛谷1600」「NOIP2016提高组」天天爱跑步【树上差分】
chhokmah的博客
05-02 246
闲话 为了理清这道题目的思路，我是边写博客边做题的，qwq。 题目链接 洛谷 题解 首先对变量进行声明 dep[i] 表示i号节点的深度，是到根节点的深度 w[i] 表示i号观测点观测的时间 dfn[i] 表示i号点的dfn序 sz[i] 表示i号点的子树大小 以上图为例，蓝色点表示一个玩家的起点和终点。 不妨先假设左边的点是起点，右边的点是终点，分别用sss和ttt来表示 那...
洛谷：P3258树上点差分
yangzijiangac的博客
01-20 253
题目链接 题解： 难点在于根据访问顺序推出差分方式，前置知识：LCA+树上点差分 AC代码： #include<bits/stdc++.h> using namespace std ; const int maxn=3e5+5; struct node { int to,nex; } tr[maxn*4]; int pre[maxn][32],depth[maxn],he...
洛谷P3258 [JLOI2014]松鼠的新家 树上差分
j45454545的博客
08-17 161
https://www.luogu.com.cn/problem/P3258 题目大意：给定一棵树，给n-1个起点与终点，路径上经过的点都需要加1。 树上差分_点差分模板题 点差分 点差分时，俩点之间lca与其父-权值 俩点加权值。 边差分时，俩点加权值，lca-2*权值。 因为每个儿子都只有一个父亲所以边差分时对应的点为父亲->儿子。 最后权值计算应自底向上。 #include <bits/stdc++.h> using namespace std; t..
专题·树上差分【including 例题：洛谷·bzoj·最大流Max Flow， 洛谷· [JLOI2014]松鼠的新家
樱狸✨愿携清风归来处
05-28 318
初见安~本专题/题解 是有前置知识的哦：LCA 树上差分——顾名思义就是把差分运用到树上。【啪！ 本来差分是相邻作差，可以用于求数轴上被线段覆盖的最大层数。求解时可以在线段的左短点和右端点+1处标记+1和-1。 树上差分也是同样的道理，我们可以先看一个例题来讲解： 传送门：洛谷P3128 题目描述 Farmer John has installed a new system ofN-...
hdu-page-11-answer.rar_hdu_hdu oj第十一页_page_搜题_杭电oj
09-14
对于初学者来说，首先要了解基础数据结构，如数组、链表、栈、队列、树、图等，以及基本的搜索和排序算法，如二分查找、冒泡排序、快速排序等。这些知识是解决ACM问题的基础。 二、杭电OJ系统介绍 杭电OJ是在线进行...
HDU-2000-2099.rar_hdu
09-19
这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些题目涵盖了初级到高级的各种算法，对于学习和提升编程技能非常有帮助。 首先，我们来看看这些题目可能涉及到的基础知识...
HDU-2000-2099.zip_hdu2000
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU-ACM_java.rar_hdu
09-22
【标题】"HDU-ACM_java.rar" 是一个针对杭州电子科技大学（HDU）ACM竞赛的资源压缩包，其中包含的是使用Java语言编写的算法解决方案。这个压缩包主要面向那些参与或准备参与ACM国际大学生程序设计竞赛（ICPC）的参赛...
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
【洛谷P3128】Max Flow【LCA 树上差分】
绫
05-22 97
linklinklink 分析： 看到标题MaxMaxMax FlowFlowFlow 还以为是网络流最大流 统计每个点经过几次 就是路径上每个点+1+1+1 这样就可以用树上差分 (x,y)(x,y)(x,y)之间点全部+1+1+1 相当于(x,LCA)(x,LCA)(x,LCA) (LCA,y)(LCA,y)(LCA,y)上的点全部+1+1+1 最后遍历整棵树 统计 CODE： #include<iostream> #include<cstdio> #include<a..
【学术篇】树上差分--洛谷3128最大流Max Flow
weixin_30687051的博客
01-25 119
懒得贴题目，直接放不稳定的传送门（雾）：点击前往暴风城（雾） 据说这题是BZOJ3490，但本蒟蒻没有权限╮(╯_╰)╭ 这题似乎就是裸树上差分。。。 对于树上(x,y)之间的路径上的点区间c[i]加k<==>c[x]+=k,c[y]+=k,c[lca(x,y)]-=k,c[father[lca(x,y)]-=k 就是这样，虽然这题我因为各种智障的原因在luogu上交了3遍，为...
HDU5044--Tree（树链剖分）
SCUT_Pein
09-27 943
Problem Description You are given a tree (an acyclic undirected connected graph) with N nodes. The tree nodes are numbered from 1 to N There are N - 1 edges numbered from 1 to N - 1. Each nod
HDU 5044
老李2009
09-28 540
● ADD1 u v k: for nodes on the path from u to v, the value of these nodes increase by k. ● ADD2 u v k: for edges on the path from u to v, the value of these edges increase by k.
树上差分习题
weixin_43145397的博客
04-08 312
重点 树上差分判定：树上区间加，点查询。（和线性差分一样） 1. 松鼠的新家 注意： 第一个dfs求fa[i][j]和depth[i]，注意写法。(无需处理root节点的fa[root][0]) fa[to][0] = now,赋值之后再dfs。 #include <iostream> #include <cstdio> #include <cstdlib>...
Luogu-2680 (二分答案+树上差分)
hehepig的博客
09-11 625
题目 题目背景 公元 2044 年,人类进入了宇宙纪元。 题目描述 L 国有 n 个星球,还有 n-1 条双向航道,每条航道建立在两个星球之间,这 n-1 条航道连通了 L 国的所有星球。 小 P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物 流飞船需要从 ui 号星球沿最快的宇航
树上差分详解
热门推荐
a1351937368的博客
10-31 1万+
树上差分Max Flow NKOJ3605给定一棵有N个点的树，所有节点的权值初始时都为0。 有K次操作，每次指定两个点s,t，将s到t路径上所有点的权值都+1。 请输出K次操作完毕后权值最大的那个点的权值。 2≤N≤50,000 1≤K≤100,000对于每一次修改s,t，将s,t的权+1; 将LCA(s,t)和father[LCA(s,t)]的权-1
POJ - 3417 Network 【树上差分 + LCA + 思维】 好题!
Anxdada -- 我等风来也等你
07-31 454
传送门 题意: 先给一棵具有n个节点的树, 然后再给出m条边, 问从树上删去一条边, 再从m条边中删去一条边, 把这个图分成至少两部分的方案数. 思路 我们知道再树上每加一条边树上一定有环, 假设我们将在环上的树边的累加标记都加一, 表示被一条m中的边所覆盖, 然后我们在分析, 对于一颗树我们删去任意一条边, 树一定会被分成两部分, 那么如果被删去的边的累加标记&gt;=...
ACM LCA 倍增 模板 HDU 5044
nickwong & nickwang
09-27 1352
LCA 倍增模板O(N*log N),N为点数 最近公共祖先
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值