2243: [SDOI2011]染色

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

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

“C a b c”表示这是一个染色操作,把节点a到节点b路径上所有点(包括a和b)都染成颜色c;

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

 

Output

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

 

 

题解: 这个题就是树链剖分+线段树的问题,主要是线段树的合并的问题。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
#include<stdio.h>
#include<string.h>
#include<vector>
#include<map>
#include<algorithm>
#include<iostream>
using namespace std;
const int N=2e6+4;
int n,w,_max,_sum;
int flag,Rmost,Lmost;
int sumv[N],maxv[N];
int rank[N],tid[N],top[N],dp[N],fa[N],a[N],siz[N],son[N];
int tot;
int head[N];
int c;
int L[N],R[N];
int setv[N];
int tim;
struct node
{
    int u,v,next;
}edge[N];
void inist()
{
    memset(head,-1,sizeof(head));
    for(int i=1;i<N;i++) setv[i]=-1;
}
void addedge(int u,int v)
{
    edge[tot].u=u; edge[tot].v=v;
    edge[tot].next=head[u]; head[u]=tot++;
}
void build(int o,int l,int r)
{
    if(l==r)
    {
        sumv[o]=1;
        L[o]=a[rank[l]];  R[o]=a[rank[l]];
        return;
    }
    int mid=(r+l)/2;
    build(o*2,l,mid);
    build(o*2+1,mid+1,r);
    if(R[o*2]!=L[o*2+1])
    sumv[o]=sumv[o*2]+sumv[o*2+1];
    else sumv[o]=sumv[o*2]+sumv[o*2+1]-1;
    L[o]=L[o*2];
    R[o]=R[o*2+1];
}
void maintain(int o,int l,int r)
{
    int lc=o*2,rc=o*2+1;
    if(R[lc]!=L[rc]) sumv[o]=sumv[lc]+sumv[rc];
    else sumv[o]=sumv[lc]+sumv[rc]-1;
    L[o]=L[o*2];
    R[o]=R[o*2+1];
}
void query(int o,int l,int r,int ql,int qr)
{
    if(setv[o]!=-1)
    {
        if(flag==0) Lmost=setv[o],_sum+=1,Rmost=setv[o],flag=1;
        else
        {
            if(Rmost!=setv[o]) _sum=_sum+1;
            Rmost=setv[o];
        }
    }
    else if(ql<=l&&qr>=r)
    {
        if(flag==0)
        {
            Lmost=L[o];
            _sum+=sumv[o];
            Rmost=R[o];
            flag=1;
        }
        else
        {
            if(Rmost!=L[o]) _sum=_sum+sumv[o];
            else _sum+=sumv[o]-1;
            Rmost=R[o];
        }
    }
    else
    {
        int mid=(r+l)/2;
        if(ql<=mid) query(o*2,l,mid,ql,qr);
        if(qr>mid) query(o*2+1,mid+1,r,ql,qr);
    }
}
void Puttage(int o,int l,int r)
{
    int lc=o*2,rc=o*2+1;
    if(setv[o]!=-1)
    {
        setv[rc]=setv[lc]=setv[o];
        sumv[lc]=1; L[lc]=setv[lc]; R[lc]=setv[lc];
        sumv[rc]=1; L[rc]=setv[rc]; R[rc]=setv[rc];
        setv[o]=-1;
    }
}
void change(int o,int l,int r,int ql,int qr)
{
    if(ql>r||qr<l) return;
    if(ql<=l&&qr>=r)
    {
        setv[o]=c;
        sumv[o]=1; L[o]=c;  R[o]=c;
        return;
    }
    Puttage(o,l,r);
    int mid=(r+l)>>1;
    change(o*2,l,mid,ql,qr);
    change(o*2+1,mid+1,r,ql,qr);
    maintain(o,l,r);
}
void dfs1(int u,int father,int d)
{
    dp[u]=d;
    fa[u]=father;
    siz[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int y=edge[i].v;
        if(y!=father)
        {
            dfs1(y,u,d+1);
            siz[u]+=siz[y];
            if(son[u]==0||siz[y]>siz[son[u]])
            {
                son[u]=y;
            }
        }
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++tim;
    rank[tid[u]]=u;
    if(son[u]==0) return;
    dfs2(son[u],tp);
  
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int y=edge[i].v;
        if(y!=son[u]&&y!=fa[u])
        {
            dfs2(y,y);
        }
    }
}
void ANS(int u,int v)
{
    int L_now_1,R_now_1,L_now_2,R_now_2;
    int sum1=0,sum2=0;
    int flag1=0,flag2=0;
    int f1=top[u],f2=top[v];
    while(top[u]!=top[v])
    {
        if(dp[top[u]]>dp[top[v]])
        {
            if(flag1==0)
            {
                flag=0;
                _sum=0;
                query(1,1,n,tid[top[u]],tid[u]);
                sum1+=_sum;
                L_now_1=Lmost;
                flag1=1;
                u=fa[top[u]];
            }
            else
            {
                flag=0;
                _sum=0;
                query(1,1,n,tid[top[u]],tid[u]);
                R_now_1=Rmost;
                if(L_now_1==R_now_1)
                {
                    sum1=_sum+sum1-1;
                }
  
                else sum1+=_sum;
                L_now_1=Lmost;
                u=fa[top[u]];
            }
        }
        else
        {
            if(flag2==0)
            {
                flag=0;
                _sum=0;
                query(1,1,n,tid[top[v]],tid[v]);
                sum2+=_sum;
                L_now_2=Lmost;
                flag2=1;
                v=fa[top[v]];
            }
            else
            {
                flag=0;
                _sum=0;
                query(1,1,n,tid[top[v]],tid[v]);
                R_now_2=Rmost;
                if(L_now_2==R_now_2)
                {
                    sum2+=_sum-1;
                }
  
                else sum2+=_sum;
                 L_now_2=Lmost;
                v=fa[top[v]];
            }
        }
    }
    int temp=0;
    flag=0;
    _sum=0;
    query(1,1,n,min(tid[u],tid[v]),max(tid[u],tid[v]));
    if(tid[u]>tid[v])
    {
        if(flag1&&L_now_1==Rmost)
        {
            temp++;
        }
        if(flag2&&L_now_2==Lmost) temp++;
    }
    else
    {
        if(flag1&&L_now_1==Lmost)
        {
            temp++;
        }
        if(flag2&&L_now_2==Rmost) temp++;
    }
    printf("%d\n",sum1+sum2+_sum-temp);
}
void Chan(int u,int v)
{
    while(top[u]!=top[v])
    {
        if(dp[top[u]]<dp[top[v]])
        {
            swap(u,v);
        }
        change(1,1,n,tid[top[u]],tid[u]);
        u=fa[top[u]];
    }
    if(tid[u]>tid[v]) swap(u,v);
    change(1,1,n,tid[u],tid[v]);
}
int main()
{
    int q;
    cin>>n>>q;
    inist();
    for(int i=1;i<=n;i++) scanf("%d",&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);
    build(1,1,n);
    scanf("%d",&q);
    while(q--)
    {
        int u,v;
        char str[10];
        scanf("%s",str);
        if(str[0]=='C')
        {
            int a,b;
            scanf("%d%d%d",&a,&b,&c);
            Chan(a,b);
        }
        else if(str[0]=='Q')
        {
            scanf("%d%d",&u,&v);
            ANS(u,v);
        }
    }
}

 

  

 

posted @   Heilce  阅读(155)  评论(0编辑  收藏  举报
编辑推荐:
· 智能桌面机器人:用.NET IoT库控制舵机并多方法播放表情
· Linux glibc自带哈希表的用例及性能测试
· 深入理解 Mybatis 分库分表执行原理
· 如何打造一个高并发系统?
· .NET Core GC压缩(compact_phase)底层原理浅谈
阅读排行:
· DeepSeek火爆全网,官网宕机?本地部署一个随便玩「LLM探索」
· 开发者新选择:用DeepSeek实现Cursor级智能编程的免费方案
· 【译】.NET 升级助手现在支持升级到集中式包管理
· 独立开发经验谈:如何通过 Docker 让潜在客户快速体验你的系统
· Tinyfox 发生重大改版
点击右上角即可分享
微信分享提示