HDU 5723 Abandoned country

题目分析

题目不难，但是注意的点比较多，首先就是写最小生成树算法，这个很简单，我也不用多说了，我要说的就是求期望的问题，我们可以这样求，对于每条边来说，它用到的次数等于这条边左边节点数乘以右边节点数，其实就是乘法原理。然后我们将用到的次数再乘以这条边的权值其实就是这条边对期望所做的贡献，那么在递归的工程中我们可以求出这个值，然后再将这个值除以n*(n-1)/2就可以得到期望了。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100005;
const int maxm = 1000005;
typedef long long LL;

int head[maxn],fa[maxn],tot;
LL ans;

void init(){
    tot = 0;
    memset(head, -1, sizeof(head));
    for(int i = 0; i < maxn; i++) fa[i] = i;
}

struct Edge{
    int from,to,w,next;
    bool operator < (const Edge edge)const{
        return w < edge.w;
    }
}e[maxn<<1],E[maxm];

void addedge(int from, int to, int w){
    e[tot].to = to;
    e[tot].w = w;
    e[tot].next = head[from];
    head[from] = tot++;
}

int Find(int x){
    if(fa[x] == x) return fa[x];
    fa[x] = Find(fa[x]);
    return fa[x];
}

LL kruskal(int m){
    sort(E, E+m);
    init();
    LL sum = 0;
    for(int i = 0; i < m; i++){
        int xx = Find(E[i].from);
        int yy = Find(E[i].to);
        if(xx != yy){
            fa[xx] = yy;
            addedge(E[i].from, E[i].to, E[i].w);
            addedge(E[i].to, E[i].from, E[i].w);
            sum += E[i].w;
        }
    }
    return sum;
}

int dfs(int u,int fa,int n){
    int node = 1;
    for(int i = head[u]; i != -1; i = e[i].next){
        int v = e[i].to;
        int w = e[i].w;
        if(v != fa){
            int temp = dfs(v, u, n);
            node += temp;
            ans += (LL)w*(LL)temp*(LL)(n-temp);  //注意中间值可能爆int
        }
    }
    return node;
}

int main(){
    int T,n,m;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);
        for(int i = 0; i < m; i++)
            scanf("%d%d%d", &E[i].from, &E[i].to, &E[i].w);
        printf("%I64d ", kruskal(m));
        ans = 0LL;
        dfs(1, -1, n);
        printf("%.2lf\n", ans*2.0/(n*1.0-1.0)/(n*1.0));
    }
    return 0;
}