4817 [Sdoi2017]树点涂色

题目描述

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

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

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

  • 1 x 表示把点 x 到根节点的路径上所有的点染上一种没有用过的新颜色。
  • 2 x y 求 x 到 y 的路径的权值。
  • 3 x 在以 x 为根的子树中选择一个点,使得这个点到根节点的路径权值最大,求最大权值。

Bob一共会进行 m 次操作

输入格式

第一行两个数 n,m。

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

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

输出格式

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

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

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

输入输出样例

输入 #1

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

输出 #1

3
4
2
2

说明/提示

\(n , m <= 1e5\)

分析

将相同颜色的点看做一个Splay , 那么操作1就是标准的access

对于操作二三维护,一个点到根的颜色个数,也是Splay的个数。

这个可以用线段树维护

在assess操作时,将要并上去的的子树-- , 断开的子树++

注意


1.别忘了初始化,初始时各个节点颜色互不相同,也就是ans = d(到根的距离)
2.rot时分清谁和谁, 我脑残写了 fa[x] = y , fa[y] = x

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 210000;
inline int read()
{
    register int x = 0; register char c = getchar();
    while(c < '0' || c > '9') c = getchar(); while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
    return x;
}
int n , m , dfn , cnt;
int head[N] , st[N] , ed[N] , d[N] , fdfn[N] , f[N][20] , siz[N] , fa[N] , tr[N][2] , rev[N] , maxn[N<<2] , tag[N<<2];
struct edge{int v , nex; } e[N<<1];
inline void add(int u , int v) { e[++cnt].v = v; e[cnt].nex = head[u]; head[u] = cnt; return ; }
#define D_bag puts("this is OK!!");
// Segment_tree->begin()

void Down(int k)
{
    if(tag[k])
    {
        maxn[k<<1] += tag[k]; maxn[k<<1|1] += tag[k];
        tag[k<<1] += tag[k]; tag[k<<1|1] += tag[k]; tag[k] = 0; // tag -->clear
    }
    return ;
}

void build(int k , int l , int r) // 建树初始化
{
    if(l == r)
    {
        maxn[k] = d[fdfn[l]];
        return ;
    }
    int mid = (l + r) >> 1;
    build(k << 1 , l , mid);
    build(k << 1 | 1 , mid + 1 , r);
    maxn[k] = max(maxn[k<<1] , maxn[k<<1|1]);
    return ;
}

void Change(int k , int l , int r , int x , int y , int val)
{
    if(x <= l && r <= y) return (void)(maxn[k] += val , tag[k] += val);
    int mid = (l + r) >> 1; Down(k);
    if(x <= mid) Change(k << 1 , l , mid , x , y , val);
    if(y  > mid) Change(k << 1 | 1 , mid+1 , r , x , y , val);
    maxn[k] = max(maxn[k<<1] , maxn[k<<1|1]); return ;
}

int Ask(int k , int l , int r , int x , int y)
{
    if(x <= l && r <= y) return maxn[k];
    Down(k); int mid = (l + r) >> 1 , ans = 0;
    if(x <= mid) ans = max(ans , Ask(k<<1 , l , mid , x , y));
    if(y  > mid) ans = max(ans , Ask(k<<1|1 , mid+1 , r , x , y));
    return ans;
}

// Segment_tree->end()

inline int witch(int x) { return x == tr[fa[x]][1]; }
inline int nrt(int x) { return (fa[x] && (tr[fa[x]][0] == x || tr[fa[x]][1] == x)); }
void rot(int x)
{
    int y = fa[x] , z = fa[y] , k = witch(x) , w = tr[x][!k];
    if(nrt(y)) tr[z][witch(y)] = x; fa[x] = z; // !!!!
    tr[y][k] = w; if(w) fa[w] = y;
    tr[x][!k] = y; fa[y] = x;
}

void Splay(int x)
{
    while(nrt(x))
    {
        if(nrt(fa[x])) rot(witch(x) == witch(fa[x]) ? fa[x] : x);
        rot(x);
    }
    return ;
}

int find_son(int x)
{
    while(tr[x][0]) x = tr[x][0]; return x;
}

void assess(int x)
{
    int t = 0;
    for(t = 0; x ; t = x , x = fa[x])
    {
        Splay(x);
        if(t)
        {
            int son = find_son(t);
            Change(1 , 1 , n , st[son] , ed[son] , -1);
        }
        if(tr[x][1])
        {
            int son = find_son(tr[x][1]);
            Change(1 , 1 , n , st[son] , ed[son] , 1);
        }
        tr[x][1] = t;
    }
    return ;
}

int lca(int x , int y)
{
    if(x == y) return x;
    if(d[x] < d[y]) swap(x , y);
    for(int i = 18 ; i >= 0 ; --i) if(d[f[x][i]] >= d[y]) x = f[x][i];
    if(x == y) return x;
    for(int i = 18 ; i >= 0 ; --i) if(f[x][i] != f[y][i]) x = f[x][i] , y = f[y][i];
    return f[x][0];
}

void dfs(int x)
{
    st[x] = ++dfn; fdfn[dfn] = x;
    for(int i = 1 ; i <= 18 ; ++i) f[x][i] = f[f[x][i-1]][i-1];
    for(int i = head[x] , v; i ; i = e[i].nex)
    {
        v = e[i].v;
        if(v == f[x][0]) continue;
        f[v][0] = x; d[v] = d[x] + 1; fa[v] = x; dfs(v);
    }
    ed[x] = dfn;
    return ;
}
int main()
{
    n = read(); m = read();
    for(int i = 1 , a , b; i <= n - 1 ; ++i)
    {
        a = read(); b = read();
        add(a , b); add(b , a);
    }
    d[1] = 1; dfs(1);
    build(1 , 1 , n);
    for(int i = 1 , op , x ; i <= m ; ++i)
    {
        op = read(); x = read();
        if(op == 1) assess(x);
        else
        if(op == 2)
        {
            int y = read() , p = lca(x , y);
            int ans = Ask(1 , 1 , n , st[x] , st[x]) + Ask(1 , 1 , n , st[y] , st[y]) - 2 * Ask(1 , 1 , n , st[p] , st[p]) + 1;
            printf("%d\n" , ans);
        }
        else
        if(op == 3)
            printf("%d\n" , Ask(1 , 1 , n , st[x] , ed[x]));
    }
    return 0;
}
/*
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
*/

原文地址:https://www.cnblogs.com/R-Q-R-Q/p/12158712.html

时间: 2024-11-02 17:25:41

4817 [Sdoi2017]树点涂色的相关文章

[BZOJ]4817: [Sdoi2017]树点涂色

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

bzoj 4817: [Sdoi2017]树点涂色【树链剖分+LCT】

非常妙的一道题. 首先对于操作一"把点x到根节点的路径上所有的点染上一种没有用过的新颜色",长得是不是有点像LCT中的access操作?进而发现,如果把同一颜色的点连起来作为LCT中的重边的话,那么询问二就相当于问路径上的虚边有多少. 然后第二.三个操作是可以用树剖在线段树上维护的. 设每个点的权值\( val \)为这个点到根的路径上颜色个数,也就是虚边个数.那么考虑access操作的影响,对于他断开的重边,所在子树加一,对于他连上的重边,所在子树减一.直接在access过程中处理即

BZOJ.4817.[SDOI2017]树点涂色(LCT DFS序 线段树)

题目链接 1.2裸树剖,但是3.每个点的答案val很不好维护.. 如果我们把同种颜色的点划分到同一连通块中,那么向根染色的过程就是Access()! 最初所有点间都是虚边,相同颜色点用实边相连.一条边由实边变为虚边时,深度大的点所在子树所有点val+1(Access()中原先x的右儿子答案+1,因为x颜色变了): 由虚边变为实边时,深度大的点所在子树所有点val-1(fa[x]颜色与x相同导致fa[x]的贡献没了).(其实是因为 实链数量(贡献)就等于虚边数量+1?无所谓了) 于是2.就是val

[BZOJ4817][SDOI2017]树点涂色(LCT+DFS序线段树)

4817: [Sdoi2017]树点涂色 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 692  Solved: 408[Submit][Status][Discuss] Description Bob有一棵n个点的有根树,其中1号点是根节点.Bob在每个点上涂了颜色,并且每个点上的颜色不同.定义一条路 径的权值是:这条路径上的点(包括起点和终点)共有多少种不同的颜色.Bob可能会进行这几种操作: 1 x: 把点x到根节点的路径上所有的点染上一种

AC日记——[SDOI2017]树点涂色 bzoj 4817

4817 思路: 跪烂大佬 代码: #include <bits/stdc++.h> using namespace std; #define maxn 500005 struct TreeNodeType { int l,r,mid,dis,flag; }; struct TreeNodeType tree[maxn<<2]; int n,m,rev[maxn],f[maxn],ch[maxn][2],Qes,deep[maxn],id[maxn]; int f_[maxn],t

BZOJ4817 [Sdoi2017]树点涂色

本文版权归ljh2000和博客园共有,欢迎转载,但须保留此声明,并给出原文链接,谢谢合作. 本文作者:ljh2000 作者博客:http://www.cnblogs.com/ljh2000-jump/转载请注明出处,侵权必究,保留最终解释权! 题目链接:BZOJ4817 正解:$LCT$+线段树 解题报告: 考虑操作$1$很类似$LCT$中的$access$操作,我们可以借助$LCT$的复杂度证明,来保证用$LCT$的实现方式来完成本题的操作复杂度的正确性. 我们维护每个点到根的权值,用线段树维

【bzoj4817】[Sdoi2017]树点涂色&amp;&amp;bzoj3779-重组病毒

题解: 两道几乎差不多的题(所以说当年sdoi考了道原题) 都是将树上一段改为新颜色询问颜色数目 可以把改成新颜色这个操作看成access操作 然后通过线段树+dfs序来维护 另外换根了为什么还可以用dfs序来维护 我们观察一下会发现 1.当根在x当中,就是除了根那边那块 2.不在的话就是原先的子树 原文地址:https://www.cnblogs.com/yinwuxiao/p/9272857.html

SDOI2017 树点涂色

题目描述 题解: SDOI SD题. LCT维护线段树, 线段树维护dfs序. 由于每次修改只是从根到x,我们可以将它理解为LCT的access操作. 然后轻重链信息发生变化时,在线段树上改一下就好了. LCTaccess板子敲错导致自己做自己爷爷. 代码: #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 100050 inline int rd(

并不对劲的[SDOI2017]树点涂色

题目大意 有一棵\(n\)(\(n\leq10^5\))个节点的树,每个点有颜色\(c\),一开始所有颜色互不相同 要进行\(m\)(\(m\leq10^5\))次操作,每次操作是以下三种中的一种: 1.给出点\(x\),将点\(x\)到根路径上所有点的染成一种没出现过的颜色 2.给出点\(x\),\(y\),询问点\(x\)到\(y\)的简单路径上有多少种颜色 3.给出点\(x\),询问点\(x\)的子树中到根路径上颜色种类最多的点 题解 先坑着 代码 #include<algorithm>