【JZOJ A组】 树

Description

梦游中的你来到了一棵 N 个节点的树上. 你一共做了 Q 个梦, 每个梦需要你从点 u 走到 点 v 之后才能苏醒, 由于你正在梦游, 所以每到一个节点后,你会在它连出去的边中等概率地 选择一条走过去, 为了确保第二天能够准时到校, 你要求出每个梦期望经过多少条边才能苏 醒. 为了避免精度误差, 你要输出答案模10^9 + 7的结果.

Input

第一行两个整数分别代表 N 和 Q. 接下来 N-1 行, 每行两个整数 u, v 代表树中的一条边. 接下来 Q 行, 每行两个整数代表询问的 u,v.

Output

一共 Q 行, 每行一个整数代表答案

Sample Input

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

Sample Output

9
5

Data Constraint

对于 20%的数据, N <= 10.
对于 40%的数据, N <= 1000.
另有 20%的数据, 保证给定的树是一条链.
对于 100%的数据, N <= 100000, Q <= 100000.

Hint

思路

zzy大佬太强啦%%%

设d[i]为i的出度，f[i]为从i走向根节点的期望步数，g[i]为从根节点走到i的期望步数

则f[i]为

1. 直接走到父亲的期望1/d[i]
2. 走到儿子，然后走回i，再到父亲的期望

g[i]为

1. 直接走到i的期望1/d[i]
2. 走到爷爷，然后走回父亲，再走到i的期望
3. 走到非i的儿子，然后走回父亲，再走到i的期望

用dfs预处理f和g

最终答案显然是：
从u走到lca，再从lca走到v

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
const int mod=1e9+7,maxn=1e6+77;
struct E
{
    int to,next;
}e[maxn*2];
int n,q,list[maxn],cnt=0;
long long fa[maxn][22],dep[maxn],f[maxn],g[maxn];
void add(int u,int v)
{
    e[++cnt].to=v; e[cnt].next=list[u]; list[u]=cnt;
}
void dfs(int u,int father)
{
    fa[u][0]=father; f[u]=0;
    for(int i=list[u]; i; i=e[i].next)
    {
        int v=e[i].to;
        if(v==father) continue;
        dfs(v,u);
        f[u]=(f[u]+f[v]+1)%mod;
    }
    f[u]=(f[u]+1)%mod;
}
void dfs1(int u,int father)
{
    long long s=0;
    for(int i=list[u]; i; i=e[i].next) if(e[i].to!=father) s=(s+f[e[i].to]+1)%mod; else
        s=(s+g[u]+1)%mod;
    for(int i=list[u]; i; i=e[i].next)
    {
        int v=e[i].to;
        if(v==father) continue;
        g[v]=((s-f[v])%mod+mod)%mod;
        dfs1(v,u);
    }
}
void dfs2(int u,int father)
{
    dep[u]=dep[father]+1;
    f[u]=(f[u]+f[father])%mod; g[u]=(g[u]+g[father])%mod;
    for(int i=list[u]; i; i=e[i].next)
    {
        int v=e[i].to; if(v==father) continue;
        dfs2(v,u);
    }
}
int getlca(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    int d=dep[u]-dep[v];
    if(d) for(int i=0; i<=log2(n)+1&&d; i++,d>>=1) if(d&1) u=fa[u][i];
    if (u==v) return u;
    for(int i=log2(n)+1; i>=0; i--)
        if(fa[u][i]!=fa[v][i]) u=fa[u][i],v=fa[v][i];
    return fa[u][0];
}
int main()
{
    freopen("tree.in","r",stdin); freopen("tree.out","w",stdout);
    scanf("%d%d",&n,&q);
    for(int i=1; i<=n-1; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y); add(y,x);
    }
    dfs(1,0);
    f[1]=0; g[1]=0;
    dfs1(1,0); dfs2(1,0);
    for(int i=1; i<=log2(n)+1; i++)
    {
        for (int j=1; j<=n; j++) fa[j][i]=fa[fa[j][i-1]][i-1];
    }
    while(q--)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        int lca=getlca(u,v);
        printf("%lld\n",(f[u]-f[lca]+g[v]-g[lca]+mod)%mod);
    }
}