G. Robots time limit per test 5.0 s memory limit per test 256 MB input standard input output standard output

The Robotics Olympiad teams were competing in a contest.

There was a tree drawn on the floor, consisting of n nodes and n - 1 edges. The nodes are numbered from 1 to n, and each edge has a weight. The tree is rooted at the first node. q teams are participating, and each team is given an integer x_i. Their robot should start at node 1, and move in the following way until there are no valid moves left: From all the edges between the current node and it's children, go through the edge with the maximum value less than x_i. Note that the robot can't move to the parent, only to children.

However, the teams weren't able to program the robots to return to them after the contest, so they had to manually pick them up. Since the tree can be quite large, they need your help to determine where each robot ended it's movement.

Input

The first line contains a single integer T, the number of test cases.

The first line of each test case contains two space-separated integers n and q. (1 ≤ n, q ≤ 10⁵).

The following n - 1 lines contain 3 integers u_i, v_i, w_i. This means that there is an edge connecting nodes u_i and v_i, with weight w_i. (1 ≤ u_i, v_i ≤ n) (1 ≤ w_i ≤ 10⁹). It's guaranteed that all w_i are distinct.

The following line contains q integers x_i. (1 ≤ x_i ≤ 10⁹).

Output

For each test case, print one line with a single number S_i, the sum of numbers of nodes where each robot ends.

Example input Copy

1
5 7
1 2 3
1 3 4
3 4 9
3 5 7
1 3 4 9 8 7 10

output Copy

21

Note

In the sample test case, the robots end in the following nodes: {1, 1, 2, 5, 5, 3, 4}.

S_i = 1+1+2+5+5+3+4 = 21.

Large I/O files. Please consider using fast input/output methods.

 

【题意】

有n个点，n-1条边，每条边有权值。现在有M个机器人，他们也有自己的权值，他们会从点1开始顺着这颗树向下走，每个机器人能走的边是那些边的权值严格小于机器*值的边。但是机器人是有选择的，它只会走那些能选择的边里面权值尽可能大的边走，并且它们是无法回头的。

现在询问给定的M个机器人最后停留在哪些点，求这些点的和

 

【分析】

把每个点连出去的边按照权值降序排序，这样保证在之后的遍历中优先选择边权大的（贪心）。每个机器人的最后停留位置是固定的，所以他们谁先走的顺序是无所谓的，只有权值才是我们需要的。所以按照机器人的权值从大到小也排序一遍，这里用优先队列来更新这个信息。

首先预处理出达到每个点所需要的最大的权值大小用mx[ ]记录。再按照DFS的顺序到达每个无法再向下的点的时候比较该点的mx[ i ]值与当前权值最大的机器人的权值，若机器人的权值大于mx[ i ]则表示这个机器人是可以到达这里的，此时更新答案并且把这个机器人从队列中取出。这样操作直到队头元素不满足权值大于mx[ i ]，然后开始回溯，这样就可以保证每个机器人一定是达到了他们固定的位置。
　

【代码】

#include<queue>
#include<cstdio>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+5;
struct E{
	int u,v,w;
	E(int _u=0,int _v=0,int _w=0){u=_u;v=_v;w=_w;}
	inline bool operator <(const E &a)const{
		return w>a.w;
	}
};
vector<E>e[N];
priority_queue<int>q;
int n,m,cas,mx[N];long long ans;
void dfs(int x,int fa){
	int sz=e[x].size();
	for(int i=0;i<sz;i++){
		int v=e[x][i].v;
		if(v!=fa){
			mx[v]=max(mx[x],e[x][i].w);
			dfs(v,x);
		}
	}
}
void DFS(int x,int fa){
	if(q.empty()||q.top()<=mx[x]) return ;
	int sz=e[x].size();
	for(int i=0;i<sz;i++){
		int v=e[x][i].v;
		if(v!=fa&&q.top()>mx[v]&&!q.empty()){
			DFS(v,x);
		}
	}
	for(;q.top()>mx[x]&&!q.empty();q.pop()) ans+=x;
}
inline void Clear(){
	ans=0;
	for(;!q.empty();q.pop());
	for(int i=1;i<=n;i++) e[i].clear(),mx[i]=0;
}
inline void Init(){
	scanf("%d%d",&n,&m);
	for(int i=1,x,y,z;i<n;i++) scanf("%d%d%d",&x,&y,&z),e[x].push_back(E(x,y,z)),e[y].push_back(E(y,x,z));
	for(int i=1,x;i<=m;i++) scanf("%d",&x),q.push(x);
	for(int i=1;i<=n;i++) sort(e[i].begin(),e[i].end());
}
inline void Solve(){
	dfs(1,0);
	DFS(1,0);
	printf("%I64d\n",ans);
}
int main(){
	for(scanf("%d",&cas);cas--;Clear()){
		Init();
		Solve();
	}
	return 0;
}