2001: [Hnoi2010]City 城市建设

最新推荐文章于 2024-07-20 21:25:00 发布
最新推荐文章于 2024-07-20 21:25:00 发布
阅读量389 收藏
点赞数
分类专栏： BZOJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wamach/article/details/76461388
版权

当分治到区间[l,r]时：

如果l==r，直接跑mst，结束。否则：

S1存初始边和[1,l)的边，S2存[l,r]的边。

先把S2中的边权全都改成inf，跑mst，S1中用不到的边即为无用边，直接删去。

再把S2中的边权全都改成-inf，跑mst，S1中仍被用到的边即为必需边，把这些边连接的两点用并查集搞在一起，并把这些边权和传到下一层。

对于分治的每一种深度，开一个边、一个点集，一个并查集，一坨询问。因为深度最多为logn、同种深度的区间不会同时运行，所以只需开logn个就够了，空间是不会爆的。

TMD把题意看错了，写了个只有加边的。。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
#define rep(i,j,k) for(i=j;i<=k;++i)
#define per(i,j,k) for(i=j;i>=k;--i)
#define sqr(x) ((x)*(x))
#define G getchar()
#define LL long long
#define pii pair<int,int>
#define mkp make_pair
#define X first
#define Y second
#define N 200005
#define NN 500005
#define inf 100000000
struct EDGE{int a,b,w;}qu[NN];
struct EDGE2{int a,b,w,wz;}ek[NN<<1];
struct node{
	EDGE e[NN<<1];
	int tot,poi[N],cnt,par[N],sz[N];
}Hz[17];
int n,m,Q,totk,park[N],szk[N];
LL ans[NN];
bool flg[NN<<1];
void read(int &x){
	char ch=G;
	while(ch<48||ch>57)ch=G;
	for(x=0;ch>47&&ch<58;ch=G)x=x*10+ch-48; 
}
bool cmp(EDGE2 x,EDGE2 y){return x.w<y.w;}
int getpar(int *par0,int x){
	if(par0[x]!=x)par0[x]=getpar(par0,par0[x]);
	return par0[x];
}
void cmb(int *par0,int *sz0,int x,int y){
	x=getpar(par0,x);y=getpar(par0,y);
	if(sz0[x]<sz0[y])par0[x]=par0[y];
	else par0[y]=par0[x];
}
LL kruscal(int *poi0,int cnt0){
	int i,x,y,j;LL rtn=0;
	rep(i,1,cnt0)szk[park[i]=i]=1;
	rep(i,1,totk)flg[i]=0;
	sort(ek+1,ek+totk+1,cmp);
	for(i=j=1;j<cnt0;++i){
		x=getpar(park,ek[i].a);y=getpar(park,ek[i].b);
		if(x==y)continue;++j;
		flg[ek[i].wz]=1;rtn+=ek[i].w;
		cmb(park,szk,ek[i].a,ek[i].b);
	}
	return rtn;
}
void cdq(int l,int r,LL sum,int dep){
	EDGE *e0=Hz[dep].e;
	int &tot0=Hz[dep].tot,*poi0=Hz[dep].poi,&cnt0=Hz[dep].cnt,*par0=Hz[dep].par,*sz0=Hz[dep].sz;
	int i;
	rep(i,1,cnt0)sz0[par0[i]=i]=1;
	totk=tot0;
	rep(i,1,tot0)ek[i]=(EDGE2){e0[i].a,e0[i].b,e0[i].w,i};
	if(l==r){
		ek[++totk]=(EDGE2){qu[l].a,qu[l].b,qu[l].w,totk};
		ans[l]=kruscal(poi0,cnt0)+sum;
		return;
	}
	rep(i,l,r)ek[++totk]=(EDGE2){qu[i].a,qu[i].b,inf,totk};
	kruscal(poi0,cnt0);
	totk=tot0;
	rep(i,1,tot0){
		ek[i]=(EDGE2){e0[i].a,e0[i].b,e0[i].w,i};
		if(!flg[i])e0[i].a=0;
	}
	rep(i,l,r)ek[++totk]=(EDGE2){qu[i].a,qu[i].b,-inf,totk};
	kruscal(poi0,cnt0);
	EDGE *e1=Hz[dep+1].e;
	int &tot1=Hz[dep+1].tot,*poi1=Hz[dep+1].poi,&cnt1=Hz[dep+1].cnt;
	int x,mid=l+r>>1;
	rep(i,1,tot0){
		if(!e0[i].a)continue;
		if(flg[i]){
			cmb(par0,sz0,e0[i].a,e0[i].b);
			e0[i].a=0;sum+=e0[i].w;
		}
	}
	rep(i,1,cnt0){
		x=poi0[i];
		if(getpar(par0,x)==x)poi1[++cnt1]=x;
	}
	rep(i,1,tot0)if(e0[i].a)
		e1[++tot1]=(EDGE){getpar(par0,e0[i].a),getpar(par0,e0[i].b),e0[i].w};
	rep(i,l,r){
		qu[i].a=getpar(par0,qu[i].a);
		qu[i].b=getpar(par0,qu[i].b);
	}
	cdq(l,mid,sum,dep+1);
	rep(i,l,mid)e1[++tot1]=qu[i];
	cdq(mid+1,r,sum,dep+1);
}
int main(){
	int i,x;
	read(n);read(m);read(Q);
	EDGE *e0=Hz[1].e;
	rep(i,1,m){
		read(e0[i].a);read(e0[i].b);read(e0[i].w);
	}
	Hz[1].tot=m;
	int *poi0=Hz[1].poi;
	rep(i,1,n)poi0[i]=i;
	Hz[1].cnt=n;
	rep(i,1,Q){
		read(x);read(qu[i].w);
		qu[i].a=e0[x].a;qu[i].b=e0[x].b;
	}
	cdq(1,Q,0LL,1);
	rep(i,1,Q)printf("%d\n",ans[i]);
	return 0;
}

简直脑子进水，下面的代码写了我一整天。不过我还真没见过这么难写的题。觉得这题比Claris loves painting 还难写得多。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
#define rep(i,j,k) for(i=j;i<=k;++i)
#define per(i,j,k) for(i=j;i>=k;--i)
#define sqr(x) ((x)*(x))
#define G getchar()
#define LL long long
#define pii pair<int,int>
#define mkp make_pair
#define X first
#define Y second
#define N 20005
#define NN 50005
#define inf 100000000
struct EDGE{int a,b,w;};
struct EDGE2{int a,b,w,wz;}ek[NN<<1];
struct QUERY{int cur,w;};
struct node{
	EDGE e[NN<<1];QUERY qu[NN];
	int tot,poi[N],cnt,par[N],sz[N];
}Hz[20];
int n,m,Q,totk,park[N],szk[N],key[NN];
LL ans[NN];
bool flg[NN<<1];
void read(int &x){
	char ch=G;
	while(ch<48||ch>57)ch=G;
	for(x=0;ch>47&&ch<58;ch=G)x=x*10+ch-48; 
}
bool cmp(EDGE2 x,EDGE2 y){return x.w<y.w;}
int getpar(int *par0,int x){
	if(par0[x]!=x)par0[x]=getpar(par0,par0[x]);
	return par0[x];
}
void cmb(int *par0,int *sz0,int x,int y){
	x=getpar(par0,x);y=getpar(par0,y);
	if(sz0[x]<sz0[y])sz0[par0[x]=y]+=sz0[x];
	else sz0[par0[y]=x]+=sz0[y];
}
LL kruscal(int *poi0,int cnt0){
	int i,x,y,j;LL rtn=0;
	rep(i,1,cnt0)szk[park[poi0[i]]=poi0[i]]=1;
	rep(i,1,totk)flg[i]=0;
	sort(ek+1,ek+totk+1,cmp);
	for(i=j=1;j<cnt0;++i){
		x=getpar(park,ek[i].a);y=getpar(park,ek[i].b);
		if(x==y)continue;++j;
		flg[ek[i].wz]=1;rtn+=ek[i].w;
		cmb(park,szk,ek[i].a,ek[i].b);
	}
	return rtn;
}
void cdq(int l,int r,LL sum,int dep){
	EDGE *e0=Hz[dep].e;QUERY *qu0=Hz[dep].qu;
	int &tot0=Hz[dep].tot,*poi0=Hz[dep].poi,&cnt0=Hz[dep].cnt,*par0=Hz[dep].par,*sz0=Hz[dep].sz;
	int i;
	rep(i,1,cnt0)sz0[par0[poi0[i]]=poi0[i]]=1;
	totk=tot0;
	rep(i,1,tot0)ek[i]=(EDGE2){e0[i].a,e0[i].b,e0[i].w,i};
	if(l==r){
		ek[qu0[l].cur].w=qu0[l].w;
		ans[l]=kruscal(poi0,cnt0)+sum;
		return;
	}
	rep(i,l,r)
		ek[qu0[i].cur].w=inf;
	kruscal(poi0,cnt0);
	totk=tot0;
	rep(i,l,r)flg[qu0[i].cur]=1;
	rep(i,1,tot0){
		ek[i]=(EDGE2){e0[i].a,e0[i].b,e0[i].w,i};
		if(!flg[i])e0[i].a=0;
	}
	rep(i,l,r)ek[qu0[i].cur].w=-inf;
	kruscal(poi0,cnt0);
	EDGE *e1=Hz[dep+1].e;QUERY *qu1=Hz[dep+1].qu;
	int &tot1=Hz[dep+1].tot,*poi1=Hz[dep+1].poi,&cnt1=Hz[dep+1].cnt;
	int x,mid=l+r>>1;
	rep(i,l,r)flg[qu0[i].cur]=0;
	rep(i,1,tot0){
		if(!e0[i].a)continue;
		if(flg[i]){
			cmb(par0,sz0,e0[i].a,e0[i].b);
			e0[i].a=0;sum+=e0[i].w;
		}
	}
	cnt1=tot1=0;
	rep(i,1,cnt0){
		x=poi0[i];
		if(getpar(par0,x)==x)poi1[++cnt1]=x;
	}
	rep(i,1,tot0)if(e0[i].a)
		e1[key[i]=++tot1]=(EDGE){getpar(par0,e0[i].a),getpar(par0,e0[i].b),e0[i].w};
	rep(i,l,r)qu1[i]=(QUERY){key[qu0[i].cur],qu0[i].w};
	cdq(l,mid,sum,dep+1);
	tot1=0;
	rep(i,1,tot0)if(e0[i].a)
		e1[++tot1]=(EDGE){getpar(par0,e0[i].a),getpar(par0,e0[i].b),e0[i].w};
	rep(i,l,mid)e1[qu1[i].cur].w=qu1[i].w;
	cdq(mid+1,r,sum,dep+1);
}
int main(){
	int i;
	read(n);read(m);read(Q);
	EDGE *e0=Hz[1].e;QUERY *qu0=Hz[1].qu;
	rep(i,1,m){
		read(e0[i].a);read(e0[i].b);read(e0[i].w);
	}
	Hz[1].tot=m;
	int *poi0=Hz[1].poi;
	rep(i,1,n)poi0[i]=i;
	Hz[1].cnt=n;
	rep(i,1,Q){
		read(qu0[i].cur);read(qu0[i].w);
	}
	cdq(1,Q,0LL,1);
	rep(i,1,Q)printf("%lld\n",ans[i]);
	return 0;
}

wamach
关注
专栏目录
【BZOJ】2001: [Hnoi2010]City 城市建设-cdq分治/LCT
远行客
05-15 659
传送门：bzoj2001 题解 此题LCT动态维护MST貌似很可做（然而本蒟蒻不会） 这里分享看到的一种很妙的分治做法。 我们简化一下问题： 每次修改(x,y)(x,y)(x,y)权值，若能使MST总边权变小，则满足： 原MST上x−&amp;amp;gt;yx−&amp;amp;gt;yx-&amp;gt;y路径上最大值大于(x,y)(x,y)(x,y)权值 （仔细想想，感觉非常有道理： 若大于等于x-&amp;amp;gt;y...
BZOJ 2001 Hnoi2010 城市建设 分治+LCT
世界
11-13 3755
题目大意：给定一张带权无向图，每次改变一条边的边权并询问最小生成树，不强制在线日狗我为什么要写这个JB算法。。。对时间进行分治，每条边的存在时间为一个区间，拆成loglog个； 带着LCT把分治结构DFS一遍，一个节点入栈时用上面的所有边扔进LCT动态维护最小生成树，出栈时还原所有操作时间复杂度O(nlog2n)O(nlog^2n)如果没有特殊的卡常技巧请不要写这个算法#include <cstd
[HNOI2010]城市建设
weixin_34014555的博客
04-28 230
[HNOI2010]城市建设 玄学cdq O(nlog^2n)的动态最小生成树 其实就是按照时间cdq分治+剪枝（剪掉一定出现和不可能出现的边） 处理[l,r]之间的修改以及修改之后的询问，不能确定是否加入的边集为E 对于会被改变边权的边，边集为Q，暂时不能确定 不妨大力假设： 都是-inf，这个时候把Q的边都加入之后，剩下的E进行kruskal如果还能加入，那么在[l,r]这个区...
[HNOI2010] 城市建设
最新发布
dingxingdi的博客
07-20 126
于是可以递归进行reduction和contraction。在往下传的过程中，会有动态边变成静态边，如。
【HNOI2010】-城市建设(动态最小生成树)
weixin_30311605的博客
01-16 166
传送门 大意：给你一棵树，每次永久修改一条边权，询问当前最小生成树 做法真的妙妙的 考虑到无论我们怎么修改某条边的边权 都总有一些边可以被选到 也总有一些边不会被选到 因此就引入了两个操作 Contraction:Contraction:Contraction: 我们将当前分治区间的所有要修改的边全部赋为−inf-inf−inf 那么显然当前如...
[HNOI2010]CITY城市建设
BeNoble_的博客
04-04 757
题意 动态改边权MSTMSTMST 题解 考虑和线段树分治+LCT+LCT+LCT一样的思想,对修改时间分治 考虑一段时间的修改的那些边 暴力就是当L=RL=RL=R时直接让修改生效,,,然后求一遍MSTMSTMST 这样是不行的因为图的规模没有还是mmm 所以在每一层分治中就是考虑怎么缩小图的规模 考虑一个修改的两种极端情况 1.1.1.把这条边变成−∞−∞-\in...
[HNOI2010]CITY 城市建设
weixin_30858241的博客
04-19 158
问题： 给一张图，支持边长度修改，求MST 题解： 自己想就想不到了。。 考虑cdq分治 1.首先求出一定有用的边 对于未处理的边，全部设为-INF，求一次MST，出现在MST上的边一定最终出现在后面的MST上 2.然后求出一定无用的边 对于未处理的边，全部设为INF，求一次MST，不在MST上的边一定不会出现在后面的MST上 这两点非常好证明 然后来观察一下时间复杂度 对于...
BZOJ 1997: [Hnoi2010]Planar|2-SAT|二分图染色
ws_yzy的博客
01-07 976
一道比较奇怪的题 用二分图染色和2-SAT都可以建模 想了一下为什么 二分图染色是找出矛盾的关系连边 2-SAT是找出“必须”的关系连边 而此题恰好都满足 -------------------------------------------------- 2-SAT做法： 一组边a,b在环构成的圆内相交 那么在圆外的a‘,b'也相交 ”必须“关系有 a-->b'   a'-->
BZOJ1997: [Hnoi2010]Planar（洛谷P3209）
forezxl的博客
01-17 248
2-SAT 平面图 BZOJ题目传送门 洛谷题目传送门 首先根据平面图的性质，如果m>n∗3−6m>n*3-6，那么这个图一定不是平面图。这样我们就可以把边数缩至nn级别的了。 因为存在哈密顿回路，那么对于连接相同的两点的边，最多只能有两条（除了哈密顿回路的边），一条在环的里面，一条在环的外面。这样的限制满足2-SAT. 用手画几张图就可以发现，当两条边相交时，必然都在环的同一侧。记相交
BZOJ1009: [HNOI2008]GT考试
MirrorGray的博客
04-12 865
挖坑系列…#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> //by:MirrorGray using namespace std; const int N=22; char s[N]; int mod,m,nxt[N],ret[N][N];int MOD(int x){ while(x>=mo
bzoj2001: [Hnoi2010]City 城市建设
zyy大蒟蒻的博客
04-21 485
传送门 这定是极其蛋疼的题目。 考虑分治询问。 我们可以先求出当询问在l到r之间是，必定在MST上的边。 （未确定权值的边即使取到-inf也在MST上的边） 同时，我们可以缩点。 然后删除必定不在MST上的边。 （未确定权值的边即使取到-inf也在MST上的边） 分析时间复杂度： 点数最多为r-l+1（其他都被缩掉了） 边数最多为2*（r-l+1）（MST上r-l+1条和未确定的
bzoj 2001: [Hnoi2010]City 城市建设
OZY的博客
11-06 442
嘴巴AC
BZOJ 2001: [Hnoi2010]City 城市建设
月下沙茶树
04-01 1395
太神辣完全不会%%%%%%%%%%%%%%%% 听说可以CDQ分治+LCT做，不过好像会被卡常数 于是找到了网上的鬼畜题解，非常玄学的做法 #include #include #include #include using namespace std; const int N=20000+5; const int M=50000+5; const int inf=1e9; typedef l
【CDQ分治】[HNOI2010]城市建设
03-13 156
题目链接 线段树分治+LCT只有80 然后就有了CDQ分治的做法 把不可能在生成树里的扔到后面 把一定在生成树里的扔到并查集里存起来 分治到l=r，修改边权，跑个kruskal就行了 由于要支持撤销，并查集要按秩合并 #include"cstdio" #include"cstring" #include"iostream" #include"algorithm" using namesp...
BZOJ2001: [Hnoi2010]City 城市建设
CIao_015的博客
10-29 255
BZOJ 题意 给你一张nnn个点mmm条边的无向联通图和QQQ个询问,每次询问永久性的修改一条边的边权,问每次修改后改图的最小生成树的权值是多少; 题解
[动态最小生成树 CDQ分治 Kruscal] BZOJ 2001 [Hnoi2010]City 城市建设
雯舞
07-13 936
思路不难想 借鉴了其他人的代码：http://blog.sina.com.cn/s/blog_6e63f59e0101blum.html 两个关键的操作： Reduction(删除无用边)： 把待修改的边标为INF，做一遍MST，把做完后不在MST中的非INF边删去（因为这些边在原图的情况下肯定更不可能选进MST的边集，即无用边）； Contraction(缩必须边，缩点)： 把待修
[Hnoi2010]City 城市建设 CDQ分治
Loging的博客
07-30 224
[Hnoi2010]City 城市建设 Part 0 怎么也想不到正解会是CDQ分治，很妙的一道题。 CDQ分治就是将在线的问题转化为离线问题，将变化的数据变为不变的数据，缩小问题规模。 着眼于每个询问间的重复的操作,让一些操作不重复执行多遍。 同时还要保证分治的子区间执行的操作的复杂度只能和这个区间的长度有关。 Part 1 本题我们用分治思想入手。我们不妨按照时间分治。 倘若我们当前处理的操作...
BZOJ-2001-city城市建设-HNOI2010-CDQ分治
ghy1953
03-28 2623
描述 给出有n个点, m条边的无向图, 每次修改一条边的权值, 求修改后的最小生成树的大小. 修改次数 ≤ 50000. 分析 还是CDQ分治, 但是有点特殊. 目前的CDQ分治还是停留在看题解看别人代码才理解的层面.有一些边一定在部分修改后的最小生成树中, 这是优化的中心思想吧.然后一个减少边的操作, 一个减少点的操作. 看课件吧.减少点的方法是缩点, 用并查集.一开始想用
P3206 [HNOI2010]城市建设
xmr_pursue_dreams的博客
02-14 244
P3206 [HNOI2010]城市建设 题目描述 无向图上修改边权，动态维护MSTMSTMST，求每次修改后的MST的权值和。 Solution 有一个简单好想的做法——LCTLCTLCT+线段树分治。 考虑每次加边，若形成了一个环，则把环上最大的一条边删掉，LCTLCTLCT维护。 然后删边就套一个线段树分治，删边操作就变成了加边和回退操作，直接做就行了。 时间复杂度：大常数O(nlg2n)O...
网络流进阶：Model VII移民站选址与HNOI2013切糕问题
以HNOI2013的BZOJ3144——切糕1为例，题目设定在一个p×q的网格上，每个位置有r个可选值，并且每个选择都有成本。关键挑战是确保相邻四连通区域内的值差不超过d，目标是找到最小的总成本。在这个问题中，作者通过将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值