【UVa】10600 ACM Contest and Blackout 次小生成树

类型：次小生成树

题目大意：

为了举办ACM竞赛，市长决定给所有的n(3 <= n <= 100)所学校提供可靠的电力供应。当且仅当一个学校直接连到电站，或者连到另一个有可靠供应的学校时，才有可靠供应。现在给出在不同学校之间的布线成本，找出最便宜的两种连线方案。一个方案的成本等于其中所有学校之间连线的成本的总和。

题目分析：

次小生成树。

先求出最小生成树，然后枚举所有不在树上的边(u,v)，和树构成环，然后去掉形成的环中属于最小生成树上的最长边maxcost[u][v]，将这条边替换进去形成新的最小生成树的权值。然后取所有新形成的最小生成树中权值最小的那一个，就是次小生成树。本题我直接用kruskal+倍增算法求解maxcost数组了，因为数据范围小，用prim时可以直接算得maxcost数组，效率不清楚。

PS：该算法同样可以判断最小生成树是否唯一。如果次小生成树的权值等于最小生成树，则不唯一，反之唯一。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

#define REPF( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define REPV( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define LOGF( j , a , b ) for ( int j = a ; ( 1 << j ) < b ; ++ j )
#define EDGE( i , x ) for ( int i = adj[x] ; ~i ; i = edge[i].n )
#define REP( i , n ) for ( int i = 0 ; i < n ; ++ i )
#define clear( a , x ) memset ( a , x , sizeof a )

const int LOGN = 20 ;
const int MAXN = 105 ;
const int MAXE = 100005 ;
const int OO = 0x3f3f3f3f ;
struct Line {
	int x , y , val ;
	void input () {
		scanf ( "%d%d%d" , &x , &y , &val ) ;
	}
	bool operator < ( const Line &a ) const {
		return val < a.val ;
	}
} ;

struct Edge {
	int v , w , n ;
	Edge ( int V = 0 , int W = 0 , int N  = 0 ) :
		v(V) , w(W) , n(N) {}
} ;

struct findAndUnion {
	int p[MAXN] ;
	int rank[MAXN] ;
	
	void init () {
		REP ( i , MAXN )
			p[i] = i , rank[i] = 1 ;
	}
	
	int find ( int x ) {//非递归查找+路径压缩
		int tmp , o = x , ans ;
		while ( p[o] != o )
			o = p[o] ;
		ans = o ;
		o = x ;
		while ( p[o] != o ) {
			tmp = p[o] ;
			p[o] = ans ;
			o = tmp ;
		}
		return ans ;
	}//find
	
	int Union ( int x , int y ) {//合并（按秩合并）
		int f1 = find ( x ) ;
		int f2 = find ( y ) ;
		if ( f1 != f2 ) {
			if ( rank[f1] <= rank[f2] ) {//秩小的合并到秩大的点上
				p[f1] = f2 ;
				if ( rank[f1] == rank[f2] )
					++ rank[f2] ;
			}
			else
				p[f2] = f1 ;
			return 1 ;
		}
		return 0 ;
	}//union
} ;

struct MST {
	//并查集
	findAndUnion F ;
	int p[MAXN] ;//并查集父节点
	
	Line line[MAXE] ;//读入边集
	
	Edge edge[MAXE] ;//最小生成树边集
	int adj[MAXN] , cntE ;//表头及指针
	
	//倍增处理及查询（可用于LCA）
	int maxcost[MAXN][LOGN] ;//maxcost[i][j]，最小瓶颈路
	int anc[MAXN][LOGN] ;//anc[i][j]表示结点i的第2^j级祖先，2^0就是父亲
	int cost[MAXN] ;//cost[i]表示i与父亲fa[i]之间的边权
	int fa[MAXN] ;//父节点
	int deep[MAXN] ;//结点深度
	
	int n , m ;//结点数，边数
	
	int s[MAXE] ;
	int top ;
	int ans ;
	
	void init () {
		top = 0 ;
		cntE = 0 ;
		clear ( adj , -1 ) ;
		clear ( deep , 0 ) ;
	}//init
	
	void addedge ( int u , int v , int w ) {
		edge[cntE] = Edge ( v , w , adj[u] ) ;
		adj[u] = cntE ++ ;
		edge[cntE] = Edge ( u , w , adj[v] ) ;
		adj[v] = cntE ++ ;
	}//addedge
	
	int kruskal () {//求最小生成树
		F.init () ;
		sort ( line , line + m ) ;
		int cnt = 0 ;
		top = 0 ;
		ans = 0 ;
		REP ( i , m ) {
			int tmp = F.Union ( line[i].x , line[i].y ) ;
			if ( tmp ) {
				++ cnt ;
				ans += line[i].val ;
				addedge ( line[i].x , line[i].y , line[i].val ) ;//添加树边
				/*
				if ( cnt == n - 1 ) {//已经得到所有树边，退出
					return ans ;
				}
				*/
			}
			else s[top ++] = i ;//未在生成树上的边
		}
		return -1 ;//构不成树
	}//kruskal
	
	void dfs ( int u , int p ) {//得到有根树
		EDGE ( i , u ) {
			int v = edge[i].v ;
			if ( v == p ) continue ;
			fa[v] = u ;//v的父亲是u
			deep[v] = deep[u] + 1 ;
			cost[v] = edge[i].w ;
			dfs ( v , u ) ;
		}
	}//dfs
	
	void preProcess () {//预处理出anc和maxcost数组
		REPF ( i , 1 , n ) {
			anc[i][0] = fa[i] ;// i^0 级祖先就是父亲
			maxcost[i][0] = cost[i] ;//i与fa[i]之间的最大权值就是cost[i]
			LOGF ( j , 1 , n )
				anc[i][j] = -1 ;
		}
		LOGF ( j , 1 , n )
			REPF ( i , 1 , n )
				if ( ~anc[i][j - 1] ) {
					int a = anc[i][j - 1] ;
					anc[i][j] = anc[a][j - 1] ;
					maxcost[i][j] = max ( maxcost[i][j - 1] , maxcost[a][j - 1] ) ;
					//选择i~anc[i][j - 1]中的最大权值和anc[i][j - 1]~anc[anc[i][j - 1]][j - 1]中的最大权值
					//也就是i ~ (i^(j-1)) 和 (i^(j-1)) ~ i^j 中选取最大权值(子段的最大权值已经求出)
				}
	}//preProcess
	
	int query ( int p , int q ) {//查询两点间的最小瓶颈路
		int tmp , log = 0 , ans = -OO ;
		if ( deep[p] < deep[q] )//令p的深度大于等于q，不满足就交换
			swap ( p , q ) ;
		LOGF ( i , 1 , deep[p] + 1 )//得到p的最大log段( 满足 ( 1 << log ) <= deep[p] , 1 << ( log + 1 ) > deep[p] )
			++ log ;
		REPV ( i , log , 0 )//将p的深度降低到与q相同，同时求出p到q深度之间的最大权值
			if ( deep[p] - ( 1 << i ) >= deep[q] ) {//第2^i级祖先的深度大于等于q
				ans = max ( ans , maxcost[p][i] ) ;
				p = anc[p][i] ;//跳到2^i级祖先的位置
			}
		if ( p == q )//q是p的祖先，则之前的处理直接让p下降到q的位置，p、q之间的最大权值已经求出
			return ans ;//LCA返回p( p 等于 q )
		REPV ( i , log , 0 )//比较的前提是p、q深度相同
			if ( ~anc[p][i] && anc[p][i] != anc[q][i] ) {
				//p和q深度相同，判断一个即可
				//同时祖先不能是同一个，保证所比较的都是唯一路径上的边，否则会跳出最近公共祖先，得到错误结果
				ans = max ( ans , maxcost[p][i] ) ;
				ans = max ( ans , maxcost[q][i] ) ;
				p = anc[p][i] ;//跳
				q = anc[q][i] ;//跳
			}
		ans = max ( ans , cost[p] ) ;
		ans = max ( ans , cost[q] ) ;
		return ans ;//LCA返回fa[p]( 它也等于fa[q] )
	}//query
} ;

MST tree ;

void work () {
	int u , v , k , ans = OO ;
	tree.init () ;
	scanf ( "%d%d" , &tree.n , &tree.m ) ;
	REP ( i , tree.m )
		tree.line[i].input () ;
	k = tree.kruskal () ;
	tree.dfs ( 1 , 0 ) ;
	tree.preProcess () ;
	REP ( i , tree.top )
		ans = min ( ans , tree.line[tree.s[i]].val - tree.query ( tree.line[tree.s[i]].x , tree.line[tree.s[i]].y ) ) ;
	printf ( "%d %d\n" , tree.ans , tree.ans + ans ) ;
}

int main () {
	int T ;
	scanf ( "%d" , &T ) ;
	while ( T -- )
		work () ;
	return 0 ;
}