Educational Codeforces Round 6 E. New Year Tree

题意

给出一个有根树，给出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;
    }