BZOJ5188: [Usaco2018 Jan]MooTube 并查集+离线处理

BZOJ又不给题面...

Luogu的翻译看不下去...

题意简述

有一个$n$个节点的树，边有权值，定义两个节点之间的距离为两点之间的路径上的最小边权

给你$Q$个询问，问你与点$v$的距离超过$k$的点有多少个

$n,Q<=100000$

题解

很妙的做法。

并查集+离线

显然可以把询问离线，按K值排序

处理距离的话可以使用并查集，并不需要带权，只需要把边也按权值排序，用并查集维护。

具体做法：对每个点维护一个$siz$数组表示与它联通的节点数目，用类似双指针的方法把符合规则的边的两端点并起来，$siz$也顺便并起来就好

对于每个询问的答案就是把大于k的边并起来之后的$siz[v]-1$

#include<set>
#include<cstdio>
#include<algorithm>

#define ll long long
#define inf 0x3f3f3f3f
#define il inline 

namespace io {

    #define in(a) a=read()
    #define out(a) write(a)
    #define outn(a) out(a),putchar('\n')

    #define I_int int
    inline I_int read() {
        I_int x =  , f =  ; char c = getchar() ;
        while( c < '' || c > '' ) { if( c == '-' ) f = - ; c = getchar() ; }
        while( c >= '' && c <= '' ) { x = x *  + c - '' ; c = getchar() ; }
        return x * f ;
    }
    char F[  ] ;
    inline void write( I_int x ) {
        I_int tmp = x >  ? x : -x ;
        if( x <  ) putchar( '-' ) ;
        int cnt =  ;
        while( tmp >  ) {
            F[ cnt ++ ] = tmp %  + '' ;
            tmp /=  ;
        }
        while( cnt >  ) putchar( F[ -- cnt ] ) ;
    }
    #undef I_int

}
using namespace io ;

using namespace std ;

#define N 100010

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

struct node {
    int k , v , id ;
    bool operator < ( const node &x ) const {
        return k > x.k ;
    }
} b[ N ] ;

int f[ N ] , siz[ N ] ;
int n , m , ans[ N ] ;

int find( int x ) {
    if( f[ x ] == x ) return x ;
    else return f[ x ] = find( f[ x ] ) ;
}

int main() {
    n = read() ; m = read() ;
    for( int i =  ; i < n ; i ++ ) {
        a[ i ] = (edge) { read() , read() , read() } ;
    }
    for( int i =  ; i <= m ; i ++ ) {
        b[ i ] = (node) { read() , read() , i } ;
    }
    sort( a +  , a + n +  ) ; sort( b +  , b + m +  ) ;
    int j =  ;
    for( int i =  ; i <= n ; i ++ ) siz[ i ] =  , f[ i ] = i ;
    for( int i =  ; i <= m ; i ++ ) {
        while( j < n && a[ j ].w >= b[ i ].k ) {
            int x = find( a[ j ].u ) , y = find( a[ j ].v ) ;
            if( x != y ) {
                f[ y ] = x ;
                siz[ x ] += siz[ y ] ;
            }
            j ++ ;
        }
        ans[ b[ i ].id ] = siz[ find( b[ i ].v ) ] -  ;
    }
    for( int i =  ; i <= m ; i ++ ) {
        printf( "%d\n" , ans[ i ] ) ;
    }
    return  ;
}