[BZOJ2001][HNOI2010]城市建设 分治最小生成树

有一个引理，就是做最小生成树的时候，假设有$m$条边权值不确定，是可以把整个图简化到边数只有$O(m)$级别的。
也就是说假如考虑分治，把修改的那些边看成不确定边，然后简化一下图，分治下一层的时候就大概只需要做边数只有分治区间大小级别的最小生成树，复杂度就能降到$O(m\log ^2m)$。
具体简化图的方法如下：
1. 先强制合并所有不确定边（把边权赋为$-\inf$），再做最小生成树，那么在当前在树上的不论不确定边权值如何变化都一定在树上，可以缩点。
2. 再强制不合并所有不确定边（把边权赋为$\inf$），做最小生成树，那么不在当前在树上的不论不确定边权值如何变化都一定不在树上，可以删边。

最后要把边集数组里边的顶点标号改成所在连通块的标号，开$\log$层并查集和$\log$层边集数组即可。然后写分治题要记得各种还原。。。
代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define PB push_back
#define MP make_pair
#define fs first
#define sc second
#define ll long long
#define N 20010
#define M 50010
using namespace std;
const int inf=1000000000;
int n,m,q,tw[M],d[M],c[M],w[M],fa[20][N],tfa[N];
ll sz[20][N];
bool chs[M],vis[M];
struct node
{
    int x,y;
}e[20][M];
int read()
{
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar()) if(ch=='-') f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
    return x*f;
}
int getfa(int *f,int v)
{
    if(f[v]==v) return v;
    return (f[v]=getfa(f,f[v]));
}
bool merge(int *f,int x,int y)
{
    if(getfa(f,x)==getfa(f,y)) return 0;
    f[f[x]]=f[y];
    return 1;
}
bool cmp(int p,int q)
{
    return w[p]<w[q];
}
void MST(vector<int> g,int *f,int dep)
{
    sort(g.begin(),g.end(),cmp);
    for(int i=0;i<g.size();i++)
        chs[g[i]]=(merge(f,e[dep][g[i]].x,e[dep][g[i]].y));
}
void solve(int dep,int L,int R,vector<int> u,vector<int> s);
void cal(int dep,int l,int r,int lx,int rx,vector<int> &u,vector<int> &s)
{
    vector<int> tu,ts;tu.clear();ts.clear();
    int lst=s.size();
    for(int i=l;i<=r;i++)
        vis[d[i]]=1;
    for(int i=lx;i<=rx;i++)
        if(!vis[d[i]]) s.PB(d[i]),vis[d[i]]=1;
    for(int i=min(l,lx);i<=max(r,rx);i++)
        vis[d[i]]=0;

    int tot=s.size();   
    for(int i=l;i<=r;i++)
        tw[i]=w[d[i]];
    for(int i=l;i<=r;i++)
        if(!vis[d[i]]) s.PB(d[i]),vis[d[i]]=1;
    for(int i=l;i<=r;i++)
        vis[d[i]]=0;
    for(int i=0;i<u.size();i++)
        tfa[u[i]]=fa[dep+1][u[i]]=u[i],sz[dep+1][u[i]]=sz[dep][u[i]];
    for(int i=l;i<=r;i++)
        w[d[i]]=-inf;
    MST(s,tfa,dep);
    for(int i=0;i<tot;i++)
        if(chs[s[i]]) 
        {
            int x=getfa(fa[dep+1],e[dep][s[i]].x),y=getfa(fa[dep+1],e[dep][s[i]].y);
            fa[dep+1][x]=y,sz[dep+1][y]+=sz[dep+1][x]+w[s[i]];
        }
    for(int i=0;i<u.size();i++)
        if(getfa(fa[dep+1],u[i])==u[i]) tu.PB(u[i]);
    for(int i=0;i<u.size();i++)
        tfa[u[i]]=fa[dep+1][u[i]];
    for(int i=l;i<=r;i++)
        w[d[i]]=inf;
    MST(s,tfa,dep);
    for(int i=0;i<tot;i++)
        if(chs[s[i]]) ts.PB(s[i]);
    for(int i=l;i<=r;i++)
        w[d[i]]=tw[i];
    for(int i=l;i<=r;i++)
        e[dep+1][d[i]].x=getfa(fa[dep+1],e[dep][d[i]].x),e[dep+1][d[i]].y=getfa(fa[dep+1],e[dep][d[i]].y);
    for(int i=0;i<ts.size();i++)
        e[dep+1][ts[i]].x=getfa(fa[dep+1],e[dep][ts[i]].x),e[dep+1][ts[i]].y=getfa(fa[dep+1],e[dep][ts[i]].y);
    solve(dep+1,l,r,tu,ts);
    while(s.size()>lst) s.pop_back();                
}
void solve(int dep,int L,int R,vector<int> u,vector<int> s)
{   
    if(L==R)
    {
        ll ans=0;
        w[d[L]]=c[L];
        s.PB(d[L]);
        MST(s,fa[dep],dep);
        for(int i=0;i<u.size();i++)
            ans+=sz[dep][u[i]];
        for(int i=0;i<s.size();i++)
            if(chs[s[i]]) ans+=w[s[i]];
        printf("%lld\n",ans);
        return ;    
    }
    int mid=(L+R)>>1;
    cal(dep,L,mid,mid+1,R,u,s);
    cal(dep,mid+1,R,L,mid,u,s);
}
int main()
{
    n=read();m=read();q=read();
    for(int i=1;i<=m;i++)
        e[0][i].x=read(),e[0][i].y=read(),w[i]=read();
    vector<int> uu,ss;uu.clear();ss.clear();
    for(int i=1;i<=q;i++)
        d[i]=read(),c[i]=read(),vis[d[i]]=1;
    for(int i=1;i<=m;i++)
        if(!vis[i]) ss.PB(i);
    memset(vis,0,sizeof(vis));  
    for(int i=1;i<=n;i++)
        uu.PB(i);
    cal(0,1,q,1,0,uu,ss);   
    return 0;       
}