[Luogu 2486] SDOI2011 染色

[Luogu 2486] SDOI2011 染色



树剖水题,线段树维护。

详细题解明天写。

我只想说我写的线段树又变漂亮了qwq


#include <algorithm>
#include <cstdio>
#include <cstring>
const int MAXN=100010;
int n,m;
class HLD
{
    private:
        bool vis[MAXN];
        int num;
        static int rank[MAXN];
        static struct Node
        {
            int v,depth,father,son,top,size,DFN;
        }s[MAXN];
        class SegmentTree
        {
            private:
                struct Node
                {
                    int v,left,right,lazy,color[2];
                    Node *c[2];
                    Node(int l,int r):left(l),right(r),lazy(0)
                    {
                        memset(color,0,sizeof color);
                        c[0]=c[1]=nullptr;
                        if(l==r)
                        {
                            v=1;
                            color[0]=color[1]=s[rank[l]].v;
                            return;
                        }
                        int mid=l+r>>1;
                        c[0]=new Node(l,mid);
                        c[1]=new Node(mid+1,r);
                        PushUp();
                    }
                    ~Node(void)
                    {
                        if(c[0]!=nullptr)
                            delete c[0];
                        if(c[1]!=nullptr)
                            delete c[1];
                    }
                    void Modify(int x)
                    {
                        v=1;
                        lazy=color[0]=color[1]=x;
                    }
                    void PushUp(void)
                    {
                        v=c[0]->v+c[1]->v;
                        color[0]=c[0]->color[0];
                        color[1]=c[1]->color[1];
                        if(c[0]->color[1]==c[1]->color[0])
                            --v;
                    }
                    void PushDown(void)
                    {
                        if(c[0]!=nullptr)
                            c[0]->Modify(lazy);
                        if(c[1]!=nullptr)
                            c[1]->Modify(lazy);
                        lazy=0;
                    }
                    int Color(int x)
                    {
                        if(left==right)
                            return color[0];
                        if(lazy)
                            PushDown();
                        int mid=left+right>>1;
                        if(x>mid)
                            return c[1]->Color(x);
                        else
                            return c[0]->Color(x);
                    }
                    void Change(int l,int r,int v)
                    {
                        if(l==left && r==right)
                        {
                            Modify(v);
                            return;
                        }
                        if(lazy)
                            PushDown();
                        int mid=left+right>>1;
                        if(r<=mid)
                            c[0]->Change(l,r,v);
                        else if(l>mid)
                            c[1]->Change(l,r,v);
                        else
                        {
                            c[0]->Change(l,mid,v);
                            c[1]->Change(mid+1,r,v);
                        }
                        PushUp();
                    }
                    int Query(int l,int r)
                    {
                        if(l==left && r==right)
                            return v;
                        int mid=left+right>>1;
                        if(lazy)
                            PushDown();
                        if(r<=mid)
                            return c[0]->Query(l,r);
                        else if(l>mid)
                            return c[1]->Query(l,r);
                        else
                        {
                            int ans=c[0]->Query(l,mid)+c[1]->Query(mid+1,r);
                            if(c[0]->color[1]==c[1]->color[0])
                                --ans;
                            return ans;
                        }
                    }
                }*root;
            public:
                SegmentTree(int n)
                {
                    root=new Node(1,n);
                }
                ~SegmentTree(void)
                {
                    delete root;
                }
                int Color(int x)
                {
                    return root->Color(x);
                }
                void Change(int l,int r,int v)
                {
                    root->Change(l,r,v);
                }
                int Query(int l,int r)
                {
                    return root->Query(l,r);
                }
        }*T;
        struct Edge
        {
            int to;
            Edge *next;
            Edge(int to,Edge* next):to(to),next(next){}
            ~Edge(void)
            {
                if(next!=nullptr)
                    delete next;
            }
        }*head[MAXN];
        void AddEdges(int u,int v)
        {
            head[u]=new Edge(v,head[u]);
            head[v]=new Edge(u,head[v]);
        }
        void DFS1(int u,int k)
        {
            s[u].depth=k;
            s[u].size=1;
            int v;
            for(Edge *i=head[u];i!=nullptr;i=i->next)
                if(!s[v=i->to].size)
                {
                    DFS1(v,k+1);
                    s[v].father=u;
                    s[u].size+=s[v].size;
                    if(s[v].size>s[s[u].son].size)
                        s[u].son=v;
                }
        }
        void DFS2(int u,int top)
        {
            s[u].top=top;
            s[u].DFN=++num;
            rank[num]=u;
            vis[u]=true;
            if(s[u].son)
                DFS2(s[u].son,top);
            int v;
            for(Edge *i=head[u];i!=nullptr;i=i->next)
                if(!vis[v=i->to])
                    DFS2(v,v);
        }
    public:
        HLD(int n):num(0)
        {
            memset(s,0,sizeof s);
            std::fill(head+1,head+n+1,nullptr);
            for(int i=1;i<=n;++i)
                scanf("%d",&s[i].v);
            for(int i=1,u,v;i<n;++i)
            {
                scanf("%d %d",&u,&v);
                AddEdges(u,v);
            }
            DFS1(1,1);
            DFS2(1,1);
            T=new SegmentTree(n);
        }
        ~HLD(void)
        {
            for(int i=1;i<=n;++i)
                delete head[i];
            delete T;
        }
        void Change(int x,int y)
        {
            int a,b,v;
            scanf("%d",&v);
            while((a=s[x].top)^(b=s[y].top))
                if(s[a].depth>s[b].depth)
                {
                    T->Change(s[a].DFN,s[x].DFN,v);
                    x=s[a].father;
                }
                else
                {
                    T->Change(s[b].DFN,s[y].DFN,v);
                    y=s[b].father;
                }
            if(s[x].depth<s[y].depth)
                T->Change(s[x].DFN,s[y].DFN,v);
            else
                T->Change(s[y].DFN,s[x].DFN,v);
        }
        void Query(int x,int y)
        {
            int a,b,ans=0;
            while((a=s[x].top)^(b=s[y].top))
                if(s[a].depth>s[b].depth)
                {
                    ans+=T->Query(s[a].DFN,s[x].DFN);
                    x=s[a].father;
                    if(T->Color(s[a].DFN)==T->Color(s[x].DFN))
                        --ans;
                }
                else
                {
                    ans+=T->Query(s[b].DFN,s[y].DFN);
                    y=s[b].father;
                    if(T->Color(s[b].DFN)==T->Color(s[y].DFN))
                        --ans;
                }
            ans+=s[x].depth<s[y].depth ? T->Query(s[x].DFN,s[y].DFN) : T->Query(s[y].DFN,s[x].DFN);
            printf("%d\n",ans);
        }
}*T;
int HLD::rank[MAXN];
HLD::Node HLD::s[MAXN];
int main(int argc,char** argv)
{
    scanf("%d %d",&n,&m);
    T=new HLD(n);
    char c;
    for(int i=1,x,y;i<=m;++i)
    {
        scanf("\n%c %d %d",&c,&x,&y);
        if(c=='C')
            T->Change(x,y);
        else
            T->Query(x,y);
    }
    delete T;
    return 0;
}

谢谢阅读。

原文地址:https://www.cnblogs.com/Capella/p/9191205.html

时间: 2024-11-02 15:37:30

[Luogu 2486] SDOI2011 染色的相关文章

luogu P2486 [SDOI2011]染色

树剖做法: 就是两个dfs+一个线段树 难度的取决基本==线段树的维护难度 所以对有点线段树基础的,树剖也不难做吧 这里操作有二 一:两点间路径染色 线段树的区间赋值操作 二:查询路径段的个数 考虑线段树如何做 我们发现两端区间的合并取决于他们相连接的那两个颜色 比如这张图 他两边区间合并的时候,完全就是左区间答案+右区间答案也就是2+2 但是这样 他们合并的答案就是2+2-1了也就是中间连接的两个颜色相同时要减1 明白了这个pushup也就不难写了 这里在说一下查询操作 由于是分开查询的,所以

P2486 [SDOI2011]染色

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 C 2 1 1 Q 3 5 C 5 1 2 Q 3 5 输出样例#1: 复制 3 1 2 说明 题解:树连剖分+细节,用二进制记录某段染色情况,并记录最边上的颜色,不

[SDOI2011]染色(树链剖分)

[SDOI2011]染色(luogu) Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段), 如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完成这m个操作. input 第一行包含2个整数n和m,分别表示节点数和操作数: 第二行包含n个正整数表示n个节点的初始颜色 下面 行每行包含两个整数x和y,表示x和y之间有一条无向

BZOJ 2243: [SDOI2011]染色 树链剖分

2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 1886  Solved: 752[Submit][Status] Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完成这m个操作. In

bzoj 2243: [SDOI2011]染色 线段树区间合并+树链剖分

2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 7925  Solved: 2975[Submit][Status][Discuss] Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完

bzoj-2243 2243: [SDOI2011]染色(树链剖分)

题目链接: 2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 6267  Solved: 2291 Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完成这m个操作. Input 第一行包含

bzoj2243:[SDOI2011]染色

链剖就可以了.一开始的想法错了.但也非常接近了.妈呀调的要死...然后把字体再缩小一号查错起来比较容易QAQ. #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> using namespace std; #define rep(i,s,t) for(int i=s;i<=t;i++) #define dwn(i,s,t) for(int i=s;i>

bzoj2243 [SDOI2011]染色 动态树

#include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 110000 int pre[N],ch[N][2]; int e[N],ne[N*2],v[N*2]; int nn,m; int col[N]; int lc[N],sm[N],rc[N],num[N]; int rt[N],n; int qu[N

2243: [SDOI2011]染色(树链剖分+线段树)

2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 8400  Solved: 3150[Submit][Status][Discuss] Description 给定一棵有n个节点的无根树和m个操作,操作有2类: 1.将节点a到节点b路径上所有点都染成颜色c: 2.询问节点a到节点b路径上的颜色段数量(连续相同颜色被认为是同一段),如“112221”由3段组成:“11”.“222”和“1”. 请你写一个程序依次完