bzoj 1969: [Ahoi2005]LANE 航线规划

最新推荐文章于 2022-02-05 17:11:56 发布
最新推荐文章于 2022-02-05 17:11:56 发布
阅读量981 收藏 1
点赞数
分类专栏： 树状数组 线段树 双联通分量 DFS序 桥 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlj1999/article/details/50894205
版权

好久不写图论题好虚啊，m打成n RE了3次QAQ人生耻辱啊。

首先假设没有删边，显然答案是两点间桥的数量。

于是求边双连通分量，缩点缩边，只留下桥。

所以剩下的肯定是树啦。

于是询问变成了求树上两点间距离，求下LCA就可以直接做了。

但是还有删边操作。

删边肯定不好处理。

反过来改成加边操作。

两点与LCA形成了一个边双联通分量，于是把他们缩起来。

直接缩不可取，考虑缩点的后果是子树被提升了相同的高度，于是考虑把点u向祖先v缩边，step by step，缩掉u-fa(u)这条边的后果是u这颗子树的高度被提升了dep(u)-dep(fa(u))，dfs序+BIT维护子树高度，差分之后变成区间修改+单点查询。

然后由于每个点都至多被缩一次（加个并查集维护一下）所以是nlogn的。

所以总的也就是nlogn了。

made竟然写了180多行

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<stack>
#define mk(x,y) make_pair(x,y)
using namespace std;
const int N=30000+5;
const int M=100000+5;
struct Edge{int to,next;}e[M<<1];
int head[N],cnt;
void ins(int u,int v){
	e[++cnt]=(Edge){v,head[u]};head[u]=cnt;
}
void insert(int u,int v){
	ins(u,v);ins(v,u);
}
int dep[N],son[N],siz[N],st[N],ed[N],fa[N],top[N],sz;
void dfs(int u){
	son[u]=0;siz[u]=1;
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;if(v==fa[u])continue;
		fa[v]=u;dep[v]=dep[u]+1;
		dfs(v);
		siz[u]+=siz[v];
		if(siz[v]>siz[son[u]])son[u]=v;
	}
}
void dfs(int u,int tp){
	st[u]=++sz;top[u]=tp;
	if(son[u])dfs(son[u],tp);
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;
		if(v!=son[u]&&v!=fa[u])
		dfs(v,v);
	}
	ed[u]=sz;
}
int lca(int u,int v){
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]])swap(u,v);
		u=fa[top[u]];
	}
	if(dep[u]>dep[v])swap(u,v);
	return u;
}
struct BIT{
	int d[N];
	#define lb(x) (x&-x)
	void add(int x,int v){
		for(;x<=sz;x+=lb(x))d[x]+=v;
	}
	int sum(int x){
		int ans=0;
		for(;x>0;x-=lb(x))ans+=d[x];
		return ans;
	}
	void add(int l,int r,int x){
		add(l,x);add(r+1,-x);
	}
	int query(int x){
		return sum(st[x]);
	}
}T;
void up(int x,int d){
	T.add(st[x],ed[x],-d);
}
int pa[N];
int find(int x){
	return pa[x]==x?x:pa[x]=find(pa[x]);
}
void merge(int f,int t){
	while(f!=t){
		up(f,T.query(f)-T.query(find(fa[f])));
		pa[f]=t;
		f=find(fa[f]);
	}
}
void add(int u,int v){
	u=find(u);v=find(v);
	if(u==v)return;
	int w=lca(u,v);w=find(w);
	merge(u,w);merge(v,w);
}
int query(int x,int y){
	x=find(x);y=find(y);
	if(x==y)return 0;
	int w=lca(x,y);w=find(w);
	return T.query(x)+T.query(y)-2*T.query(w);
}
int bccno[N],dfn[N],dfs_clock,bcc_cnt;
stack<int>s;
int tarjan(int u,int fa){
	int lowu=dfn[u]=++dfs_clock,child=0;
	s.push(u);
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;if(v==fa)continue;
		if(!dfn[v]){
			int lowv=tarjan(v,u);
			lowu=min(lowu,lowv);
			if(lowv>dfn[u]){
				bcc_cnt++;
				while(true){
					int x=s.top();s.pop();
					bccno[x]=bcc_cnt;
					if(x==v)break;
				}
			}
		}else lowu=min(lowu,dfn[v]);
	}
	if(fa<0&&child<2){
		bcc_cnt++;
		while(true){
			int x=s.top();s.pop();
			bccno[x]=bcc_cnt;
			if(x==u)break;
		}
	}
	return lowu;
}
struct Query{
	int c,x,y;
}q[40005];
vector<int>g[N],del[N];
int ans[40005];
int main(){
	//freopen("a.in","r",stdin);
	int n,m;scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v;scanf("%d%d",&u,&v);
		g[u].push_back(v);
		g[v].push_back(u);
	}
	for(int i=1;i<=n;i++){
		sort(g[i].begin(),g[i].end());
		del[i].resize(g[i].size());
	}
	int k=0;
	while(++k){
		scanf("%d",&q[k].c);
		if(q[k].c==-1)break;
		scanf("%d%d",&q[k].x,&q[k].y);
		if(q[k].c==0){
			int it=lower_bound(g[q[k].x].begin(),g[q[k].x].end(),q[k].y)-g[q[k].x].begin();
			del[q[k].x][it]=1;
			it=lower_bound(g[q[k].y].begin(),g[q[k].y].end(),q[k].x)-g[q[k].y].begin();
			del[q[k].y][it]=1;
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<g[i].size();j++)
		if(!del[i][j])
		ins(i,g[i][j]);
		g[i].clear();
	}
	tarjan(1,-1);
	for(int u=1;u<=n;u++)
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;
		if(bccno[u]!=bccno[v]){
			g[bccno[u]].push_back(bccno[v]);
			g[bccno[v]].push_back(bccno[u]);
		}
	}
	memset(head,0,sizeof(head));cnt=0;
	for(int i=1;i<=bcc_cnt;i++){
		sort(g[i].begin(),g[i].end());
		m=unique(g[i].begin(),g[i].end())-g[i].begin();
		for(int j=0;j<m;j++)
		ins(i,g[i][j]);
	}
	dfs(1);dfs(1,1);
	for(int i=1;i<=sz;i++)
	T.add(st[i],st[i],dep[i]);
	for(int i=1;i<=sz;i++)pa[i]=i;
	for(int i=k-1;i>=1;i--)
	if(q[i].c)
	ans[i]=query(bccno[q[i].x],bccno[q[i].y]);
	else add(bccno[q[i].x],bccno[q[i].y]);
	for(int i=1;i<k;i++)
	if(q[i].c)
	printf("%d\n",ans[i]);
	return 0;
}

原来可以直接树剖……果然是我太弱了

每次加边操作相当于是把u-lca(u,v)-v之间的所有边权都置为0（初始为1）

每次询问是询问两点间边权和

直接树剖啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊

其实才多了20行，而且只慢了100MS

难道是我之前那个版本写挫了QAQ

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<stack>
#define mk(x,y) make_pair(x,y)
using namespace std;
const int N=30000+5;
const int M=100000+5;
struct Edge{int to,next;}e[M<<1];
int head[N],cnt;
void ins(int u,int v){
	e[++cnt]=(Edge){v,head[u]};head[u]=cnt;
}
void insert(int u,int v){
	ins(u,v);ins(v,u);
}
int dep[N],son[N],siz[N],pos[N],fa[N],top[N],sz;
void dfs(int u){
	son[u]=0;siz[u]=1;
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;if(v==fa[u])continue;
		fa[v]=u;dep[v]=dep[u]+1;
		dfs(v);
		siz[u]+=siz[v];
		if(siz[v]>siz[son[u]])son[u]=v;
	}
}
void dfs(int u,int tp){
	pos[u]=++sz;top[u]=tp;
	if(son[u])dfs(son[u],tp);
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;
		if(v!=son[u]&&v!=fa[u])
		dfs(v,v);
	}
}
struct Node{
	int l,r,sum;
	bool flag;
}tr[N<<2];
#define lc o<<1
#define rc o<<1|1
void pushup(int o){
	tr[o].sum=tr[lc].sum+tr[rc].sum;
}
void pushdown(int o){
	if(tr[o].flag){
		tr[lc].flag=tr[rc].flag=true;
		tr[lc].sum=tr[rc].sum=0;
		tr[o].flag=0;
	}
}
void build(int o,int l,int r){
	tr[o].l=l;tr[o].r=r;
	if(l==r)tr[o].sum=1;
	else{
		int mid=l+r>>1;
		build(lc,l,mid);build(rc,mid+1,r);
		pushup(o);
	}
}
void modify(int o,int a,int b){
	int l=tr[o].l,r=tr[o].r;
	if(l==a&&b==r){
		tr[o].flag=1;tr[o].sum=0;
	}else{
		int mid=l+r>>1;
		pushdown(o);
		if(b<=mid)modify(lc,a,b);
		else if(mid<a)modify(rc,a,b);
		else modify(lc,a,mid),modify(rc,mid+1,b);
		pushup(o);
	}
}
int sum(int o,int a,int b){
	int l=tr[o].l,r=tr[o].r;
	if(l==a&&b==r)return tr[o].sum;
	else{
		int mid=l+r>>1;
		pushdown(o);
		if(b<=mid)return sum(lc,a,b);
		else if(mid<a)return sum(rc,a,b);
		else return sum(lc,a,mid)+sum(rc,mid+1,b);
	}
}
void add(int u,int v){
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]])swap(u,v);
		modify(1,pos[top[u]],pos[u]);
		u=fa[top[u]];
	}
	if(u==v)return;
	if(dep[u]>dep[v])swap(u,v);
	modify(1,pos[son[u]],pos[v]);
}
int query(int u,int v){
	int ans=0;
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]])swap(u,v);
		ans+=sum(1,pos[top[u]],pos[u]);
		u=fa[top[u]];
	}
	if(u==v)return ans;
	if(dep[u]>dep[v])swap(u,v);
	ans+=sum(1,pos[son[u]],pos[v]);
	return ans;
}
int bccno[N],dfn[N],dfs_clock,bcc_cnt;
stack<int>s;
int tarjan(int u,int fa){
	int lowu=dfn[u]=++dfs_clock,child=0;
	s.push(u);
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;if(v==fa)continue;
		if(!dfn[v]){
			int lowv=tarjan(v,u);
			lowu=min(lowu,lowv);
			if(lowv>dfn[u]){
				bcc_cnt++;
				while(true){
					int x=s.top();s.pop();
					bccno[x]=bcc_cnt;
					if(x==v)break;
				}
			}
		}else lowu=min(lowu,dfn[v]);
	}
	if(fa<0&&child<2){
		bcc_cnt++;
		while(true){
			int x=s.top();s.pop();
			bccno[x]=bcc_cnt;
			if(x==u)break;
		}
	}
	return lowu;
}
struct Query{
	int c,x,y;
}q[40005];
vector<int>g[N],del[N];
int ans[40005];
int main(){
	//freopen("a.in","r",stdin);
	int n,m;scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v;scanf("%d%d",&u,&v);
		g[u].push_back(v);
		g[v].push_back(u);
	}
	for(int i=1;i<=n;i++){
		sort(g[i].begin(),g[i].end());
		del[i].resize(g[i].size());
	}
	int k=0;
	while(++k){
		scanf("%d",&q[k].c);
		if(q[k].c==-1)break;
		scanf("%d%d",&q[k].x,&q[k].y);
		if(q[k].c==0){
			int it=lower_bound(g[q[k].x].begin(),g[q[k].x].end(),q[k].y)-g[q[k].x].begin();
			del[q[k].x][it]=1;
			it=lower_bound(g[q[k].y].begin(),g[q[k].y].end(),q[k].x)-g[q[k].y].begin();
			del[q[k].y][it]=1;
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<g[i].size();j++)
		if(!del[i][j])
		ins(i,g[i][j]);
		g[i].clear();
	}
	tarjan(1,-1);
	for(int u=1;u<=n;u++)
	for(int i=head[u];i;i=e[i].next){
		int v=e[i].to;
		if(bccno[u]!=bccno[v]){
			g[bccno[u]].push_back(bccno[v]);
			g[bccno[v]].push_back(bccno[u]);
		}
	}
	memset(head,0,sizeof(head));cnt=0;
	for(int i=1;i<=bcc_cnt;i++){
		sort(g[i].begin(),g[i].end());
		m=unique(g[i].begin(),g[i].end())-g[i].begin();
		for(int j=0;j<m;j++)
		ins(i,g[i][j]);
	}
	dfs(1);dfs(1,1);
	build(1,1,bcc_cnt);
	for(int i=k-1;i>=1;i--)
	if(q[i].c)
	ans[i]=query(bccno[q[i].x],bccno[q[i].y]);
	else add(bccno[q[i].x],bccno[q[i].y]);
	for(int i=1;i<k;i++)
	if(q[i].c)
	printf("%d\n",ans[i]);
	return 0;
}


nlj1999
关注
专栏目录
[AHOI2005]【bzoj1969】LANE 航线规划——LCT维护双联通分量
Seniorious的博客
04-03 476
前置技能点：LCT，双联通分量 如果你不知道上面的东西，请先行了解 start_of_题面 对Samuel星球的探险已经取得了非常巨大的成就，于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系。 星际空间站的Samuel II巨型计算机经过长期探测，已经锁定了Samuel星系中许多星球的空间坐标，并对这些星球从1开始编号1、2、3……...
bzoj 1969: [Ahoi2005]LANE 航线规划 离线+树链剖分+线段树
beginend
11-02 342
题意给你一个无向图，要求资瓷两个操作：删除一条边，或(x,y)表示询问有多少条边满足删掉后x和y不连通。 保证任意时刻该图连通。 n<=30000,m<=100000,q<=40000分析看到该图始终连通后，很容易想到先离线搞一棵生成树出来，那么答案的割边一定在这棵生成树上。 我们把询问离线，把删边变为加边，每加一条边就相当于把这条边两个端点路径上的边染成黑色，询问就相当于问两点路径上白色边的
BZOJ 1969: [Ahoi2005]LANE 航线规划( 树链剖分 )
weixin_30375247的博客
02-01 128
首先我们要时光倒流, 倒着做, 变成加边操作维护关键边. 先随意搞出一颗树, 树上每条边都是关键边(因为是树, 去掉就不连通了)....然后加边(u, v)时, 路径(u, v)上的所有边都变成非关键边了, 因为形成了环, 环上任意2点有2条路径。。。下图, 加上蓝色的边, 红色x的边就变成了非关键边.所以树链剖分维护一下...时间复杂度O(NlogN+MlogM+Qlog^2N), 可以AC...
BZOJ 线段树 1969: [Ahoi2005]LANE 航线规划
We Can
03-29 2111
1969: [Ahoi2005]LANE 航线规划 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 132  Solved: 55 [Submit][Status] Description 对Samuel星球的探险已经取得了非常巨大的成就，于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系
Bzoj1969: [Ahoi2005]LANE 航线规划
Cyhlnj
01-15 295
题面 戳我 Sol 把询问反过来，变成加边，先加上边变成一棵树，之后每次加边就相当于去掉这两个点与这条边形成的环的代价，用树剖+线段树覆盖区间即可 # include # define RG register # define IL inline # define Fill(a, b) memset(a, b, sizeof(a)) using namespace std; ty
[AHOI2005] 航线规划
m0_51547083的博客
02-05 417
LCT解法。
bzoj 3233: [Ahoi2013]找硬币 动态规划
beginend
06-02 741
题意小蛇是金融部部长。最近她决定制造一系列新的货币。假设她要制造的货币的面值为x1,x2,x3… 那么x1必须为1，xb必须为xa的正整数倍（b>a）。例如 1，5，125，250就是一组合法的硬币序列，而1，5，100，125就不是。不知从哪一天开始，可爱的蛇爱上了一种萌物——兔纸！从此，小蛇便走上了遇上兔纸娃娃就买的不归路。某天，小蛇看到了N只可爱的兔纸，假设这N 只兔纸的价钱分别是a1,a2…
BZOJ1797: [Ahoi2009]Mincut 最小割（洛谷P4126）
forezxl的博客
09-26 231
最小割 Tarjan BZOJ题目传送门 洛谷题目传送门 结论题。。。 跑一遍最小割，对残量网络进行缩点，使得剩下的边都是满流边。 一条边属于最小割的并集当这条边两个端点所在的联通块不同。 一条边属于最小割的交集当这条边两个端点所在的联通块分别与源点和汇点相同。 下面给出口胡： 如果这条边的两个端点在同一个联通块内，那么它就不是满流边，一定没有割它流入的满流边划算，也就不是最小割。 一条边如果一个...
BZOJ3875: [Ahoi2014&Jsoi2014]骑士游戏（洛谷P4042）
forezxl的博客
10-31 254
最短路 DP BZOJ题目传送门 洛谷题目传送门 很显然有f[u]=min(ku,su+∑f[v])f[u]=min(k_u,s_u+\sum f[v])f[u]=min(ku​,su​+∑f[v])。但是这个是有后效性的，那么就用spfa搞（也可以用类似拓扑的方法做）。每次更新一个点后把所有指向它的点都加到队列里更新即可。 代码： #include&lt;queue&gt; #include&l...
ahoi2005 lane 航线规划
unicornt的博客
06-25 479
题目链接题解对于这样一类删边+询问的题目，可以很快就想到“正难则反”这一思路，因此可以离线做，先将要删的边删掉，再反着处理每一个询问，于是删边就被处理成了加边。 然而，即使这样，仍然很麻烦，因为这是一个图，可能有环，非常麻烦。 可以考虑运用dfs树，先利用dfs造出一棵树，然后再将没包含在树上的边加入更新。 对于关键路径，非常显然，就是树上的边了。 现在考虑如何更新。 每加入一条边，就在树
[BZOJ1969][Ahoi2005]LANE 航线规划（树链剖分）
ADP+Pi==ATP
10-04 606
诶好久没发题解了啊，还有一个半月就NOIP了诶
[AHOI2005]航线规划
又又大柚纸的博客
07-14 3045
【题目链接】 洛谷 P2542 [AHOI2005]航线规划 BZOJ 1969: [Ahoi2005]LANE 航线规划 【解析】 图上的删边、删点操作一般都是通过离线转化为倒序加边、加点操作，这一题也不例外。而图论中关于联通的问题基本上都是 Tarjan 算法或者生成树。 在原图中生成一棵树，该树上所有的边一定都是关键路径。将删边转换为加边后，每次加边可以看做是将树上的一段路径全部赋...
【BZOJ1969】航线规划（Link-Cut Tree）
小蒟蒻yyb的博客
01-17 441
题面BZOJ题解删边操作 套路呀 离线读入倒过来做 变成加边操作现在考虑怎么确定两点直接的关键路径条数 如果是一棵树，那么每条边都是关键路径 在一棵树的基础上 如果连接了两点 那么，两点之间原来的路径一定都不是关键路径 所以，弄一个LCTLCT 每次维护加边#include<iostream> #include<cstdio> #include<cstdlib> #include<
[BZOJ1969][Ahoi2005]LANE 航线规划（树链剖分+并查集）
zyf2000
09-24 1130
Good start, no patient and tolerant, bear no satisfactory fruit.再好的开始，没有恒久的忍耐和包容，也结不出圆满的果实。
洛谷2542 [AHOI2005]航线规划 BZOJ1969
苦鬼·。
06-09 457
题目描述对Samuel星球的探险已经取得了非常巨大的成就，于是科学家们将目光投向了Samuel星球所在的星系——一个巨大的由千百万星球构成的Samuel星系。星际空间站的Samuel II巨型计算机经过长期探测，已经锁定了Samuel星系中许多星球的空间坐标，并对这些星球从1开始编号1、2、3……。一些先遣飞船已经出发，在星球之间开辟探险航线。探险航线是双向的，例如从1号星球到3号星球开辟探险航线，
[bzoj1969][AHOI2005]LANE 航线规划
不来也不去的一只失忆蝴蝶
08-18 1090
题目大意一个n个节点m条边的图，两点间的关键边定义为从一点走到另一个点必须经过的边。 现有许多操作，删一条边或者询问两点间的关键边数量。 保证任意时刻原图联通。时间倒流先把所有边删掉，然后倒着做，转删边为加边。 然后我们思考，最后原图也是联通的，那么做边双联通分量缩点后，就会变成一棵树。 然后显然两个结点间关键边数等于它们所处联通分量代表的点在树上树路径的边数。 然而我们要处理加边，每加一
BZOJ 1969 航线规划 - LCT 维护边双联通分量
weixin_30410119的博客
09-25 94
Solution 实际上就是查询 $u$ 到 $v$ 路径上 边双的个数 $ -1$。 并且题目仅有删边， 那么就离线倒序添边。 维护 边双 略有不同： 首先需要一个并查集， 记录 边双内的点。 在 添加边$(u,v)$时 ， 若$u, v$ 已经相连， 那么把 $u, v$ 路径上的点 缩成一个点， 用最上面的点 来代替。 1 void del(int x, int y) {...
BZOJ2839:集合计数(容斥,组合数学)
最新发布
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值