BZOJ3451: Tyvj1953 Normal

题解：

好神的一道题。蒟蒻只能膜拜题解。

考虑a对b的贡献，如果a是a-b路径上第一个删除的点，那么给b贡献1。

所以转化之后就是求sigma(1/dist(i,j)),orz！！！

如果不是分母的话O（n）就可以搞，但是现在在分母上。。。

考虑转化一下，求ret[i]表示距离为i的点对有多少对。我们发现只要求出ret数组，然后就可以回答了。

如何求ret，我们用点分治。类似于RACE那道题。

对于一颗子树，我们整个信息一块统计，让它和前面的所有做卷积，更新ret，然后再把这棵子树归入前面的信息内。

代码：

 #include<cstdio>

 #include<cstdlib>

 #include<cmath>

 #include<cstring>

 #include<algorithm>

 #include<iostream>

 #include<vector>

 #include<map>

 #include<set>

 #include<queue>

 #include<string>

 #define inf 1000000000

 #define maxn 50000+5

 #define maxm 20000000+5

 #define eps 1e-10

 #define ll long long

 #define pa pair<int,int>

 #define for0(i,n) for(int i=0;i<=(n);i++)

 #define for1(i,n) for(int i=1;i<=(n);i++)

 #define for2(i,x,y) for(int i=(x);i<=(y);i++)

 #define for3(i,x,y) for(int i=(x);i>=(y);i--)
 #define for4(i,x) for(int i=head[x],y;i;i=e[i].next)

 #define mod 1000000007

 using namespace std;

 inline int read()

 {

     int x=,f=;char ch=getchar();

     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}

     while(ch>=''&&ch<=''){x=*x+ch-'';ch=getchar();}

     return x*f;

 }
 int n,mx,m,len,cnt,sum,tot,rt,rev[maxn],head[maxn],d[maxn],f[maxn],s[maxn],g[maxn];
 bool del[maxn];
 ll ret[maxn];
 const double PI=acos(-1.0);
 struct cp
 {
     double x,y;
     cp operator +(cp b){return (cp){x+b.x,y+b.y};}
     cp operator -(cp b){return (cp){x-b.x,y-b.y};}
     cp operator *(cp b){return (cp){x*b.x-y*b.y,x*b.y+y*b.x};}
 };
 cp a[*maxn],b[*maxn],c[*maxn],y[*maxn];
 struct edge{int go,next;}e[*maxn];
 inline void insert(int x,int y)
 {
     e[++tot]=(edge){y,head[x]};head[x]=tot;
     e[++tot]=(edge){x,head[y]};head[y]=tot;
 }
 inline void getrt(int x,int fa)
 {
     s[x]=;f[x]=;
     for4(i,x)if(!del[y=e[i].go]&&y!=fa)
     {
         getrt(y,x);
         s[x]+=s[y];
         f[x]=max(f[x],s[y]);
     }
     f[x]=max(f[x],sum-f[x]);
     if(f[x]<f[rt])rt=x;
 }
 inline void getdep(int x,int fa,int w)
 {
     if(w>mx)mx=w;
     d[++cnt]=w;
     for4(i,x)if(!del[y=e[i].go]&&y!=fa)getdep(y,x,w+);
 }
 inline void get(int n)
 {
     n++;n=*n-;
     m=,len=;
     while(m<=n)m<<=,len++;
     for0(i,m-)
     {
         int x=i,y=;
         for1(j,len)y<<=,y|=x&,x>>=;
         rev[i]=y;
     }
 }
 inline void fft(cp *x,int n,int flag)
 {
     for0(i,n-)y[rev[i]]=x[i];
     for0(i,n-)x[i]=y[i];
     for(int m=;m<=n;m<<=)
     {
         cp wn=(cp){cos(2.0*PI*flag/m),sin(2.0*PI*flag/m)};
         for(int i=;i<n;i+=m)
         {
             cp w=(cp){,};int mid=m>>;
             for0(j,mid-)
             {
                 cp u=x[i+j],v=x[i+j+mid]*w;
                 x[i+j]=u+v;x[i+j+mid]=u-v;
                 w=w*wn;
             }
         }
     }
     if(flag==-)for0(i,n-)x[i].x/=n;
 }
 inline void work(int x)
 {
     //cout<<"XXXXX"<<' '<<x<<' '<<"XXXX"<<endl;
     del[x]=;mx=;
     for4(i,x)if(!del[y=e[i].go])
     {
         cnt=;
         getdep(y,x,);get(mx);
         for0(j,m-)a[j]=(cp){g[j],},b[j]=(cp){,};
         for1(j,cnt)b[d[j]].x+=,g[d[j]]++;
         //for0(j,m-1)cout<<j<<' '<<a[j].x<<' '<<b[j].x<<endl;
         fft(a,m,);fft(b,m,);
         for0(j,m-)c[j]=a[j]*b[j];
         fft(c,m,-);
         for0(j,m-)ret[j]+=c[j].x+0.5;
         //for0(j,m-1)cout<<j<<' '<<c[j].x<<' '<<c[j].y<<endl;
     }
     for1(i,mx)ret[i]+=g[i],g[i]=;
     for4(i,x)if(!del[y=e[i].go])
     {
         sum=s[y];rt=;
         getrt(y,);
         work(rt);
     }
 }    

 int main()

 {

     freopen("input.txt","r",stdin);

     freopen("output.txt","w",stdout);

     n=read();
     for1(i,n-)insert(read()+,read()+);
     sum=n;f[rt=]=inf;
     getrt(,);
     work(rt);
     double ans=0.0;
     for1(i,n)
     ans+=(double)ret[i]/(double)(i+);//cout<<i<<' '<<ret[i]<<endl;
     printf("%.4f\n",n+*ans);

     return ;

 }  

3451: Tyvj1953 Normal

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 125  Solved: 60
[Submit][Status]

Description

某天WJMZBMR学习了一个神奇的算法：树的点分治！
这个算法的核心是这样的：
消耗时间=0
Solve(树 a)
 消耗时间 += a 的 大小
 如果 a 中 只有 1 个点
  退出
 否则在a中选一个点x，在a中删除点x
 那么a变成了几个小一点的树，对每个小树递归调用Solve
我们注意到的这个算法的时间复杂度跟选择的点x是密切相关的。
如果x是树的重心，那么时间复杂度就是O(nlogn)
但是由于WJMZBMR比较傻逼，他决定随机在a中选择一个点作为x！
Sevenkplus告诉他这样做的最坏复杂度是O(n^2)
但是WJMZBMR就是不信>_<。。。
于是Sevenkplus花了几分钟写了一个程序证明了这一点。。。你也试试看吧^_^
现在给你一颗树，你能告诉WJMZBMR他的傻逼算法需要的期望消耗时间吗？（消耗时间按在Solve里面的那个为标准）

Input

第一行一个整数n，表示树的大小
接下来n-1行每行两个数a,b，表示a和b之间有一条边
注意点是从0开始标号的

Output

一行一个浮点数表示答案
四舍五入到小数点后4位
如果害怕精度跪建议用long double或者extended

Sample Input

3
0 1
1 2

Sample Output

5.6667

HINT

n<=30000

Source

我们都爱GYZ杯