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 = , INF = 0x3f3f3f3f;
 
 inline void read(int &x) {
     x = ;
     char c = getchar();
     while(c < '' || c > '') {
         c = getchar();
     }
     while(c >= '' && c <= '') {
         x = (x << ) + (x << ) + c - ;
         c = getchar();
     }
     return;
 }
 
 struct cp {
     LD x, y;
     cp(LD X = , LD Y = ) {
         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 * ], b[N * ];
 
 struct Edge {
     int nex, v;
 }edge[N << ]; int tp;
 
 int r[N * ], 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 = ; i < n; i++) {
         if(i < r[i]) {
             std::swap(a[i], a[r[i]]);
         }
     }
     for(register int len = ; len < n; len <<= ) {
         cp Wn(cos(pi / len), f * sin(pi / len));
         for(register int i = ; i < n; i += (len << )) {
             cp w(, );
             for(register int j = ; 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 == -) {
         for(register int i = ; i <= n; i++) {
             a[i].x /= n;
         }
     }
     return;
 }
 
 inline void cal(int n, int f) {
     /*printf("cal \n");
     for(int i = 0; i <= n; i++) {
         printf("%d ", bin[i]);
     }
     printf("\n");*/
     int lm = , len = ;
     while(len <= n * ) {
         len <<= ;
         lm++;
     }
     for(register int i = ; i <= len; i++) {
         r[i] = (r[i >> ] >> ) | ((i & ) << (lm - ));
     }
     for(register int i = ; i <= n; i++) {
         a[i] = cp(bin[i], );
     }
     for(register int i = n + ; i <= len; i++) {
         a[i] = cp(, );
     }
     FFT(a, len, );
     for(register int i = ; i <= len; i++) {
         a[i] = a[i] * a[i];
     }
     FFT(a, len, -);
     /*for(int i = 0; i <= n + n; i++) {
         printf("%d ", (int)(a[i].x + 0.5));
     }
     printf("\n");*/
     for(register int i = ; 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] = ;
     int large = -;
     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] + ;
     bin[d[x]]++;
     siz[x] = ;
     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, , sizeof(int) * (last_n + ));
     }
     small = INF;
     get_root(x, );
     if(f) {
         cal(last_n, -);
     }
     x = root;
     memset(bin, , sizeof(int) * (_n + ));
     DFS(x, );
     cal(_n, );
     del[x] = ;
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(del[y]) {
             continue;
         }
         _n = siz[y];
         div(y, , siz[x]);
     }
     return;
 }
 
 int main() {
     d[] = -;
     read(n);
     for(register int i = , x, y; i < n; i++) {
         read(x); read(y);
         add(x + , y + ); add(y + , x + );
     }
 
     _n = n;
     div(, , n);
     LD ans = ;
     /*for(int i = 0; i <= n; i++) {
         printf("%d ", cnt[i]);
     }
     printf("\n");*/
     for(register int i = ; i < n; i++) {
         ans += (LD)cnt[i] / (i + );
     }
     printf("%.4Lf\n", ans);
     return ;
 }

AC代码

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