【bzoj2001】 Hnoi2010—City 城市建设

http://www.lydsy.com/JudgeOnline/problem.php?id=2001 (题目链接)

题意

　　给出一张无向图，$m$组操作，每次修改一条边的权值，对于每次操作输出修改之后的图的最小生成树边权和。

Solution

　　nnd开了半个小时的脑洞，然并卵。感谢这位大爷的代码与题解：http://blog.csdn.net/u013368721/article/details/39183033

　　我们对时间cdq分治，如何在每一层向下递归的时候减小问题规模呢，两个关键的操作：

　　Reduction(删除无用边)：

　　　　把待修改的边标为INF，做一遍MST，把做完后不在MST中的非INF边删去（因为这些边在原图的情况下肯定更不可能选进MST的边集，即无用边）；

　　Contraction(缩必须边，缩点)：

　　　　把待修改的边标为-INF，做一遍MST，在MST中的非-INF边为必须边（因为这些边在原图的情况下也一定会被选进MST），缩点。

　　所以在每一层我们按顺序，先缩点，然后删边，这样子缩小了问题规模后往下递归。为什么这样的复杂度就是对的呢，我大概YY了一下。

　　在我们当前处理的这一层中，只有既不是必须边也不是无用边的边才会记入下一层的图中。考虑既这种边需要满足哪些条件。

　　不是必须边：有某条待修改的边可以代替这条边。

　　不是无用边：在非待修改的边中这条边无法被替代。

　　这么说来这些边是与待修改边息息相关的，在非待修改的边中这条边独一无二，而它所起到的作用又可以被某条待修改的边所代替，那么待修改的边与这种边大概是可以一一对应的。而待修改的边每往下递归一层就会减半，所以问题的规模每次也会减半。嘿嘿，极不严谨的证明（其实不过是口胡）

　　好吧请忽略上面的口胡，我们来严谨的证明一下。

　　设询问边的集合为$S$，图中的边集$E$，图中的点集$V$。两种操作可以看成是求了$G(V,E-S)$的最小生成树。

　　Reduction：最坏情况下最小生成树里面的边全都不是$|S|$上的，我们至少可以把边数缩小为$|V|-1+|S|$。

　　Contraction：最坏情况下最小生成树里面的边全都是$|S|$上的，我们至少可以把点数缩小为$|S|+1$。

　　所以我们缩点后，再删边，下一层的图的规模就是与$|S|$同级的了，复杂度得到了保证。

细节

　　清空并查集的时候不要破坏了复杂度。

代码

// bzoj2001
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define inf (1ll<<30)
#define Pi acos(-1.0)
#define free(a) freopen(a".in","r",stdin),freopen(a".out","w",stdout)
using namespace std;

const int maxn=20010,maxm=50010;
int n,m,Q,nv[20],ne[20],val[maxm];
LL ans[maxm];
struct ask {int id,w;}q[maxm];
struct edge {
	int u,v,w,id;
	friend bool operator < (edge a,edge b) {return a.w<b.w;}
}e[20][maxm];

namespace Unionset {
	int fa[maxn],size[maxn];
	int find(int x) {
		return fa[x]==x ? x : fa[x]=find(fa[x]);
	}
	int merge(int x,int y) {
		x=find(x),y=find(y);
		if (x==y) return 0;
		if (size[x]>size[y]) swap(x,y);
		fa[x]=y,size[y]+=size[x];
		return 1;
	}
	void clear(int x) {
		for (int i=1;i<=x;i++) fa[i]=i,size[i]=1;
	}
}
using namespace Unionset;

namespace CDQ {
	int id[maxm],vis[maxm],newv[maxn];
	edge tmp[maxm],L[maxm];
	void contraction(int &N,int &M,LL &res) {
		int tn=0,tm=0;
		sort(L+1,L+1+M);clear(N);
		for (int i=1;i<=M;i++) vis[i]=0;
		for (int i=1;i<=M;i++) {
			if (merge(L[i].u,L[i].v) && L[i].w!=-inf) vis[i]=1,res+=L[i].w;
			else tmp[++tm]=L[i];
		}
		clear(N);
		for (int i=1;i<=M;i++) if (vis[i]) merge(L[i].u,L[i].v);
		for (int i=1;i<=N;i++) if (find(i)==i) newv[i]=++tn;
		for (int i=1;i<=N;i++) newv[i]=newv[find(i)];
		for (int i=1;i<=tm;i++) {
			L[i]=tmp[i];
			id[L[i].id]=i;
			L[i].u=newv[L[i].u],L[i].v=newv[L[i].v];
		}
		N=tn,M=tm;
	}
	void reduction(int &N,int &M) {
		int tm=0;
		sort(L+1,L+1+M);clear(N);
		for (int i=1;i<=M;i++)
			if (merge(L[i].u,L[i].v) || L[i].w==inf) id[L[i].id]=++tm,L[tm]=L[i];
		M=tm;
	}
	void solve(int l,int r,int c,LL res) {
		int N=nv[c],M=ne[c];
		if (l==r) val[q[l].id]=q[l].w;
		for (int i=1;i<=M;i++) {
			e[c][i].w=val[e[c][i].id];
			L[i]=e[c][i];
			id[L[i].id]=i;
		}
		if (l==r) {
			sort(L+1,L+1+M);clear(N);
			for (int i=1;i<=M;i++) if (merge(L[i].u,L[i].v)) res+=L[i].w;
			ans[l]=res;return;
		}
		for (int i=l;i<=r;i++) L[id[q[i].id]].w=-inf;
		contraction(N,M,res);
		for (int i=l;i<=r;i++) L[id[q[i].id]].w=inf;
		reduction(N,M);
		nv[c+1]=N,ne[c+1]=M;
		for (int i=1;i<=M;i++) e[c+1][i]=L[i];
		int mid=(l+r)>>1;
		solve(l,mid,c+1,res);solve(mid+1,r,c+1,res);
	}
}

int main() {
	scanf("%d%d%d",&n,&m,&Q);
	nv[0]=n,ne[0]=m;
	for (int i=1;i<=m;i++) {
		scanf("%d%d%d",&e[0][i].u,&e[0][i].v,&e[0][i].w);
		e[0][i].id=i;val[i]=e[0][i].w;
	}
	for (int i=1;i<=Q;i++) scanf("%d%d",&q[i].id,&q[i].w);
	CDQ::solve(1,Q,0,0);
	for (int i=1;i<=Q;i++) printf("%lld\n",ans[i]);
	return 0;
}