Codechef Sad Pairs——圆方树+虚树+树上差分

SADPAIRS

删点不连通，点双，圆方树

非割点：没有影响

割点：子树DP一下

有不同颜色，所以建立虚树

在圆方树上dfs时候

如果当前点是割点

1.统计当前颜色虚树上的不连通点对，树形DP即可

2.统计所有颜色的虚树上的不连通点对。。。。

一个麻烦事是，虚树上一条边上选择一个原树割点，都会对这个虚树造成相同的影响（两边sz乘积）

n,m 2e5

树上差分

设虚树上,(x,y)的边，x是y的父亲

原树上，x的位置减去贡献，y的原树father位置加上贡献

最后dfs扫一遍就行了。

实际上麻烦事挺多：

1.不保证连通，所以圆方树森林，虚树森林

2.LCA可能是多个颜色虚树的节点，dp[x]是累计的

3.x断线只有的ans：原来本身不连通的+经过x的+x和同种别的颜色 （后面两个都是自己连通块内部）

错点：

1.dfn的cmp没有写进sort函数

2.vis在dfs时候没有赋值导致循环多遍

3.存在孤立点，不在任意一个DCC中，赋值typ=1的时候，特殊考虑到（其实typ=1没有意义）

4.统计的是当前连通块当前颜色的数量，所以初值：sz[x]=(co[x]==now)

5.答案爆int。两块sz相乘也会爆int

代码：

#include<bits/stdc++.h>
#define il inline
#define reg register int
#define numb (ch^'0')
using namespace std;
typedef long long ll;
il void rd(int &x){
    char ch;bool fl=false;
    while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
    for(x=numb;isdigit(ch=getchar());x=x*+numb);
    (fl==true)&&(x=-x);
}
namespace Miracle{
const int N=4e5+;
int n,m;
int a[N][];
int kind;//species
struct node{
    int nxt,to;
}e[*N];
int hd[N],cnt;
void add(int x,int y){
    e[++cnt].nxt=hd[x];
    e[cnt].to=y;
    hd[x]=cnt;
}
int dfn[N],low[N],df,dfn2[N];
int co[N],b[N],dcc;
vector<int>mem[N];
ll preno;
vector<int>be[N];
int typ[N];//1:yuan 0:fang
int sta[N],top;
void tarjan(int x){
    dfn[x]=low[x]=++df;
    sta[++top]=x;
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
            if(low[y]>=dfn[x]){
                ++dcc;
                int z;
                do{
                    z=sta[top];
                    mem[dcc].push_back(z);
                    --top;
                }while(z!=y);
                mem[dcc].push_back(x);
            }
        }else low[x]=min(low[x],dfn[y]);
    }
}
int belong[N];
int dep[N],fa[N][];
void dfs1(int x,int bl,int d){
    belong[x]=bl;
    dfn[x]=++df;
    dep[x]=d;
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(!dfn[y]){
            fa[y][]=x;
            dfs1(y,bl,d+);
        }
    }
    dfn2[x]=df;
}
ll dp[N];
ll tag[N];
int vis[N];
ll sz[N];
void finsz(int x,int now){
    vis[x]=now+kind;
    sz[x]=(co[x]==now);
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        finsz(y,now);
        sz[x]+=sz[y];
    }
}
void dfs2(int x,ll totsz,int now){
//    cout<<" dfs2 "<<x<<" : "<<totsz<<" "<<now<<endl;
    ll presz=;
    //dp[x]=0;
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        dfs2(y,totsz,now);
        tag[x]-=(totsz-sz[y])*sz[y];
        //cout<<" fa[y][0] "<<fa[y][0]<<endl;
        tag[fa[y][]]+=(totsz-sz[y])*sz[y];
        dp[x]+=presz*sz[y];
        presz+=sz[y];
    }
    dp[x]+=presz*(totsz-sz[x]);
    if(co[x]==now)dp[x]+=totsz-typ[x];
}
ll ans[N];

void sol(int x,int fa){
    vis[x]=;
    for(reg i=hd[x];i;i=e[i].nxt){
        int y=e[i].to;
        if(y==fa) continue;
        sol(y,x);
        tag[x]+=tag[y];
    }
    //cout<<" x "<<x<<" : "<<preno+dp[x]+tag[x]<<endl;
    if(typ[x]) ans[x]=preno+dp[x]+tag[x];
}
bool cmp(int x,int y){
    return dfn[x]<dfn[y];
}
int lca(int x,int y){
    if(dep[x]<dep[y]) swap(x,y);
    for(reg j=;j>=;--j){
        if(dep[fa[x][j]]>=dep[y]) x=fa[x][j];
    }
    if(x==y) return x;
    for(reg j=;j>=;--j){
        if(fa[x][j]!=fa[y][j]) x=fa[x][j],y=fa[y][j];
    }
    return fa[x][];
}
int main(){
    rd(n);rd(m);
    int tot=;
    for(reg i=;i<=n;++i) rd(co[i]),b[++tot]=co[i];
    sort(b+,b+tot+);
    tot=unique(b+,b+tot+)-b-;
    kind=tot;
    for(reg i=;i<=n;++i){
        typ[i]=;

        co[i]=lower_bound(b+,b+tot+,co[i])-b;
        //cout<<co[i]<<" ";
        be[co[i]].push_back(i);
    }
   // cout<<endl;

    int x,y;
    for(reg i=;i<=m;++i){
        rd(x);rd(y);add(x,y);add(y,x);
    }

    for(reg i=;i<=n;++i){
        if(!dfn[i]) tarjan(i);
    }
    memset(hd,,sizeof hd);
    memset(dfn,,sizeof dfn);
    df=;cnt=;
    tot=n;
    int edge=;
    //cout<<" dcc "<<dcc<<endl;
    for(reg i=;i<=dcc;++i){
        ++tot;
        typ[tot]=;
        //cout<<"num ******************"<<tot<<endl;
        for(reg j=;j<(int)mem[i].size();++j){
        //    cout<<mem[i][j]<<" ";
            typ[mem[i][j]]=;
            a[++edge][]=tot;
            a[edge][]=mem[i][j];
            add(tot,mem[i][j]);
            add(mem[i][j],tot);
        }
        //cout<<endl;
    }
   // cout<<" tot "<<tot<<endl;
    int kuai=;
    for(reg i=;i<=tot;++i){
        if(!dfn[i]){
            dfs1(i,++kuai,);
        }
    }
   // cout<<" kuai "<<kuai<<endl;
    memset(hd,,sizeof hd);
    cnt=;

    for(reg j=;j<=;++j){
        for(reg i=;i<=n;++i){
            fa[i][j]=fa[fa[i][j-]][j-];
        }
    }
    for(reg i=;i<=kind;++i){
        //cout<<" kind i "<<i<<" ------------------------------- "<<endl;
        int num=be[i].size();
        sort(be[i].begin(),be[i].end(),cmp);
        for(reg j=;j<num;++j){
            vis[be[i][j]]=vis[be[i][j-]]=i;
            if(belong[be[i][j]]==belong[be[i][j-]]){
                int anc=lca(be[i][j],be[i][j-]);
                if(vis[anc]!=i){
                        vis[anc]=i;
                    be[i].push_back(anc);
                }
            }
        }
        sort(be[i].begin(),be[i].end(),cmp);
        top=;

        for(reg j=;j<(int)be[i].size();++j){
        //    cout<<" j "<<be[i][j]<<endl;
            while(top&&(!(dfn[sta[top]]<=dfn[be[i][j]]&&dfn[be[i][j]]<=dfn2[sta[top]])))--top;
            if(top) add(sta[top],be[i][j]);
            sta[++top]=be[i][j];
        }

        ll has=;
        for(reg j=;j<(int)be[i].size();++j){
            if(vis[be[i][j]]!=i+kind){
                finsz(be[i][j],i);
            //    cout<<" totsz "<<be[i][j]<<" "<<typ[be[i][j]]<<" "<<sz[be[i][j]]<<endl;
                dfs2(be[i][j],sz[be[i][j]],i);
                preno+=has*sz[be[i][j]];
                has+=sz[be[i][j]];
            }
        }

        for(reg j=;j<(int)be[i].size();++j){
            hd[be[i][j]]=;
            sz[be[i][j]]=;
        }
        cnt=;
    }
//    cout<<" preno "<<preno<<endl;
//    for(reg i=1;i<=tot;++i){
//        printf("%d dp %lld %lld\n",i,dp[i],tag[i]);
//    }
    memset(vis,,sizeof vis);
    for(reg i=;i<=edge;++i){
        add(a[i][],a[i][]);
        add(a[i][],a[i][]);
    }
    for(reg i=;i<=tot;++i){
        if(!vis[i]){
            sol(i,);
        }
    }
    for(reg i=;i<=n;++i){
        printf("%lld\n",ans[i]);
    }
    return ;
}

}
signed main(){
    Miracle::main();
    return ;
}

/*
   Author: *Miracle*
   Date: 2019/2/19 17:48:21
*/