D. The Child and Zoo

 

http://codeforces.com/contest/437/problem/D

 

排序+并查集

 

为了理解原理，让我们先画一个圈：

 

其中红边无限大，黑边值为0

我们可以发现，红边的值：1、直接就是f（1，2），2、毫不影响剩下的f（1，3）、f（1，4）、f（2，3）、f（2，4）、f（3，4）的值

所以对应的，我们可以得出：1、当它是图里最大的边时，它的贡献可求，2、球完之后，它唯一的作用就是确保连通性，除此之外就是个摆设

而题目里求所有点对的f（）值等价于求所有边对所有点对的贡献

解决1用排序，解决2用并查集

import java.util.Arrays;
import java.util.Scanner;

import static java.lang.Math.min;

public class Main {
    static final int MAX = Integer.MAX_VALUE;
    static int[] f = new int[100000 + 50];

    public static void main(String[] args) {
        Scanner io = new Scanner(System.in);
        int n = io.nextInt(), m = io.nextInt();

        int[] a = new int[n + 1], c = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            a[i] = io.nextInt();
            f[i] = i;
            c[i] = 1;
        }

        P[] ps = new P[m];
        for (int i = 0, aa, bb; i < m; i++) {
            aa = io.nextInt();
            bb = io.nextInt();
            ps[i] = new P(aa, bb, min(a[aa], a[bb]));
        }

        Arrays.sort(ps);
        double w = 0;
        for (int i = 0, fx, fy, v; i < m; i++) {
            P p = ps[i];
            fx = find(p.x);
            fy = find(p.y);
            v = p.v;
            if (fx == fy) continue;
            //这道题这里和下面非常容易溢出，升double是必须的
            // 并且1L和1.0【一定】要放在最前面，因为它是一边乘一边检测
            // 什么时候碰到1.0就什么时候升double
            w += 1L * v * c[fx] * c[fy];
            f[fx] = fy;
            c[fy] += c[fx];
        }
        //下面
        System.out.println(w / (1.0 * n * (n - 1) / 2));
    }

    static int find(int x) {
        return f[x] == x ? x : (f[x] = find(f[x]));
    }

    static class P implements Comparable<P> {
        int x, y, v;

        public P(int x, int y, int v) {
            this.x = x;
            this.y = y;
            this.v = v;
        }

        @Override
        public int compareTo(P o) {
            return -v + o.v;
        }
    }
}