SCU 3365 学习 LCA 的线段树做法

传送门：SCU 3365

前面我也写过  

SCU 3365 倍增的解法

SCU 3365 ST 表的解法

SCU 3365 Disjkstra 的解法

其实，LCA 既然可以用 ST 表求 RMQ （区间最值）来找，也当然可以用线段树求区间最值来找啦，也不乏树状数组求区间最值，还有直接遍历（虽然很慢，但也能求），如果不懂 LCA 和区间最小值有啥关系，可以先看  hdu 2586 学习 LCA 的ST表解法

所以在这里，线段树只是起到一个求区间最值的作用，得出遍历的序列和 ST 表解法一样。

其实，还是不太好写的，在这里，得出访问的序列 ver 数组 和这个序列每个点的深度dep 数组，就是要对这个序列的 dep 数组进行线段树的区间查询。建树要在一般的建树上做一下改动

void Build( int l , int r , int u ){
	if( l == r ){
		node[u].first = dep[l] , node[u].second = l ;  
		// cout << "线段树 " << u << "  的地方在 dep  数组中的序列的点是  " << l << endl ; 
		return ;
	}
	int mid = ( l + r ) / 2 ;
	Build( lson ) ;
	Build( rson ) ;
	if( node[2*u] <= node[2*u+1] )
		node[u].first = node[2*u].first , node[u].second = node[2*u].second ;  // second 记录的是最值在序列中的位置
	else 
		node[u].first = node[2*u+1].first , node[u].second = node[2*u+1].second ;
}

整棵树所有的节点，除了记录区间最值信息之外，还要记录这个最值对应在序列上的位置 。

很奇怪，我写的这个代码，在 SCU 只要 4ms , 比我写的倍增还要快，在 hdu 2586 却超时...... 不懂，这两题要实现的功能是一样的

SCU  3365 

#include <bits/stdc++.h>
using namespace std ;
#define lson l , mid , 2*u
#define rson mid+1 , r , 2*u+1
typedef pair<int,int> P ;
int n , Q , len , curl , curr ;
P node[4*1050|1] ;
int head[1050] , k ;
int dis[1050] ;
int first[1050] ;        // 记录这个点第一次出现的位置
int ver[1050<<1] , dep[1050<<1] , top ; // ver 记录 2*n-1 序列的点 , R 记录这些点的位置
struct Node{
	int v , w , next ;
} e[1050<<1|1] ;

void Add( int u , int v , int cost ){
	e[k].v = v , e[k].w = cost , e[k].next = head[u] , head[u] = k++ ;
}

void DFS( int u , int depth ){
	ver[++top] = u , first[u] = top , dep[top] = depth ;
	int i , v ;
	for( i = head[u] ; i != -1 ; i = e[i].next ){
		v = e[i].v ;
		if( dis[v] ) continue ;
		dis[v] = dis[u] + e[i].w ;
		DFS( v , depth + 1 ) ;
		ver[++top] = u , dep[top] = depth ;  // 回溯记录经过的点共 2*n-1 个
	}
}

void Build( int l , int r , int u ){
	if( l == r ){
		node[u].first = dep[l] , node[u].second = l ;
		// cout << "线段树 " << u << "  的地方在 dep  数组中的序列的点是  " << l << endl ; 
		return ;
	}
	int mid = ( l + r ) / 2 ;
	Build( lson ) ;
	Build( rson ) ;
	if( node[2*u] <= node[2*u+1] )
		node[u].first = node[2*u].first , node[u].second = node[2*u].second ;
	else 
		node[u].first = node[2*u+1].first , node[u].second = node[2*u+1].second ;
}

P Quiry( int l , int r , int u ){
	if( curl > r || curr < l )
		return P( 0x3f3f3f3f , u ) ;    // 剪枝
	if( curl <= l && curr >= r )
		return node[u] ;
	int mid = ( l + r ) / 2 ;
	return min( Quiry( lson ) , Quiry( rson ) ) ;
}

int main(){
	int i , u , v , w ;
	while( ~scanf( "%d%d" , &n , &Q ) ){
		memset( head , -1 , sizeof( head ) ) ;
		memset( dis , 0 , sizeof( dis ) ) ;
		k = 0 ;
		for( i = 1 ; i <= n-1 ; ++i ){
			scanf( "%d%d%d" , &u , &v , &w ) ;
			Add( u , v , w ) ;
			Add( v , u , w ) ;
		}
		dis[1] = 1 , top = 0 , len = 2*n-1 ;
		DFS( 1 , 1 ) ;
		Build( 1 , len , 1 ) ;
		while( Q-- ){
			scanf( "%d%d" , &u , &v ) ;
			curl = first[u] , curr = first[v] ;   
			if( curl > curr )                    // 保证区间左边深度 < 区间右边深度
				swap( curl , curr ) ;               
			int lca = ver[Quiry( 1 , len , 1 ).second] ;   // 取出最值点在序列中的点，对应的原来的点 ver[]
			int ans = dis[u] + dis[v] - 2*dis[lca] ;
			printf( "%d\n" , ans ) ;
		}
	}
	return 0 ;
}