CodeForces - 1417F Graph and Queries(克鲁斯卡尔重构树的dfs序上建线段树)

题目链接:点击查看

题目大意:给出一个 n 个点 m 条边组成的无向图,每个点初始时都有一个权值 val,满足:

  1. 每个点的 val[ i ] 各不相同
  2. val[ i ] ∈ [ 1 , n ]

现在有 m 次操作,每次操作分为以下两种类型:

  1. 1 x:询问点 x 所在的连通块内 val 的最大值,设 val[ y ] 最大,输出 val[ y ],且进行赋值操作:val[ y ] = 0
  2. 2 x:将第 x 条边删除

题目分析:难点比较多,且也很具有误导性,第一个难点就是如何处理连通块内的最大值问题,之前我只涉及过在一棵树上求子树内的最大值(用线段树维护),再就是删除边的操作,很容易误导去思考正难则反,然后倒着进行并查集

但这个题目的提示也蛮足的:可以到达的连通块问题,这类问题其实可以转换为克鲁斯卡尔重构树的问题

考虑克鲁斯卡尔重构树的简化模型:对于原图中的一条边将其转换为一个点与其相连,并将边权赋给点权,如下图所示:

因为是按照克鲁斯卡尔算法的思想去建树的,所以相对于根节点而言,深度越浅的节点权值越大,利用这个性质就可以实现,在一个所有边的权值不大于某个阈值的联通块内互相可达,来个例题?洛谷 - P4197

这样一来就可以给每条边赋权了,对于永远都不会被删除掉的边,赋权为 0 ,对于第 i 条被删除的边,赋权为 inf - i,最后再用边权为 inf 的边用来联通整个图(因为初始时的图不保证联通)

建立克鲁斯卡尔重构树,在其 dfs 序上维护一棵线段树,线段树的作用是查找区间最大值以及其位置,这样就可以查找某个子树内的最大值了

于是模型转换如下,初始时设置阈值 val = inf - 1,意为没有一条边被删除:

  1. 1 x:查找点 x 在阈值 val 下所在的子树内的最大值
  2. 2 x:阈值减一,代表将第 i 条边删除

代码:

//#pragma GCC optimize(2)
//#pragma GCC optimize("Ofast","inline","-ffast-math")
//#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
#include<unordered_map>
using namespace std;
     
typedef long long LL;
     
typedef unsigned long long ull;
     
const int inf=0x3f3f3f3f;
   
const int N=1e6+100;

int n,m,q;

struct Qu
{
	int op,x;
}qu[N];

struct Edge
{
	int u,v,w;
	bool operator<(const Edge& t)const
	{
		return w<t.w;
	}
}edge[N];

struct Max
{
	int val,pos;
	Max(){}
	Max(int val,int pos):val(val),pos(pos){}
	static Max inf()
	{
		return Max(-0x3f3f3f3f,0);
	}
	bool operator<(const Max& t)const
	{
		return val<t.val;
	}
};

struct Node
{
	int l,r;
	Max mmax;
}tree[N<<2];

int a[N],f[N],val[N],dp[N][25],L[N],R[N],id[N],tot;

vector<int>node[N];
/*线段树*/
void pushup(int k)
{
	tree[k].mmax=max(tree[k<<1].mmax,tree[k<<1|1].mmax);
}

void build(int k,int l,int r)
{
	tree[k].l=l;
	tree[k].r=r;
	if(l==r)
	{
		tree[k].mmax.val=a[id[l]];
		tree[k].mmax.pos=l;
		return;
	}
	int mid=l+r>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
}

void update(int k,int pos)
{
	if(tree[k].l==tree[k].r)
	{
		tree[k].mmax.val=0;
		return;
	}
	int mid=tree[k].l+tree[k].r>>1;
	if(pos<=mid)
		update(k<<1,pos);
	else
		update(k<<1|1,pos);
	pushup(k);
}

Max query(int k,int l,int r)
{
	if(tree[k].l>r||tree[k].r<l)
		return Max::inf();
	if(tree[k].l>=l&&tree[k].r<=r)
		return tree[k].mmax;
	return max(query(k<<1,l,r),query(k<<1|1,l,r));
}
/*线段树*/
/*dfs序+树上倍增*/
void dfs(int u,int fa)
{
	dp[u][0]=fa;
	for(int i=1;i<=20;i++)
		dp[u][i]=dp[dp[u][i-1]][i-1];
	L[u]=++tot;
	id[tot]=u;
	for(auto v:node[u])
		dfs(v,u);
	R[u]=tot;
}

int get_pos(int u,int up)//树上倍增找满足的祖先 
{
	for(int i=20;i>=0;i--)
		if(dp[u][i]!=0&&val[dp[u][i]]<=up)
			u=dp[u][i];
	return u;
}
/*dfs序+树上倍增*/
/*并查集+克鲁斯卡尔重构树*/
int find(int x)
{
	return f[x]==x?x:f[x]=find(f[x]);
}

int Ex_Kruskal()
{
	for(int i=1;i<=n<<1;i++)
		f[i]=i;
	int index=n;
	sort(edge+1,edge+1+m);
	for(int i=1;i<=m;i++)
	{
		int xx=find(edge[i].u),yy=find(edge[i].v);
		if(xx!=yy)
		{
			f[xx]=f[yy]=++index;
			val[index]=edge[i].w;
			node[index].push_back(xx);
			node[index].push_back(yy);
		}
	}
	int last=1;
	for(int i=1;i<=n;i++)
	{
		int xx=find(last),yy=find(i);
		if(xx!=yy)
		{
			f[xx]=f[yy]=++index;
			val[index]=inf;
			node[index].push_back(xx);
			node[index].push_back(yy);
			last=index;
		}
	}
	return index;
}
/*并查集+克鲁斯卡尔重构树*/
int main()
{
#ifndef ONLINE_JUDGE
//  freopen("data.in.txt","r",stdin);
//  freopen("data.out.txt","w",stdout);
#endif
//  ios::sync_with_stdio(false);
	scanf("%d%d%d",&n,&m,&q);
	for(int i=1;i<=n;i++)
		scanf("%d",a+i);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&edge[i].u,&edge[i].v);
		edge[i].w=0;
	}
	int val=inf;
	for(int i=1;i<=q;i++)
	{
		scanf("%d%d",&qu[i].op,&qu[i].x);
		if(qu[i].op==2)
			edge[qu[i].x].w=--val;
	}
	int root=Ex_Kruskal();
	dfs(root,0);
	build(1,1,root);
	val=inf-1;
	for(int i=1;i<=q;i++)
	{
		if(qu[i].op==1)
		{
			int x=get_pos(qu[i].x,val);
			Max ans=query(1,L[x],R[x]);
			printf("%d\n",ans.val);
			update(1,ans.pos);
		}
		else
			val--;
	}














    return 0;
}

 

猜你喜欢

转载自blog.csdn.net/qq_45458915/article/details/109066606