[bzoj5410][动态点分治][二分]分岔路口

Description

Sample Input

4 4
1 2
2 3
3 4
1 1
1 2
1 3
1 4

Sample Output

0.00000000
1.00000000
2.00000000
2.33333333

HINT

题解

被奶牛题迷失了心智
跟我大喊OZY牛逼！
首先根据上一道奶牛题的套路不难发现
一定是一开始疯狂跳然后跳到一个直接到终点比跳的期望小的地方就停下走过去
同样写一下方程可以知道只跳的期望对于所有点都是一样的
那么所以可以知道，最终一定有一个分界线L使得到终点距离小于等于L的直接走过去，其他继续跳
那么接下来我就不会做了…
不妨列一个关于跳的期望的方程，设这个期望值为x，那么有
$$x=\frac{{\sum }_{i}min(dis(i,y),x)}{n}+1$$
随意观察一下不难发现是这样
化简一下式子，设$sum$表示那些取了$dis(i,y)$的$i$的$dis$和，$s1$表示他们的个数和
$$x=\frac{sum+n}{s1}$$
观察到我们这个分界线L增大的时候，这一个x是单减的
思考一下原式不难发现上面的性质
于是我们可以二分这个分界线L，求出来的期望值$x$满足$x>=L$即为合法
这个是怎么思考到的呢？
大概就是你考虑如果一个点的策略从跳变成直接走过去，他是不会再变回成跳的策略的
感性认识一下或者根据上面的性质理解吧…
那接下来只需要求出距离$x$小于等于$K$的点的路径和与个数和
这个用动态点分治不难解决
每个点维护一下对于自己的距离前缀和对于分治父亲的距离前缀和就可以了

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline int read()
{
	int f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
inline void write(LL x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
inline void pr1(int x){write(x);putchar(' ');}
inline void pr2(LL x){write(x);putchar('\n');}
const int MAXN=100005;

struct edge{int x,y,next;}a[MAXN*2];int len,last[MAXN];
void ins(int x,int y){len++;a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;}

int fir[MAXN],mn[25][MAXN*2],bin[25],Log[MAXN*2],id,dep[MAXN];
void pre_tree_node(int x,int fa)
{
	fir[x]=id+1;mn[0][++id]=x;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa)
		{
			dep[y]=dep[x]+1;
			pre_tree_node(y,x);
			mn[0][++id]=x;
		}
	}
}
int _min(int x,int y){return dep[x]<dep[y]?x:y;}
void init()
{
	Log[1]=0;
	for(int i=2;i<2*MAXN;i++)Log[i]=Log[i>>1]+1;
	for(int i=1;bin[i]<=id;i++)
		for(int x=1;x+bin[i]-1<=id;x++)
			mn[i][x]=_min(mn[i-1][x],mn[i-1][x+bin[i-1]]);
}
int lca(int x,int y)
{
	x=fir[x];y=fir[y];
	if(x>y)swap(x,y);
	int K=Log[y-x+1];
	return _min(mn[K][x],mn[K][y-bin[K]+1]);
}
int getdis(int x,int y){return dep[x]+dep[y]-2*dep[lca(x,y)];}


int tot[MAXN],f[MAXN],G,total;
bool vis[MAXN];
void dfs(int x,int fa)
{
	tot[x]=1;f[x]=0;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa&&vis[y])
		{
			dfs(y,x);
			tot[x]+=tot[y];
			f[x]=max(f[x],tot[y]);
		}
	}
	f[x]=max(f[x],total-tot[x]);
	if(!G||f[G]>f[x])G=x;
}
int refa[MAXN];
vector<int> vec1[MAXN],vec3[MAXN];
vector<LL> vec2[MAXN],vec4[MAXN];
int dis[MAXN],gg;
void pre(int x,int fa,int d)
{
	dis[++gg]=d;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa&&vis[y])pre(y,x,d+1);
	}
}
void play(int x,int fa,int o)
{
	dis[++gg]=getdis(x,o);
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa&&vis[y])play(y,x,o);
	}
}
void getrt(int x,int fa)
{
	refa[x]=fa;
	gg=0;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(vis[y])pre(y,x,1);
	}
	sort(dis+1,dis+1+gg);
	LL s=0;
	for(int i=1;i<=gg;i++)
	{
		if(dis[i]!=dis[i-1])vec1[x].push_back(i),vec2[x].push_back(s);
		s+=dis[i];
	}
	vec1[x].push_back(gg+1);vec2[x].push_back(s);
	gg=0;
	if(fa)
	{
		play(x,0,fa);
		sort(dis+1,dis+1+gg);
		s=0;
		for(int i=1;i<=gg;i++)
		{
			if(dis[i]!=dis[i-1])vec3[x].push_back(i-1),vec4[x].push_back(s);
			s+=dis[i];
		}
		vec3[x].push_back(gg);vec4[x].push_back(s);
	}
	vis[x]=false;
	dfs(x,0);
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(vis[y])
		{
			total=tot[y];G=0;
			dfs(y,x);getrt(G,x);
		}
	}
	
}
int n,m;
double qry(int x,int d)
{
	LL s1=0,s2=0;//人数 权值和 
	int mx=vec1[x].size()-1,nw=refa[x],pre=x;
	s1+=vec1[x][min(mx,d)];s2+=vec2[x][min(mx,d)];
	while(nw!=0)
	{
		int o1=getdis(x,nw);
		if(d>=o1)
		{
			int lst=min(d-o1,(int)vec1[nw].size()-1);
			s1+=vec1[nw][lst];s2+=vec2[nw][lst]+(LL)o1*vec1[nw][lst];
			lst=min(lst,(int)vec3[pre].size()-1);
			s1-=vec3[pre][lst];s2-=vec4[pre][lst]+(LL)o1*vec3[pre][lst];
		}
		pre=nw;nw=refa[nw];
	}
	return (double)(s2+n)/(s1);
}
double solve(int x)
{
	int l=0,r=n;double ret;
	while(l<=r)
	{
		int mid=(l+r)/2;
		double nw=qry(x,mid);
		if(nw>=mid)ret=nw,l=mid+1;
		else r=mid-1;
	}
	return ret;
}
int main()
{
//    freopen("a.in","r",stdin);
//    freopen("a.out","w",stdout);
	bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;
	n=read();m=read();
	for(int i=1;i<n;i++)
	{
		int x=read(),y=read();
		ins(x,y);ins(y,x);
	}
	pre_tree_node(1,0);
	init();
	memset(vis,true,sizeof(vis));
	total=n;dfs(1,0);
	getrt(G,0);
//	for(int i=0;i<=20;i++)
//		printf("i=%d %.8lf\n",i,qry(10,i));
	while(m--)
	{
		int x=read(),y=read();
		double dd=getdis(x,y);
		printf("%.8lf\n",min(dd,solve(y)));
	}
	return 0;
}