洛谷-P2486 [SDOI2011]染色（树链剖分）

最新推荐文章于 2022-10-25 15:21:16 发布
最新推荐文章于 2022-10-25 15:21:16 发布
阅读量225 收藏
点赞数
分类专栏： 程序设计竞赛记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40482358/article/details/90208349
版权

题目链接：https://www.luogu.org/problemnew/show/P2486

题目大意：中文题，如题。

思路：很明显的树剖，维护一条链的颜色个数，最左右节点的颜色。合并的时候注意要比较一下相连接的部分，如果颜色一样，就ans--。

比较连接处颜色的时候手残少些了个Top。结果一直WA。找了个过的对拍了一下。发现是手残。佛了。后面有对拍代码。觉得自己没问题的可以拍一下看看，把n开大一点总能拍出来的。

ACCode：

// luogu-judger-enable-o2
//#pragma comment(linker, "/STACK:1024000000,1024000000")
  
#include<stdio.h>
#include<string.h> 
#include<math.h> 
   
#include<map>  
#include<set>
#include<deque> 
#include<queue> 
#include<stack> 
#include<bitset>
#include<string> 
#include<fstream>
#include<iostream> 
#include<algorithm> 
using namespace std; 
  
#define ll long long 
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b)
#define clean(a,b) memset(a,b,sizeof(a))// ??
//std::ios::sync_with_stdio(false);
//  register
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;

class Segment{
    ll Sum[MAXN<<2],Lazy[MAXN<<2];
    ll LColor[MAXN<<2],RColor[MAXN<<2];
    
    void PushUp(int l,int r,int rt){//将该节点更新为剩下的节点 
        Sum[rt]=Sum[rt<<1]+Sum[rt<<1|1];
        LColor[rt]=LColor[rt<<1];
        RColor[rt]=RColor[rt<<1|1];
        if(RColor[rt<<1]==LColor[rt<<1|1]){
            Sum[rt]--;
        }
    }
    void PushDown(int l,int r,int rt){
        if(Lazy[rt]){
            Sum[rt<<1]=Sum[rt<<1|1]=1;
            Lazy[rt<<1]=Lazy[rt<<1|1]=Lazy[rt];
            LColor[rt<<1]=RColor[rt<<1]=LColor[rt<<1|1]=RColor[rt<<1|1]=Lazy[rt];
            Lazy[rt]=0;
        }
    }
    public:
        void Build(int l,int r,int rt,ll A[]){
            if(l==r){
                Sum[rt]=1;Lazy[rt]=0;
                LColor[rt]=RColor[rt]=A[l];
                return ;
            }
            int mid=(l+r)>>1;
            Build(l,mid,rt<<1,A);Build(mid+1,r,rt<<1|1,A);
            PushUp(l,r,rt);
        }
        void Update(int ql,int qr,ll val,int l,int r,int rt){
            if(ql<=l&&r<=qr){
                Sum[rt]=1;Lazy[rt]=val;
                LColor[rt]=RColor[rt]=val;
                return ;
            }
            PushDown(l,r,rt);
            int mid=(l+r)>>1;
            if(ql<=mid) Update(ql,qr,val,l,mid,rt<<1);
            if(qr>mid) Update(ql,qr,val,mid+1,r,rt<<1|1);
            PushUp(l,r,rt);
        }
        ll Query(int ql,int qr,int l,int r,int rt){
            if(ql<=l&&r<=qr) return Sum[rt];
            PushDown(l,r,rt);
            int mid=(l+r)>>1;
            if(ql<=mid){
                ll res=0;
                res+=Query(ql,qr,l,mid,rt<<1);
                if(qr>mid){
                    res+=Query(ql,qr,mid+1,r,rt<<1|1);
                    if(RColor[rt<<1]==LColor[rt<<1|1]) res--;
                }
                return res;
            }
            return Query(ql,qr,mid+1,r,rt<<1|1);
        }
        ll QueryColor(int ql,int qr,int l,int r,int rt){
            if(ql<=l&&r<=qr){
                return LColor[rt];
            }
            PushDown(l,r,rt);
            int mid=(l+r)>>1;
            if(ql<=mid) return QueryColor(ql,qr,l,mid,rt<<1);
            return QueryColor(ql,qr,mid+1,r,rt<<1|1);
        } 
        void Show(int l,int r,int rt){
            printf("l=%d r=%d : \nSum[rt]=%lld Lazy[rt]=%lld LColor[rt]=%lld RColor[rt]=%lld\n",l,r,Sum[rt],Lazy[rt],LColor[rt],RColor[rt]);
            if(l==r) return ;
            int mid=(l+r)>>1;
            Show(l,mid,rt<<1);Show(mid+1,r,rt<<1|1);
        }
};

struct Node1{
    int v,nxt;
    Node1(int _v=0,int _nxt=0){
        v=_v;nxt=_nxt;
    }
};
Segment Seg;
Node1 Edge[MAXN<<2];
int Head[MAXN],Ecnt;
int Deep[MAXN],Fa[MAXN],Size[MAXN],Son[MAXN];
int Idx[MAXN],Icnt;
int Top[MAXN];
ll A[MAXN],B[MAXN];
int n,m;

void Intt(){
    clean(Head,-1);Ecnt=0;
    clean(Deep,0);clean(Fa,-1);
    clean(Size,0);clean(Son,-1);
    Icnt=0;
}
void AddEdge(int u,int v){
    Edge[Ecnt]=Node1(v,Head[u]);
    Head[u]=Ecnt++;
}
int DFS1(int u,int fa,int dep){
    Deep[u]=dep;Fa[u]=fa;Size[u]=1;
    int maxson=-1;
    for(int i=Head[u];i+1;i=Edge[i].nxt){
        int temp=Edge[i].v;
        if(temp==fa) continue;
        Size[u]+=DFS1(temp,u,dep+1);
        if(Size[temp]>maxson){
            maxson=Size[temp];Son[u]=temp;
        }
    }return Size[u];
}
void DFS2(int u,int topfa){
    Idx[u]=++Icnt;Top[u]=topfa;B[Idx[u]]=A[u];
    if(Son[u]==-1) return ;
    DFS2(Son[u],topfa);
    for(int i=Head[u];i+1;i=Edge[i].nxt){
        int temp=Edge[i].v;
        if(Idx[temp]==0){
            DFS2(temp,temp);
        }
    }
}
void UpdatePath(int l,int r,ll val){
    while(Top[l]!=Top[r]){
        if(Deep[Top[l]]<Deep[Top[r]]) swap(l,r);
        Seg.Update(Idx[Top[l]],Idx[l],val,1,n,1);
        l=Fa[Top[l]];
    }
    if(Deep[l]>Deep[r]) swap(l,r);
    Seg.Update(Idx[l],Idx[r],val,1,n,1);
}
ll QueryPath(int l,int r){
    ll ans=0;
    while(Top[l]!=Top[r]){
        if(Deep[Top[l]]<Deep[Top[r]]) swap(l,r);
        ll res=ans;
//		printf("Q:%d~%d +%lld\n",Idx[Top[l]],Idx[l],Seg.Query(Idx[Top[l]],Idx[l],1,n,1));
        ans+=Seg.Query(Idx[Top[l]],Idx[l],1,n,1);
//		printf("FaColor:%lld RColor:%lld\n",Seg.QueryColor(Idx[Fa[Top[l]]],Idx[Fa[Top[l]]],1,n,1),Seg.QueryColor(Idx[Top[l]],Idx[Top[l]],1,n,1));
        if(Seg.QueryColor(Idx[Fa[Top[l]]],Idx[Fa[Top[l]]],1,n,1)==Seg.QueryColor(Idx[Top[l]],Idx[Top[l]],1,n,1)) ans--;
        l=Fa[Top[l]];
//        cout<<"差值:"<<ans-res<<endl;
    }
    if(Deep[l]>Deep[r]) swap(l,r);
//	printf("Q:%d~%d +%lld\n",Idx[l],Idx[r],Seg.Query(Idx[l],Idx[r],1,n,1));
    ans+=Seg.Query(Idx[l],Idx[r],1,n,1);
    return ans;
}
int main(){
    Intt();
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i){
        scanf("%lld",&A[i]);
    }
    for(int i=1;i<n;++i){
        int a,b;scanf("%d%d",&a,&b);
        AddEdge(a,b);AddEdge(b,a);
    }DFS1(1,-1,1);DFS2(1,1);
//	for(int i=1;i<=n;++i){
//		printf("i=%d : Idx[i]=%d\n",i,Idx[i]);
//	}printf("\n");
    Seg.Build(1,n,1,B);
//	Seg.Show(1,n,1);printf("\n");
    for(int i=1;i<=m;++i){
        char oper[5];scanf("%s",&oper);
        if(oper[0]=='C'){
            int a,b;ll c;scanf("%d%d%lld",&a,&b,&c);
            UpdatePath(a,b,c);
        }
        else{
            int a,b;scanf("%d%d",&a,&b);
            printf("%lld\n",QueryPath(a,b));
        }
//		Seg.Show(1,n,1);printf("\n");
    }
}

/*

6 1
4 1 5 1 2 4 
4 2
5 6
4 6
1 4
2 3
Q
3 1 

*/

Make：

// luogu-judger-enable-o2
//#pragma comment(linker, "/STACK:1024000000,1024000000")
  
#include<stdio.h>
#include<string.h> 
#include<math.h> 
#include<time.h>
   
#include<map>  
#include<set>
#include<deque> 
#include<queue> 
#include<stack> 
#include<bitset>
#include<string> 
#include<fstream>
#include<iostream> 
#include<algorithm> 
using namespace std; 
  
#define ll long long 
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b)
#define clean(a,b) memset(a,b,sizeof(a))// ??
//std::ios::sync_with_stdio(false);
//  register
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;
const double PI=acos(-1.0);
const double EPS=1.0e-8;

int n,m;
int a[1000];
int f[1000],cnt;
int GetFather(int x){
	return x==f[x]?x:f[x]=getfather(f[x]);
}
int main(){
    freopen("1.in","w",stdout);
    srand(time(0));
    n=rand()%5+2;m=rand()%5+1;
    cout<<n<<" "<<m<<endl;
    for(int i=1;i<=n;++i) cout<<rand()%n+1<<" ";cout<<endl;
    for(int i=1;i<=n;++i) f[i]=i;
    while(cnt<n-1){
        int x=rand()%n+1;
        int y=rand()%n+1;
        int xx=getfather(x);
        int yy=getfather(y);
        if(xx==yy)continue;
        f[xx]=yy;++cnt;
        cout<<x<<" "<<y<<endl;
    }
    for(int i=1;i<=m;++i){
        if(i&1){
            cout<<"Q"<<endl;
            int l=rand()%n+1;
            int r=rand()%n+1;
            cout<<l<<" "<<r<<" "<<endl;
        }
        else{
            cout<<"C"<<endl;
            int l=rand()%n+1;
            int r=rand()%n+1;
            int z=rand()%1000000000+1;
            cout<<l<<" "<<r<<" "<<z<<endl;
        }
    }
}

如果不会写对拍的，下面是我bat的代码（不会写循环的菜鸡QAQ）：注意是bat文件。然后就能发现那个不一样了。

 

【洛谷 P3384】树链剖分【详解树链剖分】
Gene_I must wait for the sunrise
03-15 2498
题意： 一颗 NNN 个节点的树，每个节点上都有初始权值。现在有四种操作： 操作 111 —— 1&nbsp;x&nbsp;y&nbsp;z1\ x\ y\ z1&nbsp;x&nbsp;y&nbsp;z，表示将 xxx 到 yyy 节点最短路径上所有节点的值加z 操作 222 —— 2&nbsp;x&nbsp;y2\ x\ y2&nbsp;x&nbsp;y，表示求 xxx 到 yyy 节点最短路...
【算法竞赛学习笔记】[SDOI2011]染色（路径染色+色段查询）
SC_Linno的博客
11-20 765
title : [SDOI2011]染色（路径染色+色段查询） tags : ACM,数据结构 date : 2021-11-16 author : Linno P2486 [SDOI2011]染色 题面 给一棵树，支持两种操作： ①给定u,v,w，将u到v的路径上所有节点染成颜色w。 ②给定u,v，查询u到v路径上颜色段的数量。 树链剖分+线段树 树链剖分将无根树拍平后，用线段树去做。维护每个区间的左颜色、右颜色、色段和以及tag，如果合并的时候两端颜色一致，那么ans-1。 #include<.
P2486 [SDOI2011]染色
weixin_30627381的博客
05-04 104
P2486 [SDOI2011]染色 链接：https://www.luogu.org/problemnew/show/P2486 题目描述 输入输出格式 输入格式： 输出格式： 对于每个询问操作，输出一行答案。 输入输出样例 输入样例#1：复制 6 5 2 2 1 2 1 1 1 2 1 3 2 4 2 5 2 6 Q 3 5...
洛谷P2486 [SDOI2011]染色（树链剖分+线段树判断边界）
weixin_30888027的博客
07-23 117
【题目链接】 【思路】： 涉及到树上区间修改操作，所以使用树链剖分，涉及到区间查询，所以使用线段树。 update操作时，就正常操作，难点在于query操作的计数。 因为树链剖分的dfs序只能保证一条重链上的dfn[]连续，不能使得任意两点之间简单路径上的dfn[]连续，所以当x往上跳到fa[top[x]]时，要判断 top[x]的颜色与fa[top[x]]的颜色是否相同，如果...
P2486 [SDOI2011]染色(树链剖分)
smilestruggler_Fly To Higher
04-27 251
题目链接：https://www.luogu.org/problemnew/show/P2486 题目大意： 给定一棵有n个节点的无根树和m个操作，操作有2类： 1、将节点a到节点b路径上所有点都染成颜色c； 2、询问节点a到节点b路径上的颜色段数量（连续相同颜色被认为是同一段）， 如“112221”由3段组成：“11”、“222”和“1”。 请你写一个程序依次完成这m个操作。 ...
[SDOI2011] 染色 (树链剖分)
weixin_30764137的博客
06-28 104
题目描述 输入输出格式 输入格式： 输出格式： 对于每个询问操作，输出一行答案。 输入输出样例 输入样例#1： 6 5 2 2 1 2 1 1 1 2 1 3 2 4 2 5 2 6 Q 3 5 C 2 1 1 Q 3 5 C 5 1 2 Q 3 5 输出样例#1： 3 1 2 说明 Solution 太久没打过树剖了哈,代码能力弱的一批... 这道题需要进行改进的地方是线段树部分. 我...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
洛谷P3379最近公共祖先LCA问题（倍增，st表，tarjan，树链剖分）菜鸟蒟蒻详解
m0_73293029的博客
10-25 807
洛谷P3379最近公共祖先LCA问题（倍增，st表，tarjan，树链剖分）菜鸟蒟蒻详解
洛谷P2486 [SDOI2011]染色
m0_51506155的博客
04-18 130
思路很简单，实现细节有点多，做了两个半小时。 学过树链剖分一眼就能看出来。 先树链剖分把图建好，线段树维护链，lg，rs表示每个区间的左右端点颜色，seg表示区间颜色段数，tag是染色标记。id是树链上点的编号，W(大写)是树链上点的编号对应的颜色，w(小写)是树链的线段树上叶子的颜色。 #include <bits/stdc++.h> #define mid (l+r)/2 #define ls (k<<1) #define rs (k<<1|1) using
洛谷 P2486 [SDOI2011]染色
苦鬼·。
09-13 665
题目描述 输入输出格式 输入格式： 输出格式： 对于每个询问操作，输出一行答案。 输入输出样例 输入样例#1： 6 5 2 2 1 2 1 1 1 2 1 3 2 4 2 5 2 6 Q 3 5 C 2 1 1 Q 3 5 C 5 1 2 Q 3 5 输出样例#1： 3 1 2 说明
P2486 [SDOI2011]染色（树链剖分+线段树）
starlet_kiss的博客
09-27 196
题干描述 输入描述 输出格式 对于每个询问操作，输出一行答案。 输入输出样例 输入 #1 复制 6 5 2 2 1 2 1 1 1 2 1 3 2 4 2 5 2 6 Q 3 5 C 2 1 1 Q 3 5 C 5 1 2 Q 3 5 输出 #1 复制 3 1 2 说明/提示 题干很清楚，就是树链剖分+线段树的基本操作。但是在实现的过程中有几个点需要注意一下。 我们分类讨论一下： 第一种情况...
洛谷 P2486 [SDOI2011]染色（LCT）
hhz6830975的博客
04-12 447
很经典的一道题目，这里介绍LCT的做法。 对splay的每个结点维护当前以该结点为根的子树内第一个结点和最后一个结点（即对应区间两端）的颜色，以及该子树内颜色段数。pushup合并的时候，如果合并的两个区间相邻部分的颜色不同，新区间的颜色段数就是两个区间的和，如果相同就-1。修改就打lazy标记。注意打标记要同时更新，不能等pushdown再更新。另外翻转的时候还要交换区间两端颜色。 似乎树剖...
洛谷P2486 [SDOI2011]染色（树链剖分初入门）
qq_36018057的博客
09-20 462
首先,根据本人以往解决经验这类疑似树上区间操作,都可能是树链剖分,我们先考虑数组的实现情况 给你一个数组aiaiai,有2个操作 操作1:[l,r,color]:[l,r]变成color色操作1:[l,r,color]:[l,r]变成color色操作1:[l,r,color]:[l,r]变成color色 操作2:查询[l,r]颜色段的数目操作2:查询[l,r]颜色段的数目操作2:查询[l,r]颜色段的数目 这是线段树染色的一个东西,解决方法如下: 线段树维护3个值区间颜色数量num,左端点颜色cl,右端点颜
洛谷P3384树链剖分模板详解与C++实现
本篇笔记主要围绕数据结构中的树链剖分（也称为重链剖分）进行深入讲解。树链剖分是一种将一棵树分解成若干个连续的子树的算法，用于高效地支持查询和修改树中特定路径上的节点值。该技术常用于动态规划和在线问题的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值