首页 > 其他分享 >BZOJ 2243 [SDOI2011] 染色 (树链剖分)

BZOJ 2243 [SDOI2011] 染色 (树链剖分)

时间:2023-04-13 21:39:48浏览次数:48  
标签:rt f1 f2 剖分 int sum 树链 SDOI2011 include

题目地址:BZOJ 2243
普通的树链剖分,用线段树维护区间段数与最左边和最右边的颜色。然后当合并区间的时候判断一下左儿子的右端与右儿子的左端是否相同,若相同,则将和减去1.同样,在迭代求值的过程中,也要记录下上条链的最顶端的颜色。
代码如下:

#include <iostream>
#include <string.h>
#include <math.h>
#include <queue>
#include <algorithm>
#include <stdlib.h>
#include <map>
#include <set>
#include <stdio.h>
using namespace std;
#define LL long long
#define pi acos(-1.0)
//#pragma comment(linker, "/STACK:1024000000")
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
const double eqs=1e-3;
const int MAXN=100000+10;
#define root 1, tot, 1
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
int head[MAXN], cnt, tot;
int siz[MAXN], top[MAXN], w[MAXN], fa[MAXN], dep[MAXN], son[MAXN];
int sum[MAXN<<2], lnum[MAXN<<2], rnum[MAXN<<2], lazy[MAXN<<2];
int a[MAXN];
struct N
{
        int l, r, sum;
        N (){
                l=r=-1;
                sum=0;
        }
};
struct node
{
        int u, v, next;
}edge[MAXN<<1];
void add(int u, int v)
{
        edge[cnt].u=u;
        edge[cnt].v=v;
        edge[cnt].next=head[u];
        head[u]=cnt++;
}
void init()
{
        memset(head,-1,sizeof(head));
        cnt=tot=0;
        memset(son,0,sizeof(son));
        memset(sum,0,sizeof(sum));
        memset(lazy,-1,sizeof(lazy));
}
void dfs1(int u, int p)
{
        siz[u]=1;
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v==p) continue ;
                fa[v]=u;
                dep[v]=dep[u]+1;
                dfs1(v,u);
                siz[u]+=siz[v];
                if(siz[son[u]]<siz[v]) son[u]=v;
        }
}
void dfs2(int u, int tp)
{
        w[u]=++tot;
        top[u]=tp;
        if(son[u]) dfs2(son[u],tp);
        for(int i=head[u];i!=-1;i=edge[i].next){
                int v=edge[i].v;
                if(v!=fa[u]&&v!=son[u])
                        dfs2(v,v);
        }
}
struct Line_Tree
{
        void PushUp(int rt)
        {
                sum[rt]=sum[rt<<1]+sum[rt<<1|1]-(rnum[rt<<1]==lnum[rt<<1|1]);
                lnum[rt]=lnum[rt<<1];
                rnum[rt]=rnum[rt<<1|1];
        }
        void PushDown(int rt)
        {
                if(lazy[rt]!=-1){
                        lazy[rt<<1]=lazy[rt<<1|1]=lazy[rt];
                        sum[rt<<1]=sum[rt<<1|1]=1;
                        lnum[rt<<1]=rnum[rt<<1]=lnum[rt<<1|1]=rnum[rt<<1|1]=lazy[rt];
                        lazy[rt]=-1;
                }
        }
        void Update(int ll, int rr, int x, int l, int r, int rt)
        {
                if(ll<=l&&rr>=r){
                        lazy[rt]=x;
                        sum[rt]=1;
                        lnum[rt]=rnum[rt]=x;
                        return ;
                }
                int mid=l+r>>1;
                PushDown(rt);
                if(ll<=mid) Update(ll,rr,x,lson);
                if(rr>mid) Update(ll,rr,x,rson);
                PushUp(rt);
        }
        N Query(int ll, int rr, int l, int r, int rt)
        {
                if(ll<=l&&rr>=r){
                        N f;
                        f.l=lnum[rt];
                        f.r=rnum[rt];
                        f.sum=sum[rt];
                        return f;
                }
                int mid=l+r>>1, ans;
                N f, f1, f2;
                PushDown(rt);
                if(ll<=mid) f1=Query(ll,rr,lson);
                if(rr>mid) f2=Query(ll,rr,rson);
                f.sum=f1.sum+f2.sum-(f1.r==f2.l);
                f.l=f1.r==-1?f2.l:f1.l;
                f.r=f2.l==-1?f1.r:f2.r;
                return f;
        }
}lt;
void ChangeSolve(int u, int v, int x)
{
        int f1=top[u], f2=top[v];
        while(f1!=f2){
                if(dep[f1]<dep[f2]){
                        swap(u,v);
                        swap(f1,f2);
                }
                lt.Update(w[f1],w[u],x,root);
                u=fa[f1];f1=top[u];
        }
        if(dep[u]<dep[v]){
                swap(u,v);
        }
        lt.Update(w[v],w[u],x,root);
}
int QuerySolve(int u, int v)
{
        int f1=top[u], f2=top[v], ans=0, l=-1, r=-1;
        N f;
        while(f1!=f2){
                if(dep[f1]<dep[f2]){
                        swap(u,v);
                        swap(f1,f2);
                        swap(l,r);
                }
                f=lt.Query(w[f1],w[u],root);
                ans+=f.sum-(l==f.r);
                l=f.l;
                u=fa[f1];f1=top[u];
        }
        if(dep[u]<dep[v]){
                swap(u,v);
                swap(l,r);
        }
        f=lt.Query(w[v],w[u],root);
        return ans+f.sum-(l==f.r)-(r==f.l);
}
int main()
{
        int n, m, u, v, i, x;
        char s[10];
        while(scanf("%d%d",&n,&m)!=EOF){
                init();
                for(i=1;i<=n;i++){
                        scanf("%d",&a[i]);
                }
                for(i=1;i<n;i++){
                        scanf("%d%d",&u,&v);
                        add(u,v);
                        add(v,u);
                }
                dfs1(1,-1);
                dfs2(1,1);
                for(i=1;i<=n;i++){
                        lt.Update(w[i],w[i],a[i],root);
                }
                while(m--){
                        scanf("%s",s);
                        if(s[0]=='Q'){
                                scanf("%d%d",&u,&v);
                                printf("%d\n",QuerySolve(u,v));
                        }
                        else{
                                scanf("%d%d%d",&u,&v,&x);
                                ChangeSolve(u,v,x);
                        }
                }
        }
        return 0;
}

标签:rt,f1,f2,剖分,int,sum,树链,SDOI2011,include
From: https://blog.51cto.com/u_16070138/6188402

相关文章

  • SPOJ 375 QTREE系列-Query on a tree (树链剖分)
    题目地址:SPOJ375树链剖分第一发!果然是个貌似很高级的数据结构,其实就是把树的边从树形结构转化成了线性结构,从而可以用线段树或树状数组之类的数据结构进行快速维护。从而将时间缩到n*log(2*n).这题用的线段树维护的。代码如下:#include<iostream>#include<string.h......
  • BZOJ 1036 [ZJOI2008] 树的统计Count (树链剖分)
    题目地址:BZOJ1036树链剖分裸题,需要用线段树同时维护最大值与和值两个信息,只是代码量大一点而已。。代码如下:#include<iostream>#include<string.h>#include<math.h>#include<queue>#include<algorithm>#include<stdlib.h>#include<map>#include<set&g......
  • POJ 3237 Tree (树链剖分)
    题目地址:POJ3237这题用了一下午。。本来一直认为max和min两个数组是不用改的,只需要改lazy数组,然后在查询的时候利用lazy标记来返回max或-min,后来发现错的很严重。。这题要在pushdown中修改max和min数组,从而实现最大值取反。代码如下:#include<iostream>#include<strin......
  • P2490 [SDOI2011]黑白棋
    题意:一个1*n的棋盘上有k个棋子,一半是黑一半是白,并且是白黑白黑白黑...白黑的形式,A每次最多可以将d个白棋子向右移动,B每次最多可以将d个黑棋子向左移动,不能不移动棋子,谁最后无法移动棋子谁就输了,A先手,问有多少种布局可以使得A获胜SolutionNim-K博弈+动态规划可以把棋子之间的间......
  • bzoj1969. [AHOI2005] LANE 航线规划 树链剖分+离线逆向处理删边
    保证了无论怎么破坏航线,图都会是一个连通图也就是说,起码肯定有一棵生成树考虑在生成树上U,V之间加边,会对树上各个点的割边情况产生什么影响对于任意点对(u,v),如果它们之间的最短路径不经过从U到V的树上路径,那是没有影响的否则:关键路径的数目会减少减少了多少?U,V之间树上路径经......
  • [LNOI2014] LCA 树链剖分+离线处理+lca转化
    困困的开始了我的修炼树剖之旅途考虑怎么搞这个lca是说,习惯了倍增求lca,突然冒出这么一个东西还真不会搞那要么能一次性求很多个lca(?),要么把deep[lca(i,z)]这个东西转化......
  • 长链剖分总结
    长链剖分总结长链剖分,顾名思义,就是按照链长(即深度)把树剖成若干条链。具体的,定义每个点的儿子中,子树深度最大的点是重儿子,不断跳重儿子形成的链也就是重链。长链剖分的性......
  • 【hdu6547】Tree(树链剖分, 线段树区间根号)
    problemalgorihtm1、树链剖分什么是树链剖分(重链剖分)?树链,就是树上的路径。剖分,就是把路径分类为重链和轻链。对于树上的一个点,与其相连的边中,连向的节点子树大小最大(重儿子)......
  • [学习笔记] 树链剖分
    树链剖分的用处使用树剖将整棵树剖分为若干条链,组成线性结构,可以方便用其他的数据结构维护信息。一些定义重儿子:该节点的所有子节点中子树大小最大的点。轻儿子:该节点......
  • 树链剖分
    P2590「ZJOI2008」树的统计重剖后线段树单点修改,区间查询总和或最大值。P3178「HAOI2015」树上操作子树内DFS序显然连续。重剖后线段树单点修改,区间查询总和。因为......