BZOJ2243: [SDOI2011]染色（树链剖分/LCT）

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之间有一条无向边。

下面行每行描述一个操作：

“C a b c”表示这是一个染色操作，把节点a到节点b路径上所有点（包括a和b）都染成颜色c；

“Q a b”表示这是一个询问操作，询问节点a到节点b（包括a和b）路径上的颜色段数量。

Output

对于每个询问操作，输出一行答案。

Sample Input

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

Sample Output

3
1
2

解题思路：

1.树链剖分：

只修改链，不修改关系，树链剖分。

线段树维护树链剖分序。

时间复杂度O(nlogn²)

代码：

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #define lll spc<<1

 #define rrr spc<<1|1

 using std::min;

 using std::max;

 using std::swap;

 struct trnt{

     int lc;

     int rc;

     int lzt;

     int val;

 }tr[];

 struct pnt{

     int hd;

     int col;

     int mxs;

     int ind;

     int fa;

     int tp;

     int wgt;

     int dp;

 }p[];

 struct ent{

     int twd;

     int lst;

 }e[];

 struct bag{

     int cl;

     int cr;

     int vl;

     bag friend operator + (bag a,bag b)

     {

         if(!a.cl)

             a.cl=b.cl;

         if(!b.cr)

             b.cr=a.cr;

         return (bag){a.cl,b.cr,(a.vl+b.vl-(a.cr==b.cl)<)?:(a.vl+b.vl-(a.cr==b.cl))};

     }

 };

 int n,m;

 int cnt;

 int dfn;

 char cmd[];

 void ade(int f,int t)

 {

     cnt++;

     e[cnt].twd=t;

     e[cnt].lst=p[f].hd;

     p[f].hd=cnt;

     return ;

 }

 void pushup(int spc)

 {

     tr[spc].lc=tr[lll].lc;

     tr[spc].rc=tr[rrr].rc;

     tr[spc].val=tr[lll].val+tr[rrr].val-(tr[lll].rc==tr[rrr].lc);

     return ;

 }

 void chg(int spc,int v)

 {

     tr[spc].val=;

     tr[spc].lc=tr[spc].rc=v;

     tr[spc].lzt=v;

     return ;

 }

 void pushdown(int spc)

 {

     if(tr[spc].lzt)

     {

         chg(lll,tr[spc].lzt);

         chg(rrr,tr[spc].lzt);

         tr[spc].lzt=;

     }

     return ;

 }

 void build(int l,int r,int pos,int spc,int v)

 {

     if(l==r)

     {

         tr[spc].lc=tr[spc].rc=v;

         tr[spc].val=;

         tr[spc].lzt=;

         return ;

     }

     int mid=(l+r)>>;

     if(pos<=mid)

         build(l,mid,pos,lll,v);

     else

         build(mid+,r,pos,rrr,v);

     pushup(spc);

     return ;

 }

 void Basic_dfs(int x,int f)

 {

     p[x].dp=p[f].dp+;

     p[x].fa=f;

     int maxs=-;

     p[x].wgt=;

     for(int i=p[x].hd;i;i=e[i].lst)

     {

         int to=e[i].twd;

         if(to==f)

             continue;

         Basic_dfs(to,x);

         p[x].wgt+=p[to].wgt;

         if(p[to].wgt>maxs)

         {

             maxs=p[to].wgt;

             p[x].mxs=to;

         }

     }

     return ;

 }

 void Build_dfs(int x,int tpl)

 {

     if(!x)

         return ;

     p[x].tp=tpl;

     p[x].ind=++dfn;

     build(,n,dfn,,p[x].col);

     Build_dfs(p[x].mxs,tpl);

     for(int i=p[x].hd;i;i=e[i].lst)

     {

         int to=e[i].twd;

         if(p[to].ind)

             continue;

         Build_dfs(to,to);

     }

 }

 void update(int l,int r,int ll,int rr,int spc,int v)

 {

     if(ll>rr)

         return ;

     if(l>rr||ll>r)

         return ;

     pushdown(spc);

     if(ll<=l&&r<=rr)

     {

         chg(spc,v);

         return ;

     }

     int mid=(l+r)>>;

     update(l,mid,ll,rr,lll,v);

     update(mid+,r,ll,rr,rrr,v);

     pushup(spc);

     return ;

 }

 bag mk(int a,int b,int c)

 {

     return (bag){a,b,c};

 }

 bag ask(int l,int r,int ll,int rr,int spc)

 {

     if(l>rr||ll>r)

         return mk(,,);

     pushdown(spc);

     if(ll<=l&&r<=rr)

         return mk(tr[spc].lc,tr[spc].rc,tr[spc].val);

     int mid=(l+r)>>;

     return ask(l,mid,ll,rr,lll)+ask(mid+,r,ll,rr,rrr);

 }

 int lca(int x,int y)

 {

     while(p[x].tp!=p[y].tp)

     {

         if(p[p[x].tp].dp<p[p[y].tp].dp)

             swap(x,y);

         x=p[p[x].tp].fa;

     }

     if(p[x].dp>p[y].dp)

         swap(x,y);

     return x;

 }

 void rvs(bag &a)

 {

     swap(a.cl,a.cr);

     return ;

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;i++)

         scanf("%d",&p[i].col);

     for(int i=;i<n;i++)

     {

         int a,b;

         scanf("%d%d",&a,&b);

         ade(a,b);

         ade(b,a);

     }

     Basic_dfs(,);

     Build_dfs(,);

     while(m--)

     {

         scanf("%s",cmd);

         if(cmd[]=='C')

         {

             int a,b,c;

             scanf("%d%d%d",&a,&b,&c);

             int f=lca(a,b);

             while(p[a].tp!=p[f].tp)

             {

                 update(,dfn,p[p[a].tp].ind,p[a].ind,,c);

                 a=p[p[a].tp].fa;

             }

             update(,dfn,p[f].ind,p[a].ind,,c);

             a=b;

             while(p[a].tp!=p[f].tp)

             {

                 update(,dfn,p[p[a].tp].ind,p[a].ind,,c);

                 a=p[p[a].tp].fa;

             }

             update(,dfn,p[f].ind,p[a].ind,,c);

         }

         if(cmd[]=='Q')

         {

             int a,b;

             scanf("%d%d",&a,&b);

             int f=lca(a,b);

             bag ans=(bag){,,};

             while(p[a].tp!=p[f].tp)

             {

                 ans=ask(,dfn,p[p[a].tp].ind,p[a].ind,)+ans;

                 a=p[p[a].tp].fa;

             }

             if(a!=f)

                 ans=ask(,dfn,p[f].ind+,p[a].ind,)+ans;

             bag ams=(bag){,,};

             a=b;

             while(p[a].tp!=p[f].tp)

             {

                 ams=ask(,dfn,p[p[a].tp].ind,p[a].ind,)+ams;

                 a=p[p[a].tp].fa;

             }

             if(a!=f)

                 ams=ask(,dfn,p[f].ind+,p[a].ind,)+ams;

             ans=ask(,dfn,p[f].ind,p[f].ind,)+ans;

             rvs(ans);

             ans=ans+ams;

             printf("%d\n",ans.vl);

         }

     }

     return ;

 }

2.LCT：

比较板子了。

每次维护左侧颜色和右侧颜色（注意特判0节点值）

反转时要反转左右颜色。

路径提取一下输出答案就好了。

时间复杂度O(nlogn)理论上比树剖快

但是：

蒟蒻的我：splay常数居然比logn大

代码：

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #define lll tr[spc].ch[0]

 #define rrr tr[spc].ch[1]

 #define ls ch[0]

 #define rs ch[1]

 using std::swap;

 struct trnt{

     int ch[];

     int fa;

     int lzt;

     int chg;

     int sum;

     int val;

     int lc;

     int rc;

     int wgt;

     bool anc;

 }tr[];

 int n,m;

 char cmd[];

 bool whc(int spc)

 {

     return tr[tr[spc].fa].rs==spc;

 }

 void pushup(int spc)

 {

     tr[spc].wgt=tr[lll].wgt+tr[rrr].wgt+;

     tr[spc].sum=tr[lll].sum+tr[rrr].sum+-(tr[lll].rc==tr[spc].val)-(tr[rrr].lc==tr[spc].val);

     tr[spc].lc=tr[lll].lc?tr[lll].lc:tr[spc].val;

     tr[spc].rc=tr[rrr].rc?tr[rrr].rc:tr[spc].val;

     return ;

 }

 void trr(int spc)

 {

     if(!spc)

         return ;

     swap(lll,rrr);

     swap(tr[spc].lc,tr[spc].rc);

     tr[spc].lzt^=;

     return ;

 }

 void upd(int spc,int v)

 {

     if(!spc)

         return ;

     tr[spc].val=tr[spc].lc=tr[spc].rc=v;

     tr[spc].sum=;

     tr[spc].chg=v;

     return ;

 }

 void pushdown(int spc)

 {

     if(tr[spc].lzt)

     {

         trr(lll);

         trr(rrr);

         tr[spc].lzt=;

     }

     if(tr[spc].chg)

     {

         upd(lll,tr[spc].chg);

         upd(rrr,tr[spc].chg);

         tr[spc].chg=;

     }

     return ;

 }

 void recal(int spc)

 {

     if(!tr[spc].anc)

         recal(tr[spc].fa);

     pushdown(spc);

     return ;

 }

 void rotate(int spc)

 {

     int f=tr[spc].fa;

     bool k=whc(spc);

     tr[f].ch[k]=tr[spc].ch[!k];

     tr[spc].ch[!k]=f;

     if(tr[f].anc)

     {

         tr[spc].anc=;

         tr[f].anc=;

     }else

         tr[tr[f].fa].ch[whc(f)]=spc;

     tr[spc].fa=tr[f].fa;

     tr[f].fa=spc;

     tr[tr[f].ch[k]].fa=f;

     pushup(f);

     pushup(spc);

     return ;

 }

 void splay(int spc)

 {

     recal(spc);

     while(!tr[spc].anc)

     {

         int f=tr[spc].fa;

         if(tr[f].anc)

         {

             rotate(spc);

             return ;

         }

         if(whc(spc)^whc(f))

             rotate(spc);

         else

             rotate(f);

         rotate(spc);

     }

     return ;

 }

 void access(int spc)

 {

     int lst=;

     while(spc)

     {

         splay(spc);

         tr[rrr].anc=;

         tr[lst].anc=;

         rrr=lst;

         pushup(spc);

         lst=spc;

         spc=tr[spc].fa;

     }

     return ;

 }

 void Mtr(int spc)

 {

     access(spc);

     splay(spc);

     trr(spc);

     return ;

 }

 void split(int x,int y)

 {

     Mtr(x);

     access(y);

     splay(y);

     return ;

 }

 void link(int x,int y)

 {

     Mtr(x);

     tr[x].fa=y;

     return;

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;i++)

     {

         tr[i].anc=;

         scanf("%d",&tr[i].val);

         tr[i].lc=tr[i].rc=tr[i].val;

     }

     for(int i=;i<n;i++)

     {

         int a,b;

         scanf("%d%d",&a,&b);

         link(a,b);

     }

     while(m--)

     {

         scanf("%s",cmd);

         if(cmd[]=='Q')

         {

             int a,b;

             scanf("%d%d",&a,&b);

             split(a,b);

             printf("%d\n",tr[b].sum);

         }else{

             int a,b,c;

             scanf("%d%d%d",&a,&b,&c);

             split(a,b);

             upd(b,c);

         }

     }

     return ;

 }