[2010国家集训队]Crash的旅游计划

Description

眼看着假期就要到了,Crash由于长期切题而感到无聊了,因此他决定利用这个假期和好友陶陶一起出去旅游。
Crash和陶陶所要去的城市里有N (N > 1) 个景点,Crash用正整数1到N给景点标号。
这些景点之间通过N - 1条无向道路相连,每条道路有一个长度,并且保证任意两个景点之间都有且仅有一条路径相连。
现在对于一个景点s,Crash和陶陶从s出发,然后访问一个景点序列{v0, v1, v2, … , vk},
其中v0就是s,且vi-1和vi(0 < i ≤ k)之间有道路相连。
需要注意的是,陶陶和Crash访问的景点序列中不会只有景点s。
为了使旅程不显得乏味,在一个景点序列里他们不会重复走某条道路。
我们定义这个序列的旅游代价为经过道路的长度和。下面问题出现了:
陶陶:我们走一条景点数最多的景点序列吧。
Crash:倒,你想把我累死啊。
陶陶:谁叫你整天坐在电脑前面,不出来锻炼,这下子傻了吧,哈哈哈哈~~
Crash:不行,如果你非要走景点数最多的我就不陪你走了。
陶陶:笑喷油你很跳嘛!
Crash:这样吧,我们来写伸展树,如果我写的比你快,你就要听我的。
陶陶:这样不公平哎,我们来玩PES吧,当然你要让我选法国队,如果你输了你就要听我的。
Crash:倒,你这是欺负我,T_T~
陶陶:笑喷油好说话哎。
Crash:囧……
……
这样搞了半天,最终陶陶和Crash用很多次包剪锤决定出选择旅游代价第K小 的景点序列。
不过呢Crash和陶陶还没确定开始旅行的景点s,因此他希望你对于每个景点i,计算从景点i开始的景点序列中旅游代价第K小的值。

Input

共N行。
第1行包含一个字符和两个正整数,字符为ABCD中的一个,用来表示这个测试数据的类型
(详见下面的数据规模和约定),另外两个正整数分别表示N和K (K < N),N<=100000
第2行至第N行,每行有三个正整数u、v和w (u, v ≤ N,w ≤ 10000)。
表示u号景点和v号景点之间有一条道路,长度为w。
输入文件保证符合题目的约定,即任意两个景点之间都有且仅有一条路径相连。

Output

共N行,每行有一个正整数。
第i行的正整数表示从i号景点开始的景点序列中旅游代价第K小的代价。

Sample Input

A 6 3

1 2 2

1 3 4

1 4 3

3 5 1

3 6 2

Sample Output

4

6

4

7

5

6

//样例1中输出对应的景点序列分别为:

1号景点是{1, 3},2号景点是{2, 1, 3},3号景点是{3, 1},4号景点是{4, 1, 3},5号景点是{5, 3, 1},6号景点是{6, 3, 1}。

保证每个景点到1号景点需要经过的道路数不超过30


题解

题意就是给出\(n\)个点的一棵树,对于每个点求出距离ta第\(k\)小的距离

动态点分治
我们可以先建出点分树
然后二分一个距离\(k\),判断其他点到这个点的距离小于等于这个值的有几个
那么现在的问题就是给出一个点,求出到这个点的距离不大于\(k\)的有几个点
\(v1[u]\)数组表示\(u\)的子树内的点到\(u\)的距离,\(v2[u]\)表示\(u\)的子树内的点到\(fa[u]\)的距离
然后每次查询点\(u\)的时候就顺着点分树往上跳,期间查询所有的点到点\(u\)的距离不超过\(k\)的点
注意每次往上跳到\(fa[u]\)再查\(fa[u]\)的子树的时候会把已经统计过的\(u\)的子树的信息重复统计一部分,所以我们要容斥掉\(u\)的子树内的信息
注意往上跳的时候如果跳到点\(x\)使得\(dis(u,x)>k\)也不要直接\(break\),而是要继续往上跳,因为点分树是将原树重构了,可能\(dis(u,x)>k\)了但是\(x\)的祖先到\(u\)的距离\(\le k\)

代码

#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
const int M = 200005 ;
const int INF = 1e9 ;
using namespace std ;

inline int read() {
	char c = getchar() ; int x = 0 , w = 1 ;
	while(c>'9'||c<'0') { if(c=='-') w = -1 ; c = getchar() ; }
	while(c>='0'&&c<='9') { x = x*10+c-'0' ; c = getchar() ; }
	return x*w ;
}

bool vis[M] ;
int n , k , num , tot , tmx , root , hea[M] ; 
int dis[M] , ff[M] , fa[M] , size[M] , dep[M] , son[M] , top[M] ;
vector < int > v1[M] , v2[M] ;
struct E { int nxt , to , dis ; } edge[M * 2] ;
inline void add_edge(int from , int to , int dis) {
	edge[++num].nxt = hea[from] ; edge[num].to = to ;
	edge[num].dis = dis ; hea[from] = num ;
}

void dfs1(int u , int father , int depth) {
	ff[u] = father ; size[u] = 1 ; dep[u] = depth ; int mx = -1 ;
	for(int i = hea[u] ; i ; i = edge[i].nxt) {
		int v = edge[i].to ; if(v == father) continue ;
		dis[v] = dis[u] + edge[i].dis ; dfs1(v , u , depth + 1) ; 
		size[u] += size[v] ;  if(size[v] > mx) mx = size[v] , son[u] = v ;
	}
}
void dfs2(int u , int topf) {
	top[u] = topf ; if(!son[u]) return ; dfs2(son[u] , topf) ;
	for(int i = hea[u] ; i ; i = edge[i].nxt) {
		int v = edge[i].to ; if(v == ff[u] || v == son[u]) continue ;
		dfs2(v , v) ;
	}
}
inline int LCA(int x , int y) {
	while(top[x] != top[y]) {
		if(dep[top[x]] < dep[top[y]]) swap(x , y) ;
		x = ff[top[x]] ;
	}
	return dep[x] < dep[y] ? x : y ;
}
inline int Gdis(int x , int y) {
	return dis[x] + dis[y] - dis[LCA(x , y)] * 2 ;
}
void findroot(int u , int father) {
	size[u] = 1 ; int mx = 0 ;
	for(int i = hea[u] ; i ; i = edge[i].nxt) {
		int v = edge[i].to ; if(vis[v] || v == father) continue ;
		findroot(v , u) ; mx = max(mx , size[v]) ; size[u] += size[v] ;
	}
	mx = max(mx , tot - size[u]) ;
	if(mx < tmx) tmx = mx , root = u ;
}

void Solve(int u , int father) {
	fa[u] = father ; vis[u] = true ;
	for(int i = hea[u] ; i ; i = edge[i].nxt) {
		int v = edge[i].to ; if(vis[v]) continue ;
		tot = size[v] ; tmx = INF ; 
		findroot(v , u) ; Solve(root , u) ;
	}
}
// v1 表示u的子树内的点到u的距离
// v2 表示u的子树内的点到fa[u]的距离 
inline void Insert(int x) {
	v1[x].push_back(0) ;
	for(int u = x ; fa[u] ; u = fa[u]) {
		v1[fa[u]].push_back(Gdis(x , fa[u])) ;
		v2[u].push_back(Gdis(x , fa[u])) ;
	}
}
inline int query(int id , int x , int k) {
	if(id == 1) {
		int l = 0 , r = v1[x].size() - 1 , mid , ret = -1 ;
		while(l <= r) {
			mid = (l + r) >> 1 ;
			if(v1[x][mid] <= k) l = mid + 1 , ret = mid ;
			else r = mid - 1 ;
		}
		return ret + 1 ;
	}
	else {
		int l = 0 , r = v2[x].size() - 1 , mid , ret = -1 ;
		while(l <= r) {
			mid = (l + r) >> 1 ;
			if(v2[x][mid] <= k) l = mid + 1 , ret = mid ;
			else r = mid - 1 ;
		}
		return ret + 1 ;
	}
}
inline int check(int x , int k) {
	int ans = query(1 , x , k) ;
	for(int u = x , dis1 ; fa[u] ; u = fa[u]) {
		dis1 = Gdis(x , fa[u]) ; if(k - dis1 < 0) continue ;
		ans += query(1 , fa[u] , k - dis1) - query(2 , u , k - dis1) ;
	}
	return ans - 1 ;
}
int main() {
	char s[10] ; scanf("%s",s) ; n = read() ; k = read() ;
	for(int i = 1 , u , v , w ; i < n ; i ++) {
		u = read() ; v = read() ; w = read() ;
		add_edge(u , v , w) ; add_edge(v , u , w) ;
	}
	dfs1(1 , 0 , 1) ; dfs2(1 , 1) ; 
	tot = n ; tmx = INF ; findroot(1 , 0) ; Solve(root , 0) ;
	for(int i = 1 ; i <= n ; i ++) Insert(i) ;
	for(int i = 1 ; i <= n ; i ++) {
		sort(v1[i].begin() , v1[i].end()) ;
		sort(v2[i].begin() , v2[i].end()) ;
	}
	for(int u = 1 ; u <= n ; u ++) {
		int l = 1 , r = 1e9 , ret = 0 ;
		while(l <= r) {
			int mid = (l + r) >> 1 ;
			if(check(u , mid) >= k) ret = mid , r = mid - 1 ;
			else l = mid + 1 ;
		}
		printf("%d\n",ret) ;
	}
	return 0 ;
}
posted @ 2019-04-02 21:52  beretty  阅读(225)  评论(0编辑  收藏  举报