[HNOI2010] 城市建设_动态最小生成树（Dynamic_MST）

这个题。。。暴力单次修改\(O(n)\)，爆炸。。。
$
$
不过好在可以离线做
如果可以在 分治询问 的时候把图缩小的话就可以做了
硬着头皮把这个骚东西看完了
$
$
动态最小生成树
然后，就把它当板子写好了。。。
思路是这样的：
经过修改后会得到 \(K\) 个 \(MST\)，在这些 \(MST\) 中，有些边是反复在用的，有些边是一直没有用到的
那么考虑把这些边去除掉，就能把图给缩小
关键就是这么两个东西：

1. \(contraction\)
   处理必需边，将询问中的边权值设为 \(-inf\) ，做一遍 \(MST\) ，这时 \(MST\) 中的 非\(-inf\) 的边就是必需边
   把这些边两端的点缩起来（可以用并查集维护），顺便统计一下边权和，再将其他边连回来
   

2. \(reduction\)
   处理无用边将询问中的边权值设为inf，做 \(MST\) ，不在 \(MST\) 中的 非\(inf\) 的边就是无用边，可以直接删除
   

图片蒯自 顾昱洲_浅谈一类分治算法
$
$
这样子的话在每一层都可以去掉一些点和一些边，就能在分治询问的时候缩小图的规模
总结一下的话，大致流程就是这个样子的：

1. 当前递归区间 \([l,r]\)；
2. 若 \(l=r\) ，暴力修改，统计答案并 \(return\)；
3. \(contraction\)，\(reduction\)；
4. 递归 \([l,mid]\) ， \([mid+1,r]\)；

$
$

//made by Hero_of_Someone
//哎呀这个代码...懒得写归并了,排序都用 sort 凑合一下算了...
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define N (100010)
#define ll long long
#define inf 1ll<<54
#define RG register
using namespace std;
inline int gi(){ RG int x=0,q=1; RG char ch=getchar(); while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
  if(ch=='-') q=-1,ch=getchar(); while('0'<=ch&&ch<='9') x=x*10+ch-'0',ch=getchar(); return q*x; }
void File(){freopen(".in","r",stdin);freopen(".out","w",stdout);}

ll Ans[N];
int n,m,q;
int a[N],sum[54],pos[N];
struct ques{ int k,d; }que[N];
struct Edge{ int u,v,id; ll w;
  inline bool operator<(const Edge& a)const{ return w<a.w; }
}e[54][N],tmp[N],t[N];

int fa[N];
inline int find(RG int x){ return fa[x]==x?x:fa[x]=find(fa[x]); }

inline void init(){
  n=gi(),m=gi(),q=gi();
  for(RG int i=1;i<=m;i++){
    e[0][i].u=gi(),e[0][i].v=gi();
    a[i]=e[0][i].w=gi();
    e[0][i].id=i;
  }
  sum[0]=m;
  for(RG int i=1;i<=q;i++)
    que[i].k=gi(),que[i].d=gi();
}

inline void clear(int x){
  for(RG int i=1;i<=x;i++){
    fa[tmp[i].u]=tmp[i].u;
    fa[tmp[i].v]=tmp[i].v;
  }
}

inline void contraction(int& cnt,ll& ret){  //处理必需边
  RG int num=0;
  sort(tmp+1,tmp+cnt+1); clear(cnt);
  for(RG int i=1;i<=cnt;i++){
    RG int fx=find(tmp[i].u),fy=find(tmp[i].v);
    if(fx==fy) continue;
    fa[fx]=fy; t[++num]=tmp[i];
  }
  for(RG int i=1;i<=num;i++){
    fa[t[i].u]=t[i].u;
    fa[t[i].v]=t[i].v;
  }
  for(RG int i=1;i<=num;i++){  //将必需边两端缩起来
    if(t[i].w==-inf) continue;
    RG int fx=find(t[i].u),fy=find(t[i].v);
    ret+=t[i].w,fa[fx]=fy;
  }
  num=0;
  for(RG int i=1;i<=cnt;i++){  //缩点后的新图重新连边
    RG int fx=find(tmp[i].u),fy=find(tmp[i].v);
    if(fx==fy) continue;
    t[++num]=tmp[i];
    t[num].u=fx,t[num].v=fy;
    pos[tmp[i].id]=num;
  } cnt=num;
  for(RG int i=1;i<=cnt;i++) tmp[i]=t[i];
}

inline void reduction(int& cnt){  //处理无用边
  sort(tmp+1,tmp+cnt+1);
  RG int num=0; clear(cnt);
  for(RG int i=1;i<=cnt;i++){  //只留下当前MST中的边
    RG int fx=find(tmp[i].u),fy=find(tmp[i].v);
    if(fx==fy){ //待修改边也要留下
      if(tmp[i].w==inf){
    t[++num]=tmp[i];
    pos[tmp[i].id]=num;
      }
      continue;
    }
    fa[fx]=fy;
    t[++num]=tmp[i];
    pos[tmp[i].id]=num;
  } cnt=num;
  for(RG int i=1;i<=cnt;i++) tmp[i]=t[i];
}

inline void Solve(int l,int r,int dep,ll ret){
  RG int cnt=sum[dep];
  if(l==r) a[ que[l].k ]=que[l].d;
  for(RG int i=1;i<=cnt;i++){
    e[dep][i].w=a[ e[dep][i].id ];
    pos[ e[dep][i].id ]=i;
    tmp[i]=e[dep][i];
  }
  if(l==r){
    clear(cnt);
    sort(tmp+1,tmp+cnt+1);
    for(RG int i=1;i<=cnt;i++){
      RG int fx=find(tmp[i].u),fy=find(tmp[i].v);
      if(fx==fy) continue;
      fa[fx]=fy; ret+=tmp[i].w;
    }
    Ans[l]=ret;
    return ;
  }
  RG int mid=(l+r)>>1;
  for(RG int i=l;i<=r;i++) tmp[ pos[que[i].k] ].w=-inf;
  contraction(cnt,ret);
  for(RG int i=l;i<=r;i++) tmp[ pos[que[i].k] ].w=inf;
  reduction(cnt); sum[dep+1]=cnt;
  for(RG int i=1;i<=cnt;i++) e[dep+1][i]=tmp[i];
  Solve(l,mid,dep+1,ret); Solve(mid+1,r,dep+1,ret);
}

inline void work(){
  Solve(1,q,0,0);
  for(RG int i=1;i<=q;i++)
    printf("%lld\n",Ans[i]);
}

int main(){ init(); work(); return 0; }