洛谷P3703 [SDOI2017]树点涂色

最新推荐文章于 2021-01-26 11:42:26 发布

-斯德哥尔摩-

最新推荐文章于 2021-01-26 11:42:26 发布

阅读量237

点赞数

分类专栏：线段树树链剖分 Link-Cut-Tree动态树

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/yangrui2002/article/details/79532079

版权

线段树同时被 3 个专栏收录

36 篇文章 0 订阅

订阅专栏

树链剖分

19 篇文章 0 订阅

订阅专栏

Link-Cut-Tree动态树

11 篇文章 0 订阅

订阅专栏

题目描述

Bob有一棵 $n$ 个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。

定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。

Bob可能会进行这几种操作：

把点 $x$ 到根节点的路径上所有的点染上一种没有用过的新颜色。

2 x y

求 $x$ 到 $y$ 的路径的权值。

在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。

Bob一共会进行 $m$ 次操作

输入输出格式

输入格式：

第一行两个数 $n, m$ 。

接下来 $n - 1$ 行，每行两个数 $a, b$ ，表示 $a$ 与 $b$ 之间有一条边。

接下来 $m$ 行，表示操作，格式见题目描述

输出格式：

每当出现2,3操作，输出一行。

如果是2操作，输出一个数表示路径的权值

如果是3操作，输出一个数表示权值的最大值

输入输出样例

输入样例#1：

输出样例#1：

说明

共10个测试点

测试点1， $1\leq n,m\leq1000$

测试点2、3，没有2操作

测试点4、5，没有3操作

测试点6，树的生成方式是，对于 $i(2\leq i \leq n)$ ，在1到 $i - 1$ 中随机选一个点作为i的父节点。

测试点7， $1\leq n,m\leq 50000$

测试点8， $1\leq n \leq 50000$

测试点9,10，无特殊限制

对所有数据， $1\leq n \leq 10^5$ ， $1\leq m \leq 10^5$

时间限制：1s

空间限制：128MB

LCT+树链剖分+线段树。。。

首先，按照原树，构建出一个全部都是虚边的 $L C T$ ，并用树剖维护每个点到根节点的路径权值 $v a l$ 。可以发现，每个点到根节点的路径权值就是每个点到根节点的路径上实链的个数。

我们发现，操作 $1$ 实际上就是 $L C T$ 中 $A c c e s s$ 的操作。在 $A c c e s s$ 的操作中，如果一条实边变成虚边，那么将连接这条边的深度较大的节点的子树里所有点的 $v a l$ 加 $1$ （因为实链数量就等于虚边数量 $+ 1$ ），如果一条虚边变成实边，那么将连接这条边的深度较大的节点的子树里所有点的 $v a l$ 减 $1$ 。

这样，询问 $2$ 其实就是求 $v a l [x] + v a l [y] - v a l [l c a (x, y)] * 2 + 1$ 的值，询问 $3$ 就是求 $x$ 的子树最大值。

为了好区分 LCT 与线段树，直接 namespace 封装。。。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#define MAXN 100010
using namespace std;
int n,m,c=1,d=1;
int head[MAXN],deep[MAXN],son[MAXN],size[MAXN],fa[MAXN],id[MAXN],top[MAXN];
int stack[MAXN];
struct node1{
    int next,to;
}a[MAXN<<1];
namespace ST{
    #define LSON rt<<1
    #define RSON rt<<1|1
    #define DATA(x) a[x].data
    #define SIGN(x) a[x].c
    #define LSIDE(x) a[x].l
    #define RSIDE(x) a[x].r
    struct Sg_Tree{
        int data,c,l,r;
    }a[MAXN<<2];
    inline void pushup(int rt){
        DATA(rt)=max(DATA(LSON),DATA(RSON));
    }
    inline void pushdown(int rt){
        if(!SIGN(rt)||LSIDE(rt)==RSIDE(rt))return;
        SIGN(LSON)+=SIGN(rt);DATA(LSON)+=SIGN(rt);
        SIGN(RSON)+=SIGN(rt);DATA(RSON)+=SIGN(rt);
        SIGN(rt)=0;
    }
    void buildtree(int l,int r,int rt){
        int mid;
        LSIDE(rt)=l;
        RSIDE(rt)=r;
        if(l==r){
            DATA(rt)=0;
            return;
        }
        mid=l+r>>1;
        buildtree(l,mid,LSON);
        buildtree(mid+1,r,RSON);
        pushup(rt);
    }
    void update(int l,int r,int c,int rt){
        int mid;
        if(l<=LSIDE(rt)&&RSIDE(rt)<=r){
            SIGN(rt)+=c;DATA(rt)+=c;
            return;
        }
        pushdown(rt);
        mid=LSIDE(rt)+RSIDE(rt)>>1;
        if(l<=mid)update(l,r,c,LSON);
        if(mid<r)update(l,r,c,RSON);
        pushup(rt);
    }
    int query(int l,int r,int rt){
        int mid,ans=0;
        if(l<=LSIDE(rt)&&RSIDE(rt)<=r)return DATA(rt);
        pushdown(rt);
        mid=LSIDE(rt)+RSIDE(rt)>>1;
        if(l<=mid)ans=max(ans,query(l,r,LSON));
        if(mid<r)ans=max(ans,query(l,r,RSON));
        return ans;
    }
}
namespace LCT{
    struct Link_Cut_Tree{
        int son[2];
        int f,s,flag;
    }a[MAXN];
    inline bool isroot(int rt){
        return a[a[rt].f].son[0]!=rt&&a[a[rt].f].son[1]!=rt;
    }
    inline void pushup(int rt){
        if(!rt)return;
        if(a[rt].son[0])a[rt].s=a[a[rt].son[0]].s;
        else a[rt].s=rt;
    }
    inline void pushdown(int rt){
        if(!rt||!a[rt].flag)return;
        a[a[rt].son[0]].flag^=1;a[a[rt].son[1]].flag^=1;a[rt].flag^=1;
        swap(a[rt].son[0],a[rt].son[1]);
    }
    inline void turn(int rt){
        int x=a[rt].f,y=a[x].f,k=a[x].son[0]==rt?1:0;
        if(!isroot(x)){
            if(a[y].son[0]==x)a[y].son[0]=rt;
            else a[y].son[1]=rt;
        }
        a[rt].f=y;a[x].f=rt;a[a[rt].son[k]].f=x;
        a[x].son[k^1]=a[rt].son[k];a[rt].son[k]=x;
        pushup(x);pushup(rt);
    }
    void splay(int rt){
        int top=0;
        stack[++top]=rt;
        for(int i=rt;!isroot(i);i=a[i].f)stack[++top]=a[i].f;
        while(top)pushdown(stack[top--]);
        while(!isroot(rt)){
            int x=a[rt].f,y=a[x].f;
            if(!isroot(x)){
                if((a[y].son[0]==x)^(a[x].son[0]==rt))turn(rt);
                else turn(x);
            }
            turn(rt);
        }
    }
    void access(int x){
        for(int i=0;x;i=x,x=a[x].f){
            splay(x);
            if(a[x].son[1])ST::update(id[a[a[x].son[1]].s],id[a[a[x].son[1]].s]+size[a[a[x].son[1]].s]-1,1,1);
            if(i)ST::update(id[a[i].s],id[a[i].s]+size[a[i].s]-1,-1,1);
            a[x].son[1]=i;
            if(i)a[i].f=x;
        }
    }
}
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
inline void add(int x,int y){
    a[c].to=y;a[c].next=head[x];head[x]=c++;
    a[c].to=x;a[c].next=head[y];head[y]=c++;
}
void dfs1(int rt){
    son[rt]=0;size[rt]=1;
    for(int i=head[rt];i;i=a[i].next){
        int will=a[i].to;
        if(!deep[will]){
            deep[will]=deep[rt]+1;
            fa[will]=rt;
            dfs1(will);
            size[rt]+=size[will];
            if(size[son[rt]]<size[will])son[rt]=will;
        }
    }
}
void dfs2(int rt,int f){
    id[rt]=d++;top[rt]=f;
    if(son[rt])dfs2(son[rt],f);
    for(int i=head[rt];i;i=a[i].next){
        int will=a[i].to;
        if(will!=fa[rt]&&will!=son[rt])
        dfs2(will,will);
    }
}
int LCA(int x,int y){
    while(top[x]!=top[y]){
        if(deep[top[x]]<deep[top[y]])swap(x,y);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])swap(x,y);
    return x;
}
void work(){
    int f,x,y;
    while(m--){
        f=read();x=read();
        if(f==1)LCT::access(x);
        if(f==2){
            y=read();
            int fa=LCA(x,y);
            printf("%d\n",(ST::query(id[x],id[x],1)+ST::query(id[y],id[y],1)-ST::query(id[fa],id[fa],1)*2+1));
        }
        if(f==3)printf("%d\n",ST::query(id[x],id[x]+size[x]-1,1));
    }
}
void init(){
    int x,y;
    n=read();m=read();
    for(int i=1;i<n;i++){
        x=read();y=read();
        add(x,y);
    }
    deep[1]=1;
    dfs1(1);
    dfs2(1,1);
    ST::buildtree(1,n,1);
    for(int i=1;i<=n;i++){
        ST::update(id[i],id[i],deep[i],1);
        LCT::a[i].s=i;
        LCT::a[i].f=fa[i];
    }
}
int main(){
    init();
    work();
	return 0;
}

-斯德哥尔摩-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
洛谷P3703 [SDOI2017]树点涂色

题目描述Bob有一棵nn 个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作：1 x把点xx 到根节点的路径上所有的点染上一种没有用过的新颜色。2 x y求xx 到yy 的路径的权值。3 x在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值...
复制链接

扫一扫