CodeChef PrimeDST【点分治】【FFT】

/* I will wait for you */

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <string>
#define make(a,b) make_pair(a,b)
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef map<int, int> mii;

const int maxn = 200010;
const int maxm = 1010;
const int maxs = 26;
const int inf = 0x3f3f3f3f;
const int P = 1000000007;
const double error = 1e-9;
const double Pi = 3.1415926535897932;

inline ll read()
{
ll x = 0, f = 1; char ch = getchar();
while (ch > '9' || ch < '0' )
f = (ch == '-' ? -1 : 1), ch = getchar();
while (ch <= '9' && ch >= '0')
x = x * 10 + ch - '0', ch = getchar();
return f * x;
}

struct complex
{
double re, im;
} _x[maxn], w[2][maxn];

complex operator + (complex a, complex b)
{
complex c;
c.re = a.re + b.re;
c.im = a.im + b.im;
return c;
}

complex operator - (complex a, complex b)
{
complex c;
c.re = a.re - b.re;
c.im = a.im - b.im;
return c;
}

complex operator * (complex a, complex b)
{
complex c;
c.re = a.re * b.re - a.im * b.im;
c.im = a.re * b.im + a.im * b.re;
return c;
}

struct edge
{
int v, next;
} e[maxn];

int n, root, sum, _maxdeep, maxdeep, head[maxn],
pri[maxn], _max[maxn], size[maxn], cnt, g[maxn],
f[maxn], deep[maxn], del[maxn], rev[maxn];
ll ans;

void insert(int u, int v)
{
e[cnt] = (edge) {v, head[u]}, head[u] = cnt++;
}

void _deep(int u, int p)
{
g[deep[u]] += 1, maxdeep = max(maxdeep, deep[u]);
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v != p && !del[v])
deep[v] = deep[u] + 1, _deep(v, u);
}
}

void _size(int u, int p)
{
size[u] = 1;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v != p && !del[v])
_size(v, u), size[u] += size[v];
}
}

void _find(int u, int p)
{
size[u] = 1, _max[u] = 0;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v != p && !del[v]) {
_find(v, u), size[u] += size[v];
_max[u] = max(_max[u], size[v]);
}
}
_max[u] = max(_max[u], sum - size[u]);
if (_max[u] < _max[root]) root = u;
}

void FFT(complex *a, int n, int f)
{
for (int i = 0; i < n; i++) {
rev[i] = 0;
for (int j = i, k = 1; k < n; k <<= 1, j >>= 1)
(rev[i] <<= 1) |= (j & 1);
if (rev[i] > i) swap(a[i], a[rev[i]]);
}

for (int i = 0; i < n; i++) {
w[0][i].re = cos(2 * Pi * i / n);
w[0][i].im = sin(2 * Pi * i / n);
w[1][i].re = cos(2 * Pi * i / n);
w[1][i].im = -sin(2 * Pi * i / n);
}

for (int i = 1; i < n; i <<= 1)
for (int j = 0, l = n / (i << 1); j < n; j += (i << 1))
for (int k = 0, t = 0; k < i; k += 1, t += l) {
complex x = a[j + k], y = w[f][t] * a[i + j + k];
a[j + k] = x + y, a[i + j + k] = x - y;
}
for (int i = 0; f && i < n; i++) a[i].re /= n;
}

void _solve(int *a, int n, int f)
{
int len = 1;
while (1 << len < n << 1) len += 1;

for (int i = 0; i < 1 << len; i++)
_x[i].re = _x[i].im = 0;
for (int i = 0; i < n; i++)
_x[i].re = a[i];

FFT(_x, 1 << len, 0);
for (int i = 0; i < 1 << len; i++)
_x[i] = _x[i] * _x[i];
FFT(_x, 1 << len, 1);

for (int i = 0; i < 1 << len; i++) {
if (!pri[i] && f == 1)
ans += (ll) (_x[i].re + 0.5);
if (!pri[i] && f == -1)
ans -= (ll) (_x[i].re + 0.5);
}
}

void solve(int u)
{
del[u] = 1, _size(u, 0);
f[0] = 1, _maxdeep = 0;
for (int i = 1; i <= size[u]; i++)
f[i] = 0;

for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (!del[v]) {
maxdeep = 0;
for (int i = 0; i <= size[v]; i++)
g[i] = 0;

deep[v] = 1, _deep(v, u);
_solve(g, maxdeep + 1, -1);

_maxdeep = max(_maxdeep, maxdeep);
for (int i = 0; i <= size[v]; i++)
f[i] += g[i];
}
}
_solve(f, _maxdeep + 1, 1);

for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (!del[v]) {
sum = size[v], root = 0;
_find(v, u), solve(root);
}
}

}

void init()
{
pri[0] = pri[1] = 1;
for (int i = 2; i < n; i++)
if (!pri[i])
for (int j = 2 * i; j < n; j += i)
pri[j] = 1;
}

int main()
{
n = read(), init();

memset(head, -1, sizeof head);
for (int i = 1; i < n; i++) {
int u = read(), v = read();
insert(u, v), insert(v, u);
}

sum = _max[0] = n, root = 0;
_find(1, 0), solve(root);

printf("%.6f\n", 1.0 * ans / n / (n - 1));

return 0;
}