bzoj3451 Normal

题意：点分治每次随机选重心，求期望复杂度。

发现一次点分治的复杂度就是点分树上每个节点的子树大小之和。(并没有发现......)

看这个。

注意这个写法有问题，随便来个菊花图就是n²了。

每一层点分治的时候，时间复杂度决不能与上一层大小挂钩。

/**************************************************************
    Problem: 3451
    Language: C++
    Result: Accepted
    Time:5548 ms
    Memory:8548 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
 
typedef long long LL;
typedef long double LD;
const LD pi = 3.1415926535897932384626;
const int N = 30010, INF = 0x3f3f3f3f;
 
inline void read(int &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') {
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = (x << 3) + (x << 1) + c - 48;
        c = getchar();
    }
    return;
}
 
struct cp {
    LD x, y;
    cp(LD X = 0, LD Y = 0) {
        x = X;
        y = Y;
    }
    inline cp operator +(const cp &w) const {
        return cp(x + w.x, y + w.y);
    }
    inline cp operator -(const cp &w) const {
        return cp(x - w.x, y - w.y);
    }
    inline cp operator *(const cp &w) const {
        return cp(x * w.x - y * w.y, x * w.y + y * w.x);
    }
}a[N * 4], b[N * 4];
 
struct Edge {
    int nex, v;
}edge[N << 1]; int tp;
 
int r[N * 4], n, e[N], small, root, d[N], bin[N], cnt[N], _n, siz[N];
bool del[N];
 
inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}
 
inline void FFT(cp *a, int n, int f) {
    for(register int i = 0; i < n; i++) {
        if(i < r[i]) {
            std::swap(a[i], a[r[i]]);
        }
    }
    for(register int len = 1; len < n; len <<= 1) {
        cp Wn(cos(pi / len), f * sin(pi / len));
        for(register int i = 0; i < n; i += (len << 1)) {
            cp w(1, 0);
            for(register int j = 0; j < len; j++) {
                cp t = a[i + len + j] * w;
                a[i + len + j] = a[i + j] - t;
                a[i + j] = a[i + j] + t;
                w = w * Wn;
            }
        }
    }
    if(f == -1) {
        for(register int i = 0; i <= n; i++) {
            a[i].x /= n;
        }
    }
    return;
}
 
inline void cal(int n, int f) {
    /*printf("cal 
");
    for(int i = 0; i <= n; i++) {
        printf("%d ", bin[i]);
    }
    printf("
");*/
    int lm = 1, len = 2;
    while(len <= n * 2) {
        len <<= 1;
        lm++;
    }
    for(register int i = 0; i <= len; i++) {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }
    for(register int i = 0; i <= n; i++) {
        a[i] = cp(bin[i], 0);
    }
    for(register int i = n + 1; i <= len; i++) {
        a[i] = cp(0, 0);
    }
    FFT(a, len, 1);
    for(register int i = 0; i <= len; i++) {
        a[i] = a[i] * a[i];
    }
    FFT(a, len, -1);
    /*for(int i = 0; i <= n + n; i++) {
        printf("%d ", (int)(a[i].x + 0.5));
    }
    printf("
");*/
    for(register int i = 0; i <= len; i++) {
        cnt[i] += f * (int)(a[i].x + 0.5);
    }
    return;
}
 
void get_root(int x, int f) {
    bin[d[x]]++;
    siz[x] = 1;
    int large = -1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f || del[y]) {
            continue;
        }
        get_root(y, x);
        siz[x] += siz[y];
        large = std::max(large, siz[y]);
    }
    if(small > std::max(large, _n - siz[x])) {
        small = std::max(large, _n - siz[x]);
        root = x;
    }
    return;
}
 
void DFS(int x, int f) {
    d[x] = d[f] + 1;
    bin[d[x]]++;
    siz[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f || del[y]) {
            continue;
        }
        DFS(y, x);
        siz[x] += siz[y];
    }
    return;
}
 
void div(int x, int f, int last_n) {
    if(f) {
        memset(bin, 0, sizeof(int) * (last_n + 1));
    }
    small = INF;
    get_root(x, 0);
    if(f) {
        cal(last_n, -1);
    }
    x = root;
    memset(bin, 0, sizeof(int) * (_n + 1));
    DFS(x, 0);
    cal(_n, 1);
    del[x] = 1;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(del[y]) {
            continue;
        }
        _n = siz[y];
        div(y, 1, siz[x]);
    }
    return;
}
 
int main() {
    d[0] = -1;
    read(n);
    for(register int i = 1, x, y; i < n; i++) {
        read(x); read(y);
        add(x + 1, y + 1); add(y + 1, x + 1);
    }
 
    _n = n;
    div(1, 0, n);
    LD ans = 0;
    /*for(int i = 0; i <= n; i++) {
        printf("%d ", cnt[i]);
    }
    printf("
");*/
    for(register int i = 0; i < n; i++) {
        ans += (LD)cnt[i] / (i + 1);
    }
    printf("%.4Lf
", ans);
    return 0;
}

注意FFT里面j从0开始，到len。