题干：

There was a civil war between two factions in Skyrim, a province of the Empire on the continent of Tamriel. The Stormcloaks, led by Ulfric Stormcloak, are made up of Skyrim's native Nord race. Their goal is an independent Skyrim free from Imperial interference. The Imperial Legion, led by General Tullius, is the military of the Empire that opposes the Stormcloaks and seeks to reunite and pacify the province. 

The current target of General Tullius is to defend Whiterun City. Near by this city there are NN towers under the Empire's control. There are N−1N−1 roads link these tower, so solders can move from any tower to another one through these roads. 

In military affairs, tactical depth means the longest path between two towers of all. Larger the tactical depth is, more stable these towers are. 

According to the message sent by spies, General Tullius believe that Stormcloaks is planning to attack one of these roads, and his towers would be divided into two parts. However, Tullius does not know which one, so he supposes the possibility that Stormcloaks attack these roads are the same. Now, General Tullius ask for your help, to calculate the expectation of tactical depth after this attack. 

To avoid the issue of precision, you need to calculate expectationoftacticaldepth×(N−1)expectationoftacticaldepth×(N−1).

Input

The first line of input contains an integer tt, the number of test cases. tt test cases follow. 
For each test case, in the first line there is an integer N(N≤100000)N(N≤100000). 
The ii-th line of the next N−1N−1 lines describes the ii-th edge. Three integers u,v,w (0≤w≤1000)u,v,w (0≤w≤1000) describe an edge between uu and vv of length ww.

Output

For each test cases, output expectationoftacticaldepth×(N−1)expectationoftacticaldepth×(N−1).

Sample Input

2
3
2 1 2
3 2 5
5
2 1 7
3 1 7
4 2 5
5 2 6

Sample Output

7
63

题目大意：

给出一棵树，边上有权值，现在毁掉任意一条边，分成两部分，求这两部分中最远的两点距离期望，答案*（n-1）

一句话题意：

N个点的一棵带权树。切掉某条边的价值为切后两树直径中的最大值。求各个边切掉后的价值和（共N-1项）。

解题报告：

说白了就是求最远距离加成和 
对于一棵树来说，两点最远的距离，考虑两点： 
1.最长链没有被拆开，那么答案就是最长链； 
2.最长链被拆开了，那么答案一定在最长链的端点到某个叶子结点上； 
第一点很显然，关于第二点的证明很简单，假设最长路不是最长链的端点到某个叶子结点，那么另一条更长的路径会取代他成为树的直径，与已知矛盾。

有了这个结论，这个题就好做了，首先预处理出最长链，数组存下来，然后对于每个最长链上的结点预处理出它的权值最大的叶子结点（不在最长链上），注意这里的处理看似是n^2的，但是因为是一棵树，所以其实每个点只会被扫到一遍所以是线性的。剩下的就是处理最长链左边和右边的拆开后的最大值了，左右扫一遍，两个数组LR存下来，最后On扫一遍最长链，取LR中最大值得到答案。 

刚开始想在bfs的过程中就处理处nxt数组和nxtw数组，后来发现不行，因为你不能保证dis[v]>ans的时候更新的一定是最终选择的路径，所以还是需要从起点到终点dfs一次，在回溯的时候这条路径一定是我们选择的。

AC代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#include<set>
#include<string>
#include<cmath>
#include<cstring>
#define F first
#define S second
#define ll long long
#define pb push_back
#define pm make_pair
using namespace std;
typedef pair<int,int> PII;
const int MAX = 2e5 + 5;
struct Edge {int u,v;ll w;int ne;
} e[MAX];
int head[MAX],tot,n;//记录边数 
int path[MAX],nxt[MAX],top;//top记录最长链上的顶点数
ll dis[MAX],nxtw[MAX],sum[MAX],val[MAX],L[MAX],R[MAX];
int flag[MAX];
void add(int u,int v,ll w) {e[++tot].u = u;e[tot].v = v;e[tot].w = w;e[tot].ne = head[u];head[u] = tot;
}
int bfs(int st,ll& ans) {queue<int> q;int retp = st;ans = 0;//注意初始化 for(int i = 1; i<=n; i++) dis[i] = -1,nxt[i]=-1;q.push(st);dis[st] = 0; while(!q.empty()) {int cur = q.front();q.pop();for(int i = head[cur]; ~i; i = e[i].ne) {int v = e[i].v;if(dis[v] != -1) continue;q.push(v);dis[v] = dis[cur] + e[i].w;if(dis[v] >= ans) {ans = dis[v];retp = v;}}}return retp;
}
int st,ed;
bool ok;
void dfs(int cur,int fa) {if(cur == ed) {ok = 1;return;}for(int i = head[cur]; ~i; i = e[i].ne) {int v = e[i].v;if(v == fa) continue;dfs(v,cur);if(ok == 1) {nxt[cur] = v;nxtw[cur] = e[i].w;return;}}
}
ll dfs2(int cur,int fa) {ll res = 0;for(int i = head[cur]; ~i; i = e[i].ne) {int v = e[i].v;if(flag[v] == 1 || v == fa) continue;res = max(res,dfs2(v,cur) + e[i].w);}return res;
}
int main()
{int t;cin>>t;while(t--) {scanf("%d",&n);//inittot=top=0;ok=0;for(int i = 1; i<=n; i++) head[i] = -1,sum[i] = 0,val[i]=L[i]=R[i]=0,flag[i] = 0;for(int a,b,i = 1; i<=n-1; i++) {ll c;scanf("%d%d%lld",&a,&b,&c);add(a,b,c);add(b,a,c);}ll maxx,ans=0;st = bfs(1,maxx); ed = bfs(st,maxx);dfs(st,-1);for(int i = st; i!=-1; i = nxt[i]) {flag[i] = 1;path[++top] = i;}ans = maxx * (n-top);for(int i = 1; i<top; i++) {//枚举他和他儿子的那条边 sum[i+1] = sum[i] + nxtw[path[i]];//照这么来看的话还是递归的写法会好一些，因为正好就是儿子节点代表儿子到父亲的那条边 }for(int i = 1; i<=top; i++) {//搜索中间点 (st和ed也可以搜，只不过搜出来结果肯定是0)val[i] = dfs2(path[i],-1);}for(int i = 1; i<=top; i++) {//枚举割最长链上的每一条边 L[i] = max(val[i] + sum[i],L[i-1]);}for(int i = top; i>=1; i--) {R[i] = max(R[i+1],val[i] + (sum[top]-sum[i]));}for(int i = 1; i<top; i++) {ans += max(L[i],R[i+1]);}printf("%lld\n",ans);}return 0 ;
}