题意
给出一个有根树，给出m个操作，操作1表示使得这一棵树的某一个节点的所有子树染上某一种颜色，操作2表示查询这个节点及其子树的颜色数量。
思路
对于一颗有根树来说，我们依靠dfs序就可以变换成为一个有序的序列，所以根据dfs序可以建立线段树。
对于线段树的操作，更新的话，区间更新，推lazy标记，问题是怎么去统计颜色的数量，这也关系到我们将怎么去推lazy标记。
如果单纯的修改，变换tree[root]=val这样，我们合并区间的时候，对于叶子节点的父亲来说可以合并，因为可以判断两个叶子是否相等，从而使得数量++，然而对于叶子的父亲的父亲，便没有办法统计不同的数目了。
我们进一步发现颜色只有60种，明显暗示你，状压思想。
所以改一下传统线段树更新方式，我们用位操作来更新即可，每一次取出来压好的状态，遍历1-60，有1的话答案加1即可。
ps：写这么久才发现的一个小tips：（wa了一发再tree更新上，注意线段树更新的时候，一般来讲如果区间更新的时候tree+=或者tree|=了，那么就是说直接对于这个区间做了影响，他的子树对他没有影响，所以没有pushup，同样，有pushup的时候，tree区间更新用=号。）
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<map>
//#include<regex>
#include<cstdio>
#define up(i,a,b) for(int i=a;i<b;i++)
#define dw(i,a,b) for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
int read()
{
char ch = getchar(); int x = 0, f = 1;
while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
int n, m;
const int N = 4e5 + 10;
ll lazy[N<<2];
ll tree[N<<2];
int st[N], ed[N];
struct {
int to, next;
}edge[2*N];
int head[N];
int cnt = 0;
int a[N];
void addedge(int u, int v)
{
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int num = 0;
void dfs(int u,int f)
{
st[u] = ++num;
for (int i = head[u]; ~i; i = edge[i].next)
{
if (edge[i].to != f)dfs(edge[i].to,u);
}
ed[u] = num;
}
void pushup(int root)
{
ll temp = 0; temp |= tree[lrt]; temp |= tree[rrt];
tree[root] = temp;
}
void pushdown(int root)
{
if (lazy[root])
{
lazy[lrt] = lazy[root];
lazy[rrt] = lazy[root];
tree[lrt] = lazy[root];
tree[rrt] = lazy[root];
lazy[root] = 0;
}
}
void build(int l, int r, int root)
{
lazy[root] = 0;
if (l == r)
{
tree[root] = 0;
return;
}
int mid = (l + r) >> 1;
build(lson);
build(rson);
pushup(root);
}
void update(int l, int r, int root, int lf, int rt,int val)
{
if (lf <= l && r <= rt)
{
tree[root] = (1ll << val);
lazy[root] = (1ll << val);
return;
}
pushdown(root);
int mid = (l + r) >> 1;
if (lf <= mid)update(lson, lf, rt, val);
if (rt > mid)update(rson, lf, rt, val);
pushup(root);
}
ll querry(int l, int r, int root, int lf, int rt)
{
if (lf <= l && r <= rt)
{
return tree[root];
}
pushdown(root);
int mid = (l + r) >> 1;
ll ans = 0;
if (lf <= mid)ans |= querry(lson, lf, rt);
if (rt > mid)ans |= querry(rson, lf, rt);
return ans;
}
int main()
{
n = read(); m = read();
int x, y;
memset(head, -1, sizeof(head));
up(i, 0, n)a[i] = read();
up(i, 0, n - 1)
{
x = read(), y = read();
addedge(x, y); addedge(y, x);
}
dfs(1, 0);
build(1, n, 1);
up(i, 0, n)update(1, n, 1, st[i + 1], st[i + 1], a[i]);
int op;
while (m--)
{
op = read();
if (op == 1)
{
x = read(), y = read();
update(1, n, 1, st[x], ed[x], y);
}
else
{
x = read();
ll ans = querry(1, n, 1, st[x], ed[x]);
int temp = 0;
upd(i, 1, 61)
{
if ((1ll << i)&ans)temp++;
}
printf("%d\n", temp);
}
}
return 0;
}