[NOIP2015]运输计划

题目链接 : CodeVS 4632

题目大意
在一棵 $N$ 节点树上，有 $M$ 个运输计划( 从$ai$ 到 $bi$ ) ，$N , M \le 300000$ 。
问：把哪一条树边的权值变为0，可以使所有运输计划的最大距离最小，输出这个最大距离的最小值。

分析
0. 首先要会LCA和树上差分。
1. 显然，这道题要求树上两点之间的距离，所以要写LCA( 我是用数剖写的LCA )，现在问题就是怎么选取变为0的树边。
2. 对于一个某一个答案 $X$ ，若 $X$ 可以作为答案，那么所有比 $X$ 小的答案可以实现，满足二分条件，二分答案求解。
3. 对于某一个 $X$ ，把所有距离大于 $X$ 的运输计划进行树上差分。若找到一条边，满足 $Maxdist-val \le X$ 而且所有距离大于 $X$ 运输计划都经过这条边，则返回 $true$ ，否则，返回 $false$ 。
4. 最后二分出的答案最大值即为问题的解。

PS. 不知道用数剖LCA合适不合适

上代码

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

const int N = 3e5 + 5 ;

int n, m, maxn ;

// vector比较慢，可能T，所以选择手写邻接表
int head[ N ], llen ;
struct node_lib {
    int to, wigh, next ;
    inline void add( int a , int b , int c ) {
        to = b, wigh = c ;
        next = head[ a ], head[ a ] = llen ++ ;
    }
} lib[ N << 1 ] ;

// 数剖模板(没有加线段树)
int fa[ N ], size[ N ], son[ N ], deep[ N ], dist[ N ] ;
int top[ N ], pass[ N ], plen ; // 注意这个pass数组，下面有用
void dfs1( int a , int b ) {
    fa[ a ] = b, size[ a ] = 1, deep[ a ] = deep[ b ] + 1 ;
    for ( int p = head[ a ] ; p != -1 ; p = lib[ p ].next ) {
        int node = lib[ p ].to, cost = lib[ p ].wigh ;
        if ( node == b )    continue ;
        dist[ node ] = dist[ a ] + cost ;
        dfs1( node , a ), size[ a ] += size[ node ] ;
        if ( size[ node ] > size[ son[ a ] ] )  son[ a ] = node ;
    }
}
void dfs2( int a , int b ) {
    top[ a ] = b, pass[ ++ plen ] = a ;
    if ( son[ a ] ) dfs2( son[ a ] , b ) ;
    for ( int p = head[ a ] ; p != -1 ; p = lib[ p ].next ) {
        int node = lib[ p ].to ;
        if ( node == fa[ a ] || node == son[ a ] )  continue ;
        dfs2( node , node ) ;
    }
}

// 数剖LCA
int calc_lca( int a , int b ) {
    int f1 = top[ a ], f2 = top[ b ] ;
    while ( f1 != f2 ) {
        if ( deep[ f1 ] < deep[ f2 ] )  
            swap( f1 , f2 ), swap( a , b ) ;
        a = fa[ f1 ], f1 = top[ a ] ;
    }
    return deep[ a ] < deep[ b ] ? a : b ;
}

struct node_tran { // 记录所有的计划
    int st, to, lca ;
    int wigh ;
} tran[ N ] ;
void init() {
    int a, b, c ;
    llen = 0 ;
    memset( head , 0xff , sizeof( head ) ) ;
    scanf( "%d %d", &n, &m ) ;
    for ( int i = 1 ; i < n ; i ++ ) {
        scanf( "%d %d %d", &a, &b, &c ) ;
        lib[ llen ].add( a , b , c ) ;
        lib[ llen ].add( b , a , c ) ;
    }
    dfs1( 1 , 0 ) ;
    dfs2( 1 , 1 ) ;
    for ( int i = 1 ; i <= m ; i ++ ) { // LCA求树上距离
        scanf( "%d %d", &a, &b ), c = calc_lca( a , b ) ;
        tran[ i ].st = a, tran[ i ].to = b, tran[ i ].lca = c ;
        tran[ i ].wigh = dist[ a ] + dist[ b ] - ( dist[ c ] << 1 ) ;
        maxn = max( maxn , tran[ i ].wigh ) ;
    }
}

int cover[ N ] ;
bool judge( int a ) {
    int num = 0 ;
    memset( cover , 0 , sizeof( cover ) ) ;
    for ( int i = 1 ; i <= m ; i ++ )
        if ( tran[ i ].wigh > a ) { // 把所有的大与ａ的计划进行树上差分
            cover[ tran[ i ].st ] ++, cover[ tran[ i ].to ] ++ ;
            cover[ tran[ i ].lca ] -= 2, num ++ ;
        }
    for ( int i = n ; i >= 1 ; i -- ) // 按照pass数组(dfs遍历)的顺序更新，从叶子到根
        cover[ fa[ pass[ i ] ] ] += cover[ pass[ i ] ] ;
    for ( int i = 1 ; i <= n ; i ++ )
        if ( cover[ i ] == num && dist[ i ] - dist[ fa[ i ] ] >= maxn - a ) return true ;
    return false ;
}
int figure() {
    int l = 0, r = maxn ;
    int mid = 0, ans = 0 ;
    while ( l <= r ) { // 二分求解
        mid = ( l + r ) >> 1 ;
        if ( judge( mid ) )
            r = mid - 1, ans = mid ;
        else
            l = mid + 1 ;
    }
    return ans ;
}
int main() {
    init() ;
    printf( "%d\n", figure() ) ;
    return 0 ;
}

以上