题目1 : 彩色的树

时间限制:2000ms
单点时限:1000ms
内存限制:256MB

描述

给定一棵n个节点的树，节点编号为1, 2, …, n。树中有n - 1条边，任意两个节点间恰好有一条路径。这是一棵彩色的树，每个节点恰好可以染一种颜色。初始时，所有节点的颜色都为0。现在需要实现两种操作:

1. 改变节点x的颜色为y；

2. 询问整棵树被划分成了多少棵颜色相同的子树。即每棵子树内的节点颜色都相同，而相邻子树的颜色不同。

输入

第一行一个整数T，表示数据组数，以下是T组数据。

每组数据第一行是n，表示树的节点个数。接下来n - 1行每行两个数i和j，表示节点i和j间有一条边。接下来是一个数q，表示操作数。之后q行，每行表示以下两种操作之一：

1. 若为"1"，则询问划分的子树个数。

2. 若为"2 x y"，则将节点x的颜色改为y。

输出

每组数据的第一行为"Case #X:"，X为测试数据编号，从1开始。

接下来的每一行，对于每一个询问，输出一个整数，为划分成的子树个数。

数据范围

1 ≤ T ≤ 20

0 ≤ y ≤ 100000

小数据

1 ≤ n, q ≤ 5000

大数据

1 ≤ n, q ≤ 100000

样例输入
2
3
1 2
2 3
3
1
2 2 1
1
5
1 2
2 3
2 4
2 5
4
1
2 2 1
2 3 2
1
样例输出
Case #1:
1
3
Case #2:
1
5

解答思路
本题主要解决任意时刻树中有多少棵颜色相同的子树，可以记录每一个节点的邻居节点，在每次更新一个节点的颜色的时候，都重新计算有多少棵同色子树。
整棵树抽象化成一颗有根树，节点i的父节点为father[i]，son_color[i][color]表示节点i的直接子节点中颜色为color的节点个数。
neighbor[i]表示节点i的邻居节点集合，color[i]表示节点i的颜色，new_color表示节点i新获得的颜色，color_tree_num表示树中有多少棵同色子树，初始为1。
如果color[i] == new_color，color_tree_num不变；
如果color[i] != new_color,节点获得了新颜色，需要更新color_tree_num
　　如果节点i是非根节点（father[i] != 0）
　　　　节点i更新前的颜色和父节点颜色相同的话，更新颜色后将被划为不同的颜色树，故 color_tree_num + 1;
　　　　节点i更新前颜色和父节点不同，更新后相同的话，将被划为同一颗颜色树，故 color_tree_num - 1;
　　　　更新父节点的子树颜色数：
　　　　　　son_color[father[i]][color[i]] - 1
　　　　　　son_color[father[i]][new_color] + 1
　　
　　节点i和它的颜色为color[i]的子树将被划为不同的颜色树， color_tree_num + son_color[i][color[i]]
　　节点i和它的颜色为new_color的子树将被划为同一颗颜色树， color_tree_num - son_color[i][new_color]
最后更新节点i的颜色 color[i] = new_color
代码如下
　　　　
#include<iostream>
#include<cstring>
#include<cstdio>
#include<map>
using namespace std;
const int max_N = 100001;
int color[max_N];
int edge[max_N - 1][2];
int father[max_N];
map<int, int> son_color[max_N];
struct Node{
    int n;
    int *p;
}neighbor[max_N];
void init_father(int cur, int father_node){
    for(int i = 0, n = neighbor[cur].n, *p = neighbor[cur].p; i < n; ++i){
        int son = p[i];
        if(son != father_node){
            father[son] = cur;
            init_father(son, cur);
        }
    }
}
int main(){
    int T, n, q, i, j, query, c;
    scanf("%d", &T);
    for(int k = 1; k <= T; k++){
        memset(color, 0, sizeof(color));
        memset(father, 0, sizeof(father));
        for(i = 1; i < max_N; ++i){
            son_color[i].clear();
        }
        scanf("%d", &n);
        for(int t = 1; t < n; ++t){
            scanf("%d%d", &i, &j);
            color[i]++;
            color[j]++;
            edge[t][0] = i;
            edge[t][1] = j;
        }
        for(i = 1; i <= n; i++){
            neighbor[i].n = 0;
            neighbor[i].p = new int[color[i]];
        }
        for(int t = 1; t < n; t++){
            i = edge[t][0], j = edge[t][1];
            neighbor[i].p[neighbor[i].n++] = j;
            neighbor[j].p[neighbor[j].n++] = i;
        }
        init_father(1, 0);
        memset(color, 0, sizeof(color));
        for(i = 1; i <= n; ++i){
            if(father[i] == 0){
                son_color[i][0] = neighbor[i].n;
            }else{
                son_color[i][0] = neighbor[i].n - 1;
            }
            delete[] neighbor[i].p;
        }
        scanf("%d", &q);
        printf("Case #%d:\n", k);
        int ans = 1;
        for(int t = 0; t < q; t++){
            scanf("%d", &query);
            if(query == 1){
                printf("%d\n", ans);
            }else{//query == 2
                scanf("%d%d", &i, &c);
                if(color[i] != c){
                    j = father[i];
                    if(j != 0){
                        if(color[i] == color[j]){
                            ++ans;
                        }else if(color[j] == c){
                            --ans;
                        }
                        son_color[j][color[i]]--;
                        son_color[j][c]++;
                    }
                    ans += son_color[i][color[i]];
                    ans -= son_color[i][c];
                    color[i] = c;
                }
            }
        }
    }
    return 0;
}