Tree and Permutation
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 126 Accepted Submission(s): 48
Problem Description
There are N vertices connected by N−1 edges, each edge has its own length.
The set { 1,2,3,…,N } contains a total of N! unique permutations, let’s say the i-th permutation is Pi and Pi,j is its j-th number.
For the i-th permutation, it can be a traverse sequence of the tree with N vertices, which means we can go from the Pi,1-th vertex to the Pi,2-th vertex by the shortest path, then go to the Pi,3-th vertex ( also by the shortest path ) , and so on. Finally we’ll reach the Pi,N-th vertex, let’s define the total distance of this route as D(Pi) , so please calculate the sum of D(Pi) for all N! permutations.
Input
There are 10 test cases at most.
The first line of each test case contains one integer N ( 1≤N≤105 ) .
For the next N−1 lines, each line contains three integer X, Y and L, which means there is an edge between X-th vertex and Y-th of length L ( 1≤X,Y≤N,1≤L≤109 ) .
Output
For each test case, print the answer module 109+7 in one line.
Sample Input
3
1 2 1
2 3 1
3
1 2 1
1 3 2
Sample Output
16
24
Source
题目
给出一棵树,现在给出n!全排列所有的访问顺序。
求出所有的路径和。
考虑所有的排列的和。则可以计算树上每两个节点的距离对答案的贡献。
而每两点的距离和就是树上所有路径的和。
树上所有路径的和用树上dp跑一下,就是说考虑每一条边对路径和贡献。也就是说每一条边被计算了几次。
每一条边被计算了son[u] * (n-son[u]) 次。
组合数计算
假设当前n = 3 存在 n! 种全排列
1 2 3 2 1 3 3 1 2
1 3 2 2 3 1 3 2 1
可以发现每个排列计算了(n-1)条路径的距离 如1 2 3 计算了[1-2] 和 [2-3] 的距离和,一共有n!*(n-1)条路径被计算
而很多是计算重复。可以数一下一共有几种不同的路径。[1-2] [2-3] [1-3] 三种 一般来说就是C(n,2) 种
于是每一条路径被计算了 n!*(n-1) / C(n,2) 次
v = n! * (n-1) / C(n,2) = (n-1)! * 2
考虑最终答案
ans = [1-2] * v + [1-3] * v + [2-3] * v
= ([1-2] + [1-3] + [2-3]) * v
= 树上所有路径和 * v
代码
/*
* 题意: 给出一棵树,现在给出n!全排列所有的访问顺序。
* 求出所有的路径和。
* 考虑所有的排列的和。则可以计算树上每两个节点的距离对答案的贡献。
* 而每两点的距离和就是树上所有路径的和。
* 树上所有路径的和用树上dp跑一下,就是说考虑每一条边对路径和贡献。也就是说每一条边被计算了几次。
* 每一条边被计算了son[u] * (n-son[u]) 次。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,ll> edge;
const int maxn = 1e5+10;
const ll mod = 1e9+7;
vector<edge> ways[maxn];
ll dp[maxn],fac[maxn];
int son[maxn],n;
inline void init() {
fac[0] = 1;
for(int i=1;i<maxn;i++) fac[i] = fac[i-1] * i % mod;
}
void dfs(int rt,int fa) {
son[rt] = 1;
for(auto v:ways[rt]) {
int to = v.first;ll val = v.second;
if(to == fa) continue;
dfs(to,rt);
son[rt] += son[to];
ll tmp = 1LL * son[to] * (n - son[to]) % mod;
dp[rt] = (dp[rt] + (dp[to] + tmp * val % mod) % mod) % mod;
}
}
int main()
{
init();
while(~scanf("%d",&n)) {
memset(dp,0,sizeof(dp));
memset(son,0,sizeof(son));
for(int i=0;i<maxn;i++) ways[i].clear();
int u,v;ll val;
for(int i=1;i<n;i++) {
scanf("%d%d%lld",&u,&v,&val);
ways[u].push_back(make_pair(v,val));
ways[v].push_back(make_pair(u,val));
}
dfs(1,0);
printf("%lld\n",dp[1]*fac[n-1]%mod*2%mod);
}
return 0;
}