D. Maximum Distributed Tree（Codeforces Round #665 (Div. 2)）

思路

题意就不说了。
首先看这个式子，$\sum _{i=1}^{n-1}\sum _{j=i+1}^{n}f(i,j)$可以发现，其实就是所有的点对都连了一遍，也就是任意两个点都不重复的连了一遍。

那么假设有一条边L，L左边有$x$个节点，那么L右边一定就有$n-x$个节点，那么通过L的次数就是$(n-x)x$那么只需要dfs一遍就可以算出所有边的经过次数了。
然后对于给的m个质数需要分情况讨论：

1. 如果$m<=n-1$那么就可以直接把经过次数多的边匹配大的质数，剩下不足的匹配1。
2. 如果$m>n-1$那么，可以先把大的质数合并，然后把合并出来的大质数当成一个整体匹配最大经过次数的边，然后剩下的质数再匹配剩下的边。

代码

#include<bits/stdc++.h>
#define ll long long
#define INF 0x3f3f3f3f
#define endl '\n'
#define eps 1e-8
using namespace std;
const ll maxn = 1e6 + 5;
const ll mod = 1e9 + 7;
int t,a[maxn],b[maxn];
int n,m;
int h[maxn],nex[maxn],e[maxn],cnt = 1;
ll p[maxn];
vector<ll> dd;

void add(int a, int b){
    
    
    e[cnt] = b;
    nex[cnt] = h[a];
    h[a] = cnt++;
}

ll dfs(int x,int f){
    
    
    ll sum = 1;
    for(int i = h[x]; i ; i = nex[i]){
    
    
        int endd = e[i];
        if(endd == f)continue;
        ll uu = dfs(endd,x);//得到右边的节点个数
        dd.push_back(1ll * uu * (n - uu));
        sum += uu;
    }
    return sum;
}

int main(){
    
    
    ios::sync_with_stdio(false);
    int u,v;
    cin >> t;
    while(t--){
    
    
        ll ans = 0;
        cnt = 1,dd.clear();
        cin >> n;
        for(int i = 1; i <= n; i++)h[i] = 0;
        for(int i = 1; i <= n - 1; i++){
    
    
            cin >> u >> v;
            add(u,v),add(v,u);
        }
        cin >> m;
        for(int i = 0; i < m; i++)cin >> p[i];
        dfs(1,0);
        sort(dd.begin(), dd.end(), greater<ll>());
        sort(p, p + m, greater<ll>());
        
        if(m <= n - 1){
    
    //如果质数的个数不足匹配所有的边
             for(int i = 0; i < m; i++)
                ans = (dd[i] * p[i] % mod + ans) % mod;
            for(int i = m; i < n - 1; i++)ans = (ans + dd[i]) % mod;
        }else{
    
    
            ll tmp = 1;//tmp用于储存前几个大质数合并的结果
            for(int i = 0,f = 0,j = 0; i < n - 1;){
    
    
                if(f){
    
    
                    ans = (ans + p[j++] * dd[i++] % mod) % mod;
                }else{
    
    
                    tmp = tmp * p[j++] % mod;
                    if(m - j == n - 2){
    
    //合并结束，把标记f打开，然后匹配剩下的边
                        f = 1;
                        ans = (ans + tmp * dd[i++] % mod) % mod;//第一个最大通过的边匹配合并后的数
                    }
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}