CodeForces - 620E New Year Tree （线段树+dfs序）

E. New Year Tree

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

The New Year holidays are over, but Resha doesn't want to throw away the New Year tree. He invited his best friends Kerim and Gural to help him to redecorate the New Year tree.

The New Year tree is an undirected tree with n vertices and root in the vertex1.

You should process the queries of the two types:

1. Change the colours of all vertices in the subtree of the vertexv to the colourc.
2. Find the number of different colours in the subtree of the vertexv.

Input

The first line contains two integers n, m (1 ≤ n, m ≤ 4·10⁵) — the number of vertices in the tree and the number of the queries.

The second line contains n integersc_i (1 ≤ c_i ≤ 60) — the colour of the i-th vertex.

Each of the next n - 1 lines contains two integersx_j, y_j (1 ≤ x_j, y_j ≤ n) — the vertices of the j-th edge. It is guaranteed that you are given correct undirected tree.

The last m lines contains the description of the queries. Each description starts with the integert_k (1 ≤ t_k ≤ 2) — the type of the k-th query. For the queries of the first type then follows two integersv_k, c_k (1 ≤ v_k ≤ n, 1 ≤ c_k ≤ 60) — the number of the vertex whose subtree will be recoloured with the colour c_k. For the queries of the second type then follows integerv_k (1 ≤ v_k ≤ n) — the number of the vertex for which subtree you should find the number of different colours.

Output

For each query of the second type print the integera — the number of different colours in the subtree of the vertex given in the query.

Each of the numbers should be printed on a separate line in order of query appearing in the input.

Sample test(s)

Input

7 10
1 1 1 1 1 1 1
1 2
1 3
1 4
3 5
3 6
3 7
1 3 2
2 1
1 4 3
2 1
1 2 5
2 1
1 6 4
2 1
2 2
2 3

Output

2
3
4
5
1
2

Input

23 30
1 2 2 6 5 3 2 1 1 1 2 4 5 3 4 4 3 3 3 3 3 4 6
1 2
1 3
1 4
2 5
2 6
3 7
3 8
4 9
4 10
4 11
6 12
6 13
7 14
7 15
7 16
8 17
8 18
10 19
10 20
10 21
11 22
11 23
2 1
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 4
1 12 1
1 13 1
1 14 1
1 15 1
1 16 1
1 17 1
1 18 1
1 19 1
1 20 1
1 21 1
1 22 1
1 23 1
2 1
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 4

Output

6
1
3
3
2
1
2
3
5
5
1
2
2
1
1
1
2
3

题意：给出n,m(n,m<=4·105)

再给出n个数表示第i个数的颜色为ci(ci<=60)

接下来是n-1条边连接这n个点（保证是树）

最后是m个操作，操作分为两种：

1.将点v和v的所有子树上的结点颜色都改为c；

2.询问结点v和v的所有子树中共有多少种不同的颜色。

分析：用dfs序建树，然后考虑到颜色最多为60种，用二进制表示每种颜色存在与否极为合适，不会超过long long,对于一个区间中的颜色种数就是左右区间的num值通过位运算或起来，这个数中1的个数就是答案。

#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
#define maxn 400010
#define LL long long
using namespace std;
LL c[maxn];
vector<int> v[maxn];
struct node
{
    LL num,fg;
}tree[maxn<<2];
struct Node
{
    int l,r;
}E[maxn];///每个点能管的范围，即包括自己所有的子树结点
LL val[maxn];
int time;
bool vis[maxn];
void dfs(int x)
{
    E[x].l=++time;
    val[time]=c[x];///记录time点的值，方便后面提取
    vis[x]=true;
    for(int i=0;i<v[x].size();i++)
    {
        int y=v[x][i];
        if(!vis[y]) dfs(y);
    }
    E[x].r=time;
}
void pushup(int id)
{
    tree[id].num=tree[id<<1].num|tree[id<<1|1].num;
}
void pushdown(int id)
{
    if(tree[id].fg)
    {
        tree[id<<1].num=tree[id<<1|1].num=(1ll<<tree[id].fg);
        tree[id<<1].fg=tree[id<<1|1].fg=tree[id].fg;
        tree[id].fg=0;
    }
}
void build(int id,int l,int r)
{
    tree[id].fg=0;
    if(l==r)
    {
        tree[id].num=(1ll<<val[l]);///由于超过int范围所以1的后面加ll
        return;
    }
    int mid=(l+r)>>1;
    build(id<<1,l,mid);
    build(id<<1|1,mid+1,r);
    pushup(id);
}
void update(int id,int L,int R,int l,int r,LL co)
{
    if(l<=L&&r>=R)
    {
        tree[id].fg=co;
        tree[id].num=(1ll<<co);
        return;
    }
    int mid=(L+R)>>1;
    pushdown(id);
    if(l<=mid) update(id<<1,L,mid,l,r,co);
    if(r>mid) update(id<<1|1,mid+1,R,l,r,co);
    pushup(id);
}
LL ans;
void solve(int id,int L,int R,int l,int r)
{
    if(l<=L&&r>=R)
    {
        ans|=tree[id].num;
        return;
    }
    pushdown(id);
    int mid=(L+R)>>1;
    if(l<=mid) solve(id<<1,L,mid,l,r);
    if(r>mid) solve(id<<1|1,mid+1,R,l,r);
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=0;i<maxn;i++) v[i].clear();
        for(int i=1;i<=n;i++) scanf("%lld",&c[i]);
        for(int i=1;i<n;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            v[x].push_back(y);
            v[y].push_back(x);
        }
        memset(vis,false,sizeof(vis));
        time=0;
        dfs(1);
        build(1,1,n);
        for(int i=1;i<=m;i++)
        {
            int d,x;
            LL co;
            scanf("%d%d",&d,&x);
            if(d==1)
            {
                scanf("%lld",&co);
                update(1,1,n,E[x].l,E[x].r,co);
            }
            else
            {
                ans=0;
                solve(1,1,n,E[x].l,E[x].r);
                int sum=0;
                for(;ans;ans-=ans&(-ans)) sum++;
                printf("%d\n",sum);
            }
        }
    }
    return 0;
}