题目大意:给出一个n(2 <= n <= 100)个结点的无向图,找一棵苗条度(最大边减最小边的值)最小的生成树。图中不含自环或重边。
题目分析:枚举最小边求生成树即可。模板用用萌萌哒~
代码如下:
#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 = 1 ; ( 1 << j ) < n ; ++ 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[u][v],最小瓶颈路
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 ;//结点数,边数
void init () {
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 ( int x ) {//求最小生成树
F.init () ;
sort ( line + x , line + m ) ;
int cnt = 0 ;
//int ans = 0 ;
REPF ( i , x , m - 1 ) {
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 ;
return line[i].val - line[x].val ;
}
}
}
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 ;
while ( ~scanf ( "%d%d" , &tree.n , &tree.m ) && ( tree.n || tree.m ) ) {
REP ( i , tree.m )
tree.line[i].input () ;
int ans = tree.kruskal ( 0 ) ;//求最小生成树
if ( ans == -1 )
printf ( "-1\n" ) ;
else {
REPF ( i , 1 , tree.m ) {
int tmp = tree.kruskal ( i ) ;
if ( tmp == -1 ) {
break ;
}
ans = min ( ans , tmp ) ;
}
printf ( "%d\n" , ans ) ;
}
}
}
int main () {
work () ;
return 0 ;
}