bzoj 4539: [Hnoi2016]树

最新推荐文章于 2019-03-25 18:27:44 发布
最新推荐文章于 2019-03-25 18:27:44 发布
阅读量666 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heheda_is_an_OIer/article/details/51285930
版权
开始读错题了，以后一定要好好读题！！！
称原来给的大小为n的树为模板树，最后得到的树为答案树，把一次操作增加的节点看成一块，然后构成的树称为大树。
答案树上两点的距离=两点分别走到所在块的根，在大树上走到两个块的lca，撤销进入块lca后两个点共同走过的路径。
第一步的答案就是找到点到它所在块的根在原树中的距离
第二步，把大树上两点之间的边权定义为答案树上这两个块的根的距离，然后倍增lca求出
第三步，要知道两个点进入lca后具体是走到模板树上的哪个点，分别设为x,y，然后答案减去2*(lca(x,y)在模板树中的深度-lca块的根在模板树中的深度)
然后把需要维护的东西维护出来就好。
写错的地方：
1.大树中的节点个数是m+1，不是n
2.第三步减去的不是lca(x,y)的深度，而是到所在块的根的距离。 
   
   

    
    

     
     #include<cstdio>
    
    

    
    

     
     #include<cstdlib>
    
    

    
    

     
     #include<cstring>
    
    

    
    

     
     #include<algorithm>
    
    

    
    

     
      
    
    

    
    

     
     #define ll long long
    
    

    
    

     
     #define inf 1e9
    
    

    
    

     
     #define eps 1e-8
    
    

    
    

     
     #define md
    
    

    
    

     
     #define N 100010
    
    

    
    

     
     using namespace std;
    
    

    
    

     
     //kai long long
    
    

    
    

     
     struct yts { int x,t,l,ne;};
    
    

    
    

     
     struct Tr { int l,r,sz;};
    
    

    
    

     
     int n,B[N],C[N],K;
    
    

    
    

     
     ll A[N];
    
    

    
    

     
     struct Mu
    
    

    
    

     
     {
    
    

    
    

     
     	int left[N],q[N],sz[N],right[N],v[N],fa[N][20],dep[N],root[N];
    
    

    
    

     
     	yts e[2*N];
    
    

    
    

     
     	Tr tr[20*N];
    
    

    
    

     
     	int dfs_cnt,cnt,num;
    
    

    
    

     
     	
    
    

    
    

     
     	void put(int x,int y)
    
    

    
    

     
     	{
    
    

    
    

     
     		num++; e[num].x=x; e[num].t=y;
    
    

    
    

     
     		e[num].ne=v[x]; v[x]=num;
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	void dfs(int x)
    
    

    
    

     
     	{
    
    

    
    

     
     		left[x]=++dfs_cnt; q[dfs_cnt]=x; sz[x]=1;
    
    

    
    

     
     		for (int i=v[x];i;i=e[i].ne)
    
    

    
    

     
     		{
    
    

    
    

     
     			int y=e[i].t;
    
    

    
    

     
     			if (y!=fa[x][0])
    
    

    
    

     
     			{
    
    

    
    

     
     				dep[y]=dep[x]+1; fa[y][0]=x;
    
    

    
    

     
     				dfs(y);
    
    

    
    

     
     				sz[x]+=sz[y];
    
    

    
    

     
     			}
    
    

    
    

     
     		}
    
    

    
    

     
     		right[x]=dfs_cnt;
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	void insert(int &i,int pre,int l,int r,int x)
    
    

    
    

     
     	{
    
    

    
    

     
     		i=++cnt; tr[i].sz=tr[pre].sz+1; tr[i].l=tr[pre].l; tr[i].r=tr[pre].r;
    
    

    
    

     
     		if (l==r) return;
    
    

    
    

     
     		int mid=(l+r)>>1;
    
    

    
    

     
     		if (x<=mid) insert(tr[i].l,tr[pre].l,l,mid,x);
    
    

    
    

     
     		  else insert(tr[i].r,tr[pre].r,mid+1,r,x);
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	int query(int L,int R,int l,int r,int k)
    
    

    
    

     
     	{
    
    

    
    

     
     		if (l==r) return l;
    
    

    
    

     
     		int mid=(l+r)>>1,sz=tr[tr[R].l].sz-tr[tr[L].l].sz;
    
    

    
    

     
     		if (sz>=k) return query(tr[L].l,tr[R].l,l,mid,k);
    
    

    
    

     
     		else return query(tr[L].r,tr[R].r,mid+1,r,k-sz);
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	void build()
    
    

    
    

     
     	{
    
    

    
    

     
     		for (int j=1;j<=18;j++)
    
    

    
    

     
     		  for (int i=1;i<=n;i++)
    
    

    
    

     
     		    fa[i][j]=fa[fa[i][j-1]][j-1];
    
    

    
    

     
     		for (int i=1;i<=n;i++) insert(root[i],root[i-1],1,n,q[i]);	
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	int lca(int x,int y)
    
    

    
    

     
     	{
    
    

    
    

     
     		if (dep[x]<dep[y]) swap(x,y);
    
    

    
    

     
     		int t=dep[x]-dep[y];
    
    

    
    

     
     		for (int i=18;i>=0;i--)
    
    

    
    

     
     		  if (t&(1<<i)) x=fa[x][i];
    
    

    
    

     
     		if (x==y) return dep[x];
    
    

    
    

     
     		for (int i=18;i>=0;i--)
    
    

    
    

     
     		  if (fa[x][i]!=fa[y][i])
    
    

    
    

     
     		    x=fa[x][i],y=fa[y][i];
    
    

    
    

     
     		return dep[x]-1;
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	int get_point(ll x,int pos)
    
    

    
    

     
     	{
    
    

    
    

     
     		x=x-A[pos]+1;
    
    

    
    

     
     		return query(root[left[B[pos]]-1],root[right[B[pos]]],1,n,x);
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	int dis_to_root(int pos,ll x)
    
    

    
    

     
     	{
    
    

    
    

     
     		x=get_point(x,pos);
    
    

    
    

     
     		return dep[x]-dep[B[pos]];
    
    

    
    

     
     	}
    
    

    
    

     
     } mu;
    
    

    
    

     
      
    
    

    
    

     
     struct Big
    
    

    
    

     
     {
    
    

    
    

     
     	yts e[2*N];
    
    

    
    

     
     	int dep[N],pr[N][20],fa[N][20]; ll dis[N][20];
    
    

    
    

     
     	int v[N],num;
    
    

    
    

     
     	
    
    

    
    

     
     	void put(int x,int y,int l)
    
    

    
    

     
     	{
    
    

    
    

     
     		num++; e[num].x=x; e[num].t=y; e[num].l=l;
    
    

    
    

     
     		e[num].ne=v[x]; v[x]=num;
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	void dfs(int x)
    
    

    
    

     
     	{
    
    

    
    

     
     		pr[x][0]=C[x];
    
    

    
    

     
     		for (int i=v[x];i;i=e[i].ne)
    
    

    
    

     
     		{
    
    

    
    

     
     			int y=e[i].t;
    
    

    
    

     
     			if (y!=fa[x][0])
    
    

    
    

     
     			{
    
    

    
    

     
     				dep[y]=dep[x]+1; fa[y][0]=x; dis[y][0]=e[i].l;
    
    

    
    

     
     				dfs(y);
    
    

    
    

     
     			}
    
    

    
    

     
     		}
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	void build()
    
    

    
    

     
     	{
    
    

    
    

     
     		for (int j=1;j<=18;j++)
    
    

    
    

     
     		  for (int i=1;i<=K;i++)
    
    

    
    

     
     		    if (fa[i][j-1])
    
    

    
    

     
     		      fa[i][j]=fa[fa[i][j-1]][j-1],dis[i][j]=dis[i][j-1]+dis[fa[i][j-1]][j-1],pr[i][j]=pr[fa[i][j-1]][j-1];
    
    

    
    

     
     	}
    
    

    
    

     
     	
    
    

    
    

     
     	ll lca(int x,int y,int &px,int &py,int &lca)
    
    

    
    

     
     	{
    
    

    
    

     
     		ll ans=0;
    
    

    
    

     
     		if (dep[x]>dep[y])
    
    

    
    

     
     		{
    
    

    
    

     
     			int t=dep[x]-dep[y];
    
    

    
    

     
     			for (int i=18;i>=0;i--)
    
    

    
    

     
     			  if (t&(1<<i)) { px=pr[x][i]; ans+=dis[x][i]; x=fa[x][i];}
    
    

    
    

     
     		}
    
    

    
    

     
     		else
    
    

    
    

     
     		{
    
    

    
    

     
     			int t=dep[y]-dep[x];
    
    

    
    

     
     			for (int i=18;i>=0;i--)
    
    

    
    

     
     			  if (t&(1<<i)) { py=pr[y][i]; ans+=dis[y][i]; y=fa[y][i];}
    
    

    
    

     
     		}
    
    

    
    

     
     		if (x==y) { lca=B[x]; return ans;}
    
    

    
    

     
     		for (int i=18;i>=0;i--)
    
    

    
    

     
     		  if (fa[x][i]!=fa[y][i])
    
    

    
    

     
     		  {
    
    

    
    

     
     		  	px=pr[x][i]; py=pr[y][i];
    
    

    
    

     
     		  	ans+=dis[x][i]; ans+=dis[y][i];
    
    

    
    

     
     		  	x=fa[x][i]; y=fa[y][i];
    
    

    
    

     
     		  }
    
    

    
    

     
     		px=pr[x][0]; py=pr[y][0]; lca=B[fa[x][0]];
    
    

    
    

     
     		return ans+dis[x][0]+dis[y][0];
    
    

    
    

     
     	}
    
    

    
    

     
     } big;
    
    

    
    

     
     	
    
    

    
    

     
     int find(ll x)
    
    

    
    

     
     {
    
    

    
    

     
     	int l=1,r=K;
    
    

    
    

     
     	while (l!=r)
    
    

    
    

     
     	{
    
    

    
    

     
     		int mid=(l+r+1)>>1;
    
    

    
    

     
     		if (A[mid]<=x) l=mid; else r=mid-1;
    
    

    
    

     
     	}
    
    

    
    

     
     	return l;
    
    

    
    

     
     }
    
    

    
    

     
      
    
    

    
    

     
     int main()
    
    

    
    

     
     {
    
    

    
    

     
     	//freopen("data.in","r",stdin); freopen("data.out","w",stdout);
    
    

    
    

     
     	int m,Q;
    
    

    
    

     
     	scanf("%d%d%d",&n,&m,&Q);
    
    

    
    

     
     	for (int i=1;i<n;i++)
    
    

    
    

     
     	{
    
    

    
    

     
     		int x,y;
    
    

    
    

     
     		scanf("%d%d",&x,&y);
    
    

    
    

     
     		mu.put(x,y); mu.put(y,x);
    
    

    
    

     
     	}
    
    

    
    

     
     	mu.dfs(1); mu.build();
    
    

    
    

     
     	A[1]=1; B[1]=1; C[1]=0;
    
    

    
    

     
     	ll S=n; K=1;
    
    

    
    

     
     	for (int i=1;i<=m;i++)
    
    

    
    

     
     	{
    
    

    
    

     
     		ll x,y;
    
    

    
    

     
     		scanf("%lld%lld",&x,&y); int pos=find(y);
    
    

    
    

     
     		K++; A[K]=S+1; B[K]=x; C[K]=mu.get_point(y,pos);
    
    

    
    

     
     		big.put(pos,K,mu.dis_to_root(pos,y)+1);
    
    

    
    

     
     		S+=mu.sz[x];
    
    

    
    

     
     	}
    
    

    
    

     
     	big.dfs(1); big.build();
    
    

    
    

     
     	for (int i=1;i<=Q;i++)
    
    

    
    

     
     	{
    
    

    
    

     
     		ll x,y;
    
    

    
    

     
     		scanf("%lld%lld",&x,&y);
    
    

    
    

     
     		int posx=find(x),posy=find(y);
    
    

    
    

     
     		int prex=mu.get_point(x,posx),prey=mu.get_point(y,posy),lca;
    
    

    
    

     
     		ll ans=mu.dis_to_root(posx,x)+mu.dis_to_root(posy,y);
    
    

    
    

     
     		ans+=big.lca(posx,posy,prex,prey,lca);
    
    

    
    

     
     		ans-=(mu.lca(prex,prey)-mu.dep[lca])*2;
    
    

    
    

     
     		printf("%lld\n",ans); 
    
    

    
    

     
     	}
    
    

    
    

     
     	return 0;
    
    

    
    

     
     }
heheda_is_an_OIer
关注
BZOJ4540: [Hnoi2016]序列 （线段树）
DZYO的博客
03-04 383
传送门 题解： 这道题的线段树做法好神啊。。 考虑直接从111扫描到nnn，不断更新1~i1~i1\text{~}i到iii的最小值。 那么显然我们要对线段树支持区间覆盖， 区间求历史和。 然后我们可以构造矩阵来完成，对于每个节点构造⎛⎝⎜⎜svallen⎞⎠⎟⎟(svallen)\begin{pmatrix} s \\ val\\ len \end{pmatrix} 即可完成区间覆盖...
BZOJ 1997: [Hnoi2010]Planar|2-SAT|二分图染色
ws_yzy的博客
01-07 975
一道比较奇怪的题 用二分图染色和2-SAT都可以建模 想了一下为什么 二分图染色是找出矛盾的关系连边 2-SAT是找出“必须”的关系连边 而此题恰好都满足 -------------------------------------------------- 2-SAT做法： 一组边a,b在环构成的圆内相交 那么在圆外的a‘,b'也相交 ”必须“关系有 a-->b'   a'-->
bzoj4539: [Hnoi2016]树
weixin_30474613的博客
04-20 98
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=4539 思路：首先把大树缩点，一个点代表一次操作复制的子树 两个点之间的边权值就是两个子树的根在大树中的距离，这个可以在原树中用倍增求出 至于从大树标号转成原树标号，就相当于求子树内编号第k大的点的编号，用可持久化线段树即可。 询问的话，就先把两个点移到对应复制操作的子树的根，...
BZOJ4539: [Hnoi2016]树 (倍增)
DZYO的博客
02-28 272
传送门 题解: 一开始看错题了以为可以拷贝新加的点的，仔细一看是一道倍增裸题。 首先建一颗虚树，只存拷贝的根节点。 注意到询问两点最后肯定是到某个虚树的节点内部求lcalcalca。那么直接在虚树上倍增到同一个节点再在原树上倍增到lcalcalca即可。 时间复杂度O(nlogn)O(nlog⁡n)O(n \log n)。 注意还要求的是一个子树中第kkk大的节点是哪一个，这个直接用df...
bzoj 4539: [Hnoi2016]树（缩点+主席树+lca）
clover_hxy的博客
08-04 528
4539: [Hnoi2016]树 Time Limit: 40 Sec  Memory Limit: 256 MB Submit: 442  Solved: 173 [Submit][Status][Discuss] Description 　　小A想做一棵很大的树，但是他手上的材料有限，只好用点小技巧了。开始，小A只有一棵结点数为N的树，结 点的编号为1,2,…,N，其中结点1
bzoj4539【HNOI2016】树
AaronPolaris
06-13 1891
树分块+可持久化线段树，思路好
bzoj4541【HNOI2016】矿区
AaronPolaris
06-14 2674
平面图转对偶图+DFS树
BZOJ1009: [HNOI2008]GT考试
MirrorGray的博客
04-12 865
挖坑系列…#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> //by:MirrorGray using namespace std; const int N=22; char s[N]; int mod,m,nxt[N],ret[N][N];int MOD(int x){ while(x>=mo
BZOJ1009 [HNOI2008]GT考试
Monster__Yi的博客
07-17 525
矩阵快速幂+KMP优化dp
[BZOJ4539][Hnoi2016]树（倍增+LCA+主席树）
ADP+Pi==ATP
02-16 1136
这篇题解ATP竟然码了三天。。
bzoj 4539: [Hnoi2016]树 主席树&lca
lych的博客
04-20 1062
首先那个大树是由若干小树组成的，那么把每一颗小树抽象成一个点，这颗大树就变成节点为M+1的树了。同时定义树上相邻点(x,fa[x])的距离为小树x的根到小树fa[x]的根的距离。那么此时查询两个点x,y流程如下：        1.得到x所在小树u，y所在小树v；        2.若u=v，直接查询；否则令w=lca(u,v)（这里的lca为大树中的lca），然后分lca=u(v)和lca!
【BZOJ4539】树（HNOI2016）-主席树+LCA
Maxwei_wzj的OI世界
05-29 276
测试地址：树 做法：本题需要用到主席树+LCA。 要求两点间的距离，显然要维护每个点的深度，以及要求两个点的LCA。 我们把一开始的树看成一块，然后每次操作，都是在某一块下面挂一个新的块，每个块都是模板树的一棵子树。这样我们可以先把块缩成点，那么缩块后整棵大树就变成了一棵更小的树。考虑求一个点的深度，这个深度等于它到它所在块的根的距离，加上块根到整棵树根节点的距离，显然前面的部分可以直接在模...
[BZOJ4539][HNOI2016]树-虚树
「嫌われ者のフィロソフィ」
03-23 194
树Description　　小A想做一棵很大的树，但是他手上的材料有限，只好用点小技巧了。开始，小A只有一棵结点数为N的树，结点的编号为1,2,…,N，其中结点1为根；我们称这颗树为模板树。小A决定通过这棵模板树来构建一颗大树。构建过程如下： 　　 （1）将模板树复制为初始的大树。 （2）以下(2.1)(2.2)(2.3)步循环执行M次 （2.1）选择两个数字a,b，其中1<=a<=N，1<
bzoj4539: [Hnoi2016]树（主席树+倍增）
苟为蒟蒻又何妨
03-25 182
传送门 题意：给一棵大树，令一棵模板树与这棵树相同，然后进行mmm次操作，每次选择模板树中的一个节点aaa和大树中一个节点bbb，把aaa这棵子树接在bbb上面，节点编号顺序跟aaa中的编号顺序相同。 最后有qqq次询问问大树上两点距离。 思路： 真·树套树 把每棵树所成一个点，然后相当于先把两个点跳到一个块中再求它们的lcalcalca，可以用主席树维护块中编号第kkk大来维护块中对应点，实现...
【BZOJ】4539: [Hnoi2016]树-模拟&LCA
远行客
11-29 183
模拟
[BZOJ4539][Hnoi2016]树（dfs序+主席树+lca）
zyf2000
08-05 826
将军有剑，不斩苍蝇。
【BZOJ4539】【Hnoi2016】树 树套树
鲜衣怒马少年郎
04-20 1934
你萌知道一道题从晚八点调到早一点是什么感觉么？ 你萌知道凌晨一点的CQ长什么样子么？ 你萌知道TLE或者WA的情况显示成RE对没有数据的小朋友伤害有多大吗？？？ 我！知！道！ 算了我们来说说Hn的这套题。。。 6道DS。。。 这道是我当时拿道题后第一道yy出标算的题。。。 我也不知道是算树套树还是算分块。。。 主要思想就是把模板树建好之后，每个加入一块树的操作在大树中只加入一个
基于Go语言的疫情物资信息平台服务端设计源码
最新发布
09-25
该项目是一款采用Go语言编写的疫情物资信息平台服务端源码，包含57个文件，其中包括43个Go源文件、4个XML文件、2个Git忽略文件以及其他必要的配置和管理文件。该平台旨在提供疫情物资的实时信息管理和数据交换服务。
BZOJ2839:集合计数(容斥,组合数学)
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合的个数，以此类推，直到加上包含所有特定元素的集合的个数。 对于一个大小为n的集合，其子集的个数为2^n。因此，所有集合的个数为2^n。现在我们考虑如何计算至少包含一个特定元素的集合的个数。我们可以将这个特定元素看作是一个元素，然后考虑其余n-1个元素组成的集合的个数，即2^(n-1)。因此，至少包含一个特定元素的集合的个数为2^(n-1)。同理，至少包含两个特定元素的集合的个数为C(2,n)*2^(n-2)，其中C(2,n)表示从n个元素中选取2个元素的组合数。 将以上结果代入容斥原理的公式中，即可得到最终的计数公式： sum((-1)^k*C(k,n)*2^(n-k),k=0,1,...,n) 其中，sum表示对k从0到n进行求和，C(k,n)表示从n个元素中选取k个元素的组合数，2^(n-k)表示剩余元素组成集合的个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值