BZOJ 3732 题解

3732: Network

Description

给你N个点的无向图 (1 <= N <= 15,000)，记为：1…N。 
图中有M条边 (1 <= M <= 30,000) ，第j条边的长度为： d_j ( 1 < = d_j < = 1,000,000,000).

现在有 K个询问 (1 < = K < = 15,000)。 
每个询问的格式是：A B，表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Input

第一行： N, M, K。 
第2..M+1行: 三个正整数：X, Y, and D (1 <= X <=N; 1 <= Y <= N). 表示X与Y之间有一条长度为D的边。 
第M+2..M+K+1行: 每行两个整数A B,表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Output

对每个询问，输出最长的边最小值是多少。

Sample Input

6 6 8
1 2 5
2 3 4
3 4 3
1 4 8
2 5 7
4 6 2
1 2
1 3
1 4
2 3
2 4
5 1
6 2
6 1

Sample Output

5
5
5
4
4
7
4
5

HINT

1 <= N <= 15,000

1 <= M <= 30,000

1 <= d_j <= 1,000,000,000

1 <= K <= 15,000

—————————————分割线—————————————

为了保证最长边最小，即求图的最小瓶颈生成树，原图的最小瓶颈生成树就是最小生成树。

代码：

 /**************************************************************
     Problem: 3732
     User: shadowland
     Language: C++
     Result: Accepted
     Time:372 ms
     Memory:32768 kb
 ****************************************************************/

 /*
     树链剖分
     author : SHHHS
     2016-10-02 09:04:15
 */
 #include "bits/stdc++.h"

 using namespace std ;

 struct MST{int x , y , val ; } ;
 struct Edge{int to , next , val ; } ;
 struct SegTree{int l , r , mintr ; } ;
 const int INF =  ;
 const int maxN =  ;
 typedef long long QAQ ;

 MST MST_e[ maxN ] ;
 Edge e [ maxN ] ;
 SegTree tr[ maxN <<  ] ;
 int head[maxN] , father[maxN], DFN[maxN], hv[maxN],rank[maxN], E_val[maxN], start[maxN], pre[maxN];
 bool vis[maxN] ;

 int cnt , dfs_num ;
 QAQ Ans = INF ;

 void Init ( int n ){for ( int i =  ; i <= n ; ++i )father[ i ] = i ; }
 int getfa ( int x ){if(father[x] == x)return x ; else return father[ x ] = getfa( father[ x ] ) ; }
 inline bool cmp ( MST x , MST y ){ return x.val < y.val ; }
 inline int gmin ( int x , int y ){ return x < y ? y : x ; }
 inline void Union_Set ( const int x , const int y ){ father[ x ] = y ; }
 inline void Push_up ( int i ){tr[ i ].mintr = gmin (tr[ i <<  |  ].mintr, tr[ i <<  ].mintr) ; }
 inline void gswap ( int &x , int &y ) {int temp = x ; x = y ; y = temp ; }
 bool Check ( const int x , const int y ) { return getfa( x ) == getfa( y ) ? true : false ; }

 void Build_Tree ( int x , int y , int i ) {
         tr[ i ].l = x ;
         tr[ i ].r = y ;
         if ( x == y ) tr[ i ].mintr = E_val[ rank[ x ] ] ;
         else {
                 int mid = ( tr[ i ].l + tr[ i ].r ) >>  ;
                 Build_Tree ( x , mid , i <<  ) ;
                 Build_Tree ( mid +  , y , i <<  |  ) ;
                 Push_up ( i ) ;
         }
 }

 inline void Add_Edge ( const int x , const int y , const int _val ) {
         e[ ++cnt ].to = y ;
         e[ cnt ].val = _val ;
         e[ cnt ].next = head[ x ] ;
         head[ x ] = cnt ;
 }

 void MST ( int N , int M ) {
         int cnt_ =  ;
         Init ( N ) ;
         sort ( MST_e +  , MST_e + M +  , cmp ) ;
         for ( int i =  ; i <= M ; ++i ) {
                 int px = getfa ( MST_e[i].x ) ;
                 int py = getfa ( MST_e[i].y ) ;
                 if ( px == py ) continue ;
                 else {
                         Union_Set ( px , py ) ;
                         Add_Edge ( MST_e[i].x , MST_e[i].y , MST_e[i].val ) ;
                         Add_Edge ( MST_e[i].y , MST_e[i].x , MST_e[i].val ) ;
                         ++cnt_ ;
                 }
                 if ( cnt_ == N -  ) break ;
         }
 }

 int Init_DFS ( const int x , const int fa ) {
         vis[ x ] = true ;
         int cnt_ =  , max_ =  ;
         for ( int i = head[ x ] ; i ; i = e[ i ].next ) {
                 int temp = e[ i ].to ;
                 if ( temp == fa ) continue ;
                 int _ = Init_DFS ( temp , x ) ;
                 if ( _ > max_ ) {
                         max_ = _ ;
                         hv[ x ] = temp ;
                 }
                 cnt_ += _;
         }
         return cnt_ ;
 }

 void DFS ( const int x , const int fa ) {
         vis [ x ] = false ;
         if ( !start[ x ] ) start[ x ] = start[ fa ] ;
         DFN[ x ] = ++ dfs_num ;
         rank[ dfs_num ] = x ;
         if ( hv[ x ] ) DFS ( hv[ x ] , x ) ;
         for ( int i = head[ x ] ; i ; i = e[ i ].next ) {
                 if ( e[ i ].to == fa ) continue ;
                 E_val[ e[ i ].to ] = e[ i ] .val ;
                 if ( e[ i ].to != hv[ x ] && e[ i ].to != fa && vis[ e[ i ].to ] == true ) {
                         int temp = e[ i ].to ;
                         start[ temp ] = temp ;
                         pre [ temp ] = x ;
                         DFS ( temp , x ) ;
                 }
         }
 }

 QAQ Query_Tree ( int q , int w , int i ) {
         if ( q <= tr[i].l && w >= tr[i].r ) return tr[i].mintr;
         else {
                 int mid = ( tr[ i ].l + tr[ i ].r ) >>  ;
                 if ( q > mid ) return Query_Tree ( q , w , i <<  | ) ;
                 else if ( w <= mid ) return Query_Tree ( q , w , i <<  ) ;
                 else return gmin ( Query_Tree ( q , w , i <<  |  ) , Query_Tree ( q , w , i <<  ) ) ;
         }
 }

 void Solve ( const int x , const int y ) {
         int px = x , py = y ;
         while ( start[ px ] != start[ py ] ) {
                 if ( DFN[ start[ px ] ] > DFN[ start[ py ] ] ) {
                         Ans = gmin ( Ans , Query_Tree ( DFN[start[ px ]] , DFN[px] ,  ) ) ;
                         px = pre[ start[ px ] ] ;
                 }
                 else {//py跳
                         Ans = gmin ( Ans , Query_Tree ( DFN[start[ py ]] , DFN[py] ,  ) ) ;
                         py = pre[ start[ py ] ] ;
                 }
         }

         if ( px == py ) return ;
         int dfn_px = DFN[ px ] , dfn_py = DFN[ py ] ;
         if ( dfn_px  > dfn_py ) gswap ( dfn_px , dfn_py ) ;
         Ans = gmin ( Ans , Query_Tree ( dfn_px + , dfn_py ,  ) );
 }

 void DEBUG__ ( int n ){
         putchar ( '\n' ) ;
         for ( int i =  ; i <= n ; ++i )printf ("%d : %d %d\n", i , E_val[rank[ i ] ] , E_val[ i ]) ;
         putchar ( '\n' ) ;
 }
 void DEBUG_ ( int m ) {
         putchar('\n');
         for ( int i =  ; i <= m ; ++i ) printf ("%d %d %d\n" , MST_e[ i ].x , MST_e[ i ].y , MST_e[ i ].val) ;
 }
 int main ( ) {
         int N , M , Q , _x , _y ;
         scanf ( "%d%d%d" , &N , &M , &Q ) ;
         for ( int i =  ; i <= M ; ++i )
                 scanf ( "%d%d%d" , &MST_e[ i ].x , &MST_e[ i ].y , &MST_e[ i ].val ) ;
         MST ( N , M ) ;

         Init_DFS (  ,  ) ;
         start[  ] =  ;
         E_val[  ] = -INF ;

         //DEBUG_( M );
         DFS (  ,  ) ;

         Build_Tree (  , dfs_num ,  ) ;

         //DEBUG__( dfs_num ) ;
         while ( Q-- ){
                 Ans = -INF ;
                 scanf ( "%d%d" , &_x , &_y ) ;
                 if ( Check ( _x , _y ) ) {
                         Solve ( _x , _y ) ;
                         printf ( "%lld\n" , Ans ) ;
                 }
         }
         return  ;
 }

BZOJ 3727

NOIP_RP++;

2016-10-11 03:53:37

(完)