BZOJ 1977/洛谷P4180 - 次小生成树 Tree(严格次小生成树)

题目链接 https://www.luogu.org/problemnew/show/P4180

【题意】
小C最近学了很多最小生成树的算法,Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时,小P又来泼小C冷水了。小P说,让小C求出一个无向图的次小生成树,而且这个次小生成树还得是严格次小的,也就是说:如果最小生成树选择的边集是EME_M,严格次小生成树选择的边集是ESE_S,那么需要满足:(value(e)value(e)表示边ee的权值) eEMvalue(e)<eESvalue(e)\sum_{e \in E_M}value(e) < \sum_{e \in E_S} value(e) 这下小 C 蒙了,他找到了你,希望你帮他解决这个问题。

【输入格式】
第一行包含两个整数NNMM,表示无向图的点数与边数。 接下来 MM行,每行 3个数x,y,zx ,y, z 表示,点 xx 和点yy之间有一条边,边的权值为zz。数据中无向图无自环; 50% 的数据N2000,M3000N≤2 000 ,M≤3 000; 80% 的数据N50000,M100000N≤50 000 ,M≤100 000; 100% 的数据N100000,M300000N≤100 000 ,M≤300 000 ,边权值非负且不超过 10910^9

【输出格式】
包含一行,仅一个数,表示严格次小生成树的边权和。(数据保证必定存在严格次小生成树)

【输入样例】
5 6
1 2 1
1 3 2
2 4 3
3 5 4
3 4 3
4 5 6

【输出样例】
11

【思路】
一般求次小生成树的方法是枚举所有不在最小生成树中的边,用它们将最小生成树上的一条边换掉(换掉原来的最小瓶颈路)以后形成一个新的生成树,然后取最小值. 但是这道题要求严格次小,还按照刚才的办法,如果枚举某条不在最小生成树种的边时,这条边的权值和最小生成树上对应最小瓶颈路相等,那么这就不是一组解了. 假设这条边的端点为u,vu,v,这时我们就不能换掉最小生成树上u,vu,v的最小瓶颈路了,而是要换掉从uuvv 的路径上次大的那一条边,才能保证换完之后新的生成树严格大于最小生成树. 具体实现还要借助于LCA的倍增思想,假设
depth[u]depth[u] 表示节点 uu 的深度
parent[u][k]parent[u][k] 表示节点uu 向上走 2k2^k步到达的节点,不存在则为-1
zuida[u][k]zuida[u][k] 表示节点 uu 向上走 2k2^k 步途径的最大边权值,不存在则为-1
cida[u][k]cida[u][k] 表示节点 uu 向上走 2k2^k 步途径的次大边权值,不存在则为-1

下面两个状态转移不难想到
parent[u][k]=parent[parent[u][k1]][k1]parent[u][k]=parent[parent[u][k-1]][k-1]
zuida[u][k]=max{zuida[u][k1],zuida[parent[u][k1]][k1]}zuida[u][k]=max\{ zuida[u][k-1],zuida[parent[u][k-1]][k-1] \}
次大边权值的状态转移不太好想
cida[u][k]=max{min{zuida[u][k1],zuida[parent[u][k1]][k1]}(zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])cida[u][k1]cida[parent[u][k1][k1]cida[u][k]=max \begin{cases} min\{zuida[u][k-1],zuida[parent[u][k-1]][k-1]\} & \text {(zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])} \\ cida[u][k-1] \\ cida[parent[u][k-1][k-1] \end{cases}
递推边界就是k=1k=1,用一次dfs就可以求出边界时的解,在查询某两个点u,vu,v的时候采用倍增思想,先让更深的uu向上走到和vv同样的高度,然后u,vu,v同时向上走到LCA(u,v)LCA(u,v),用两个变量记录这一过程中经过的最大边权和次大边权

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll inf=1e15;
const int maxn=100005;
const int maxm=300005; 

struct Edge{
	int from,to;
	ll dist;
	Edge(int f,int t,ll d):from(f),to(t),dist(d){}
	bool operator<(const Edge& e)const{
		return dist<e.dist;
	}
};

int n,m;
int par[maxn];
bool ok[maxm];
vector<Edge> edges0,edges;
vector<int> g[maxn];
int depth[maxn];
int parent[maxn][20];
ll zuida[maxn][20],cida[maxn][20]; 

int findrt(int x){return par[x]==x?x:par[x]=findrt(par[x]);}

void add(int from,int to,ll dist){
	edges.push_back(Edge(from,to,dist));
	int x=edges.size();
	g[from].push_back(x-1); 
}

ll kruscal(){
	memset(ok,0,sizeof(ok));
	sort(edges0.begin(),edges0.end());
	for(int i=0;i<n;++i){
		par[i]=i;
		g[i].clear(); 
	}
	int cnt=0;
	ll ans=0;
	for(int i=0;i<m;++i){
		Edge& e=edges0[i];
		int x=findrt(e.from);
		int y=findrt(e.to);
		if(x!=y){
			ok[i]=true;
			par[x]=y;
			int u=e.from;
			int v=e.to;
			ll d=e.dist;
			ans+=d;
			add(u,v,d);
			add(v,u,d);
			if(++cnt==n-1) break;
		}
	}
	return ans;
}

void dfs(int u,int fa,int dep,ll dist){
	depth[u]=dep;
	parent[u][0]=fa;
	zuida[u][0]=dist;
	cida[u][0]=-1;
	for(int i=0;i<g[u].size();++i){
		Edge& e=edges[g[u][i]];
		int v=e.to;
		if(v!=fa) dfs(v,u,dep+1,e.dist);
	}
}

void init(){
	int log=0;
	while((1<<(log+1))<=n) ++log;
	for(int j=1;j<=log;++j){
		for(int i=0;i<n;++i){
			int a=parent[i][j-1];
			if(a==-1){
				parent[i][j]=-1;
				zuida[i][j]=-1;
				cida[i][j]=-1;
			}
			else{
				parent[i][j]=parent[a][j-1];
				zuida[i][j]=max(zuida[i][j-1],zuida[a][j-1]);
				cida[i][j]=-1;
				if(zuida[i][j-1]!=zuida[a][j-1]) 
					cida[i][j]=min(zuida[i][j-1],zuida[a][j-1]);
				cida[i][j]=max(cida[i][j],cida[i][j-1]);
				cida[i][j]=max(cida[i][j],cida[a][j-1]);
			}
		}
	}
}

ll query(int u,int v,ll d){
	if(depth[u]<depth[v]) swap(u,v);
	int log=0;
	while((1<<(log+1))<=depth[u]) ++log;
	
	ll Max=-1,ciMax=-1;
	for(int k=log;k>=0;--k){
		if((depth[u]-depth[v])>>k&1){
			if(Max!=zuida[u][k])
				ciMax=max(ciMax,min(Max,zuida[u][k]));
			ciMax=max(ciMax,cida[u][k]);
			Max=max(Max,zuida[u][k]);
			u=parent[u][k];
		}
	}
	if(u==v){
		if(Max!=d) return Max;
		if(ciMax!=-1) return ciMax;
		else return -inf;
	}
	
	for(int k=log;k>=0;--k){
		if(parent[u][k]!=-1 && parent[u][k]!=parent[v][k]){
			if(Max!=zuida[u][k])
				ciMax=max(ciMax,min(Max,zuida[u][k]));
			ciMax=max(ciMax,cida[u][k]);
			if(Max!=zuida[v][k])
				ciMax=max(ciMax,min(Max,zuida[v][k]));
			ciMax=max(ciMax,cida[v][k]);
			Max=max(Max,zuida[u][k]);
			Max=max(Max,zuida[v][k]);
			u=parent[u][k];
			v=parent[v][k];
		}
	}
	if(Max!=zuida[u][0])
		ciMax=max(ciMax,min(Max,zuida[u][0]));
	ciMax=max(ciMax,cida[u][0]);
	if(Max!=zuida[v][0])
		ciMax=max(ciMax,min(Max,zuida[v][0]));
	ciMax=max(ciMax,cida[v][0]);
	Max=max(Max,zuida[u][0]);
	Max=max(Max,zuida[v][0]);
	
	if(Max!=d) return Max;
	if(ciMax!=-1) return ciMax;
	else return -inf;
}

int main(){
	while(scanf("%d%d",&n,&m)==2){
		edges0.clear();
		edges.clear();
		for(int i=0;i<m;++i){
			int u,v;
			ll w;
			scanf("%d%d%lld",&u,&v,&w);
			edges0.push_back(Edge(u-1,v-1,w));
		}
		ll mst=kruscal();
		dfs(0,-1,0,0);
		init();
		ll ans=inf;
		for(int i=0;i<m;++i){
			if(!ok[i]){
				Edge& e=edges0[i];
				ans=min(ans,mst-query(e.from,e.to,e.dist)+e.dist);
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
}
posted @ 2018-09-18 09:52  不想吃WA的咸鱼  阅读(69)  评论(0编辑  收藏  举报