CF1172E Nauuo and ODT LCT

自己独立想出来的，超级开心 

一开始想的是对于每一个点分别算这个点对答案的贡献. 

但是呢，我们发现由于每一条路径的贡献是该路径颜色种类数，而每个颜色可能出现多次，所以这样就特别不好算贡献. 

那么，还是上面那句话，由于算的是颜色种类，所以我们可以对每一个颜色种类单独算贡献. 

即不以点为单位去算，而是以颜色种类为单位去算.    

假设要算颜色为 $r$ 的贡献，那么必须保证每一个路径至少有一个端点在颜色 $r$ 构成的连通块中. 

这句话等同于不能出现两个端点都在非 $r$ 连通块的路径，即 $n^2-sum_{col[i] eq r}size[i]^2$   

对于每一个颜色都这么算就好了 ~ 

具体的话需要离线+撤销+LCT维护子树信息（就是那个平方和） 

然后还要用到那个点权转边权，每次只删除和父亲连边的那个套路 ~    

code: 

#include <cstdio> 
#include <vector>   
#include <cstring>  
#include <algorithm>  
#define N 600003  
#define LL long long  
#define lson t[x].ch[0] 
#define rson t[x].ch[1]         
#define setIO(s) freopen(s".in","r",stdin) ,freopen(s".out","w",stdout)   
using namespace std; 
LL ans,re[N];  
int edges;  
int fa[N],hd[N],to[N<<1],nex[N<<1],val[N],size[N],col[N],is[N];  
void add(int u,int v) 
{
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;   
}       
struct data 
{
    int u,v,tim;   
    data(int u=0,int v=0,int tim=0):u(u),v(v),tim(tim){}  
};   
vector<data>G[N];  
struct node  
{ 
    LL sqr;    
    int ch[2],rev,f,siz,son;   
}t[N];         
int get(int x) 
{
    return t[t[x].f].ch[1]==x; 
}
int isrt(int x) 
{
    return !(t[t[x].f].ch[0]==x||t[t[x].f].ch[1]==x);  
}
void pushup(int x) 
{
    t[x].siz=t[lson].siz+t[rson].siz+t[x].son+1;         
}
void rotate(int x) 
{
    int old=t[x].f,fold=t[old].f,which=get(x); 
    if(!isrt(old))   t[fold].ch[t[fold].ch[1]==old]=x;        
    t[old].ch[which]=t[x].ch[which^1],t[t[old].ch[which]].f=old; 
    t[x].ch[which^1]=old,t[old].f=x,t[x].f=fold; 
    pushup(old),pushup(x); 
}   
void splay(int x) 
{
    int u=x,fa; 
    for(;!isrt(u);u=t[u].f);            
    for(u=t[u].f;(fa=t[x].f)!=u;rotate(x))    
    {
        if(t[fa].f!=u)     
        { 
            rotate(get(fa)==get(x)?fa:x);  
        }
    }
}   
void Access(int x) 
{
    for(int y=0;x;y=x,x=t[x].f)    
    {
        splay(x); 
        if(rson) 
        {
            t[x].son+=t[rson].siz;            
            t[x].sqr+=(LL)t[rson].siz*t[rson].siz;       
        }
        if(y) 
        {
            t[x].son-=t[y].siz; 
            t[x].sqr-=(LL)t[y].siz*t[y].siz;    
        }
        rson=y;  
        pushup(x);  
    }
}   
void link(int x,int y) 
{                
    Access(x),splay(x);   
    t[y].f=x;   
    t[x].son+=t[y].siz;   
    t[x].sqr+=(LL)t[y].siz*t[y].siz;                  
    pushup(x);   
}
// x 与 x 的父亲 
void cut(int x) 
{ 
    Access(x),splay(x);   
    if(lson)       
    {
        t[lson].f=0;   
        lson=0;           
        pushup(x);  
    }   
}
int findroot(int x) 
{   
    Access(x),splay(x);    
    while(lson)  x=lson;    
    return x;  
}         
void turn_0(int x) 
{             
    Access(x),splay(x);  
    int now=t[x].siz;      
    ans-=t[x].sqr;                     
    if(fa[x])  link(fa[x],x);       
    int p=findroot(x);                  
    splay(p);       
    is[x]=0;                   
    p=is[p]?t[p].ch[1]:p;          
    int ori=t[p].siz;         
    ans-=(LL)(ori-now)*(ori-now);   
    ans+=(LL)ori*ori;         
}
void turn_1(int x) 
{                      
    int p=findroot(x);          
    splay(p);                              
    p=is[p]?t[p].ch[1]:p;                      
    int ori=t[p].siz;    
    ans-=(LL)ori*ori;    
    cut(x);    
    int now=t[x].siz;                   
    ans+=(LL)(ori-now)*(ori-now);        
    ans+=(LL)t[x].sqr;            
    is[x]=1; 
}
void dfs(int u,int ff) 
{    
    size[u]=1;
    fa[u]=t[u].f=ff;        
    for(int i=hd[u];i;i=nex[i]) 
    {
        int v=to[i]; 
        if(v==ff)    continue;   
        dfs(v,u);    
        size[u]+=size[v];  
        t[u].son+=size[v];  
        t[u].sqr+=(LL)size[v]*size[v];  
    }   
    pushup(u);  
}
int main() 
{ 
    // setIO("input"); 
    int i,j,n,m,mx=0;   
    scanf("%d%d",&n,&m);                  
    for(i=1;i<=n;++i)   
    {
        scanf("%d",&col[i]); 
        val[i]=col[i]; 
        mx=max(mx,col[i]);    
        G[val[i]].push_back(data(i,val[i],0));        
    }
    for(i=1;i<n;++i)   
    {
        int u,v;  
        scanf("%d%d",&u,&v);    
        add(u,v),add(v,u);  
    }   
    dfs(1,0);    
    for(i=1;i<=m;++i) 
    {
        int u,v; 
        scanf("%d%d",&u,&v);      
        mx=max(mx,v);  
        if(val[u]==v)   continue;   
        G[val[u]].push_back(data(u,v,i));       //  val[u]->v  
        G[v].push_back(data(u,v,i));            //  ?->v       
        val[u]=v;  
    }               
    for(i=1;i<=mx;++i) 
    { 
        ans=(LL)n*n; 
        LL pre=0;               
        for(j=0;j<G[i].size();++j) 
        {                
            if(G[i][j].v==i)             // 别的变成 i   (0->1)
            {           
                turn_1(G[i][j].u);            
            }
            else                         // i 变成别的   (1->0)
            {  
                turn_0(G[i][j].u);      
            }                                    
            re[G[i][j].tim]-=pre;   
            re[G[i][j].tim]+=(LL)n*n-ans;   
            pre=(LL)n*n-ans;   
        }                
        for(j=G[i].size()-1;j>=0;--j) 
        {
            if(G[i][j].v==i)             // 别的变成 i   (0->1)
            {           
                turn_0(G[i][j].u);            
            }
            else                         // i 变成别的   (1->0)
            {  
                turn_1(G[i][j].u);      
            }   
        }        
    }    
    printf("%lld
",re[0]);   
    for(i=1;i<=m;++i)  re[i]+=re[i-1], printf("%lld
",re[i]); 
    return 0; 
}