[bzoj4817][LCT][线段树]树点涂色

2023-10-16 03:38

本文主要是介绍[bzoj4817][LCT][线段树]树点涂色,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

Description

Bob有一棵n个点的有根树,其中1号点是根节点。Bob在每个点上涂了颜色,并且每个点上的颜色不同。定义一条路
径的权值是:这条路径上的点(包括起点和终点)共有多少种不同的颜色。Bob可能会进行这几种操作: 1 x:
把点x到根节点的路径上所有的点染上一种没有用过的新颜色。 2 x y: 求x到y的路径的权值。 3 x
在以x为根的子树中选择一个点,使得这个点到根节点的路径权值最大,求最大权值。 Bob一共会进行m次操作

Input

第一行两个数n,m。 接下来n-1行,每行两个数a,b,表示a与b之间有一条边。 接下来m行,表示操作,格式见题目描述
1<=n,m<=100000

Output

每当出现2,3操作,输出一行。 如果是2操作,输出一个数表示路径的权值 如果是3操作,输出一个数表示权值的最大值

Sample Input

5 6

1 2

2 3

3 4

3 5

2 4 5

3 3

1 4

2 4 5

1 5

2 4 5

Sample Output

3

4

2

2

题解

我怎么这么菜啊..
没有第三个操作的话可以树剖过的..、
维护每个点到根的答案
先观察第一个操作
发现
这很像LCT的access操作
因为都是把根到某个点的一段路径提取出来
当割断一条重边的时候,我们把重边连接的下端端点子树答案全部减一
连接一条轻边的时候,我们把轻边连接的下端端点子树答案全部加一
每个点的答案其实就是他到根上的轻边数量加一
统计路径答案的时候就是 dep[x]+dep[y]2dep[LCA]1 d e p [ x ] + d e p [ y ] − 2 ∗ d e p [ L C A ] − 1
分LCA是否是一条链的起始端讨论即可得证
写线段树维护就行了..
注意access的时候不能加splay的子树,要加原树的子树
所以先往左找到根再更新

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#define lc now<<1
#define rc now<<1|1
using namespace std;
struct node{int x,y,next;}a[210000];int len,last[110000];
void ins(int x,int y){len++;a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;}
int fa[110000][25],bin[25],dep[110000],ys[110000],tot[110000],z;
void pre_tree_node(int x)
{ys[x]=++z;tot[x]=1;for(int i=1;bin[i]<=dep[x];i++)fa[x][i]=fa[fa[x][i-1]][i-1];for(int k=last[x];k;k=a[k].next){int y=a[k].y;if(y!=fa[x][0]){fa[y][0]=x;dep[y]=dep[x]+1;pre_tree_node(y);tot[x]+=tot[y];}}
}
int lca(int x,int y)
{if(dep[x]<dep[y])swap(x,y);for(int i=20;i>=0;i--)if(bin[i]<=dep[x]&&dep[fa[x][i]]>=dep[y])x=fa[x][i];if(x==y)return x;for(int i=20;i>=0;i--)if(bin[i]<=dep[x]&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];return fa[x][0];
}
int mx[810000],lazy[810000];
void pushup(int now)
{lazy[lc]+=lazy[now];lazy[rc]+=lazy[now];mx[lc]+=lazy[now];mx[rc]+=lazy[now];lazy[now]=0;
}
void ch(int now,int l,int r,int ql,int qr,int c)
{if(l==ql&&r==qr){mx[now]+=c;lazy[now]+=c;return ;}int mid=(l+r)/2;if(lazy[now]!=0)pushup(now);if(qr<=mid)ch(lc,l,mid,ql,qr,c);else if(mid+1<=ql)ch(rc,mid+1,r,ql,qr,c);else ch(lc,l,mid,ql,mid,c),ch(rc,mid+1,r,mid+1,qr,c);mx[now]=max(mx[lc],mx[rc]); 
}
int findmx(int now,int l,int r,int ql,int qr)
{if(qr<=0)return 0;if(l==ql&&r==qr)return mx[now];int mid=(l+r)/2;if(lazy[now]!=0)pushup(now);if(qr<=mid)return findmx(lc,l,mid,ql,qr);else if(mid+1<=ql)return findmx(rc,mid+1,r,ql,qr);else return max(findmx(lc,l,mid,ql,mid),findmx(rc,mid+1,r,mid+1,qr));
}
struct lct
{int son[2],f;
}tr[110000];
void rotate(int x,int w)
{int R,r;int f=tr[x].f,ff=tr[f].f;R=f;r=tr[x].son[w];tr[R].son[1-w]=r;if(r!=0)tr[r].f=R;R=ff;r=x;if(tr[R].son[0]==f)tr[R].son[0]=r;else if(tr[R].son[1]==f)tr[R].son[1]=r;tr[r].f=R;R=x;r=f;tr[R].son[w]=r;tr[r].f=R;
}
void splay(int x,int rt)
{while(tr[x].f!=rt &&(tr[tr[x].f].son[0]==x||tr[tr[x].f].son[1]==x)){int f=tr[x].f,ff=tr[f].f;if(ff==rt||(tr[ff].son[0]!=f&&tr[ff].son[1]!=f)){if(tr[f].son[0]==x)rotate(x,1);else rotate(x,0);}else{if(tr[ff].son[0]==f&&tr[f].son[0]==x)rotate(f,1),rotate(x,1);else if(tr[ff].son[1]==f&&tr[f].son[0]==x)rotate(x,1),rotate(x,0);else if(tr[ff].son[1]==f&&tr[f].son[1]==x)rotate(f,0),rotate(x,0);else rotate(x,0),rotate(x,1);}}
}
int n,m;
int getroot(int x)
{while(tr[x].son[0])x=tr[x].son[0];return x;
}
void access(int x)
{int y=0;while(x!=0){splay(x,0);if(tr[x].son[1]){int gg=getroot(tr[x].son[1]);ch(1,1,n,ys[gg],ys[gg]+tot[gg]-1,1);}tr[x].son[1]=y;if(y!=0){tr[y].f=x;int gg=getroot(y);ch(1,1,n,ys[gg],ys[gg]+tot[gg]-1,-1);}y=x;x=tr[x].f;}
}
int main()
{bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;scanf("%d%d",&n,&m);for(int i=1;i<n;i++){int x,y;scanf("%d%d",&x,&y);ins(x,y);ins(y,x);}pre_tree_node(1);for(int i=1;i<=n;i++)ch(1,1,n,ys[i],ys[i],dep[i]),tr[i].f=fa[i][0];while(m--){int op,u,v;scanf("%d%d",&op,&u);if(op==1)access(u);else if(op==2){scanf("%d",&v);int LA=lca(u,v),s1=findmx(1,1,n,ys[u],ys[u]),s2=findmx(1,1,n,ys[v],ys[v]);int s3=findmx(1,1,n,ys[LA],ys[LA]);printf("%d\n",s1+s2-2*s3+1);}else printf("%d\n",findmx(1,1,n,ys[u],ys[u]+tot[u]-1)+1);}return 0;
}

这篇关于[bzoj4817][LCT][线段树]树点涂色的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/218761

相关文章

poj3468(线段树成段更新模板题)

题意:包括两个操作:1、将[a.b]上的数字加上v;2、查询区间[a,b]上的和 下面的介绍是下解题思路: 首先介绍  lazy-tag思想:用一个变量记录每一个线段树节点的变化值,当这部分线段的一致性被破坏我们就将这个变化值传递给子区间,大大增加了线段树的效率。 比如现在需要对[a,b]区间值进行加c操作,那么就从根节点[1,n]开始调用update函数进行操作,如果刚好执行到一个子节点,

hdu1394(线段树点更新的应用)

题意:求一个序列经过一定的操作得到的序列的最小逆序数 这题会用到逆序数的一个性质,在0到n-1这些数字组成的乱序排列,将第一个数字A移到最后一位,得到的逆序数为res-a+(n-a-1) 知道上面的知识点后,可以用暴力来解 代码如下: #include<iostream>#include<algorithm>#include<cstring>#include<stack>#in

hdu1689(线段树成段更新)

两种操作:1、set区间[a,b]上数字为v;2、查询[ 1 , n ]上的sum 代码如下: #include<iostream>#include<algorithm>#include<cstring>#include<stack>#include<queue>#include<set>#include<map>#include<stdio.h>#include<stdl

hdu 1754 I Hate It(线段树,单点更新,区间最值)

题意是求一个线段中的最大数。 线段树的模板题,试用了一下交大的模板。效率有点略低。 代码: #include <stdio.h>#include <string.h>#define TREE_SIZE (1 << (20))//const int TREE_SIZE = 200000 + 10;int max(int a, int b){return a > b ? a :

hdu 1166 敌兵布阵(树状数组 or 线段树)

题意是求一个线段的和,在线段上可以进行加减的修改。 树状数组的模板题。 代码: #include <stdio.h>#include <string.h>const int maxn = 50000 + 1;int c[maxn];int n;int lowbit(int x){return x & -x;}void add(int x, int num){while

poj 1127 线段相交的判定

题意: 有n根木棍,每根的端点坐标分别是 px, py, qx, qy。 判断每对木棍是否相连,当他们之间有公共点时,就认为他们相连。 并且通过相连的木棍相连的木棍也是相连的。 解析: 线段相交的判定。 首先,模板中的线段相交是不判端点的,所以要加一个端点在直线上的判定; 然后,端点在直线上的判定这个函数是不判定两个端点是同一个端点的情况的,所以要加是否端点相等的判断。 最后

HDU4737线段树

题目大意:给定一系列数,F(i,j)表示对从ai到aj连续求或运算,(i<=j)求F(i,j)<=m的总数。 const int Max_N = 100008 ;int sum[Max_N<<2] , x[Max_N] ;int n , m ;void push_up(int t){sum[t] = sum[t<<1] | sum[t<<1|1] ;}void upd

zoj 1721 判断2条线段(完全)相交

给出起点,终点,与一些障碍线段。 求起点到终点的最短路。 枚举2点的距离,然后最短路。 2点可达条件:没有线段与这2点所构成的线段(完全)相交。 const double eps = 1e-8 ;double add(double x , double y){if(fabs(x+y) < eps*(fabs(x) + fabs(y))) return 0 ;return x + y ;

圆与线段的交点

poj 3819  给出一条线段的两个端点,再给出n个圆,求出这条线段被所有圆覆盖的部分占了整条线段的百分比。 圆与线段的交点 : 向量AB 的参数方程  P = A + t * (B - A)      0<=t<=1 ; 将点带入圆的方程即可。  注意: 有交点 0 <= t <= 1 ; 此题求覆盖的部分。 则 若求得 t  满足 ; double ask(d

Codeforces 482B 线段树

求是否存在这样的n个数; m次操作,每次操作就是三个数 l ,r,val          a[l] & a[l+1] &......&a[r] = val 就是区间l---r上的与的值为val 。 也就是意味着区间[L , R] 每个数要执行 | val 操作  最后判断  a[l] & a[l+1] &......&a[r] 是否= val import ja