11.2 T3.tree（树形dp+期望）

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

输入格式
第一行两个整数分别代表N 和Q. 接下来N-1 行, 每行两个整数u, v 代表树中的一条边.
接下来Q 行, 每行两个整数代表询问的 u,v.
输出格式
一共Q行, 每行一个整数代表答案.

样例
tree.in
4 2
1 2
2 3
3 4
1 4
3 4
tree.out
9
5

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

分析：
从u到v的路径，可以分成两段：u—>lca和lca—>v，而去往lca的路都是由直接父亲构成的，
设u—>fa[u]的期望为f[u]
fa[v]—>v的期望为g[v]
我们可以得到柿子：

deg是每个点的出度
1/deg[u]实际上是：1*（1/deg[u]）表示直接走到父亲的期望（花费*概率）
除了直接到达目标，还有一种情况是先到u的儿子，之后从u的儿子返回u再到达fa[u]
每一个儿子的花费都是1+f[son]+f[u]，概率是1/deg[u]

从父亲转移来也是大同小异
第一种情况是直接到达u：1/deg[fa[u]]
第二种情况是先到达fa[u]的父节点（u的爷爷），之后从爷爷再一路回到u：花费是1+g[u]+g[fa[u]]，概率是1/deg[u]
第三种情况是先到达从fa[u]到达一个不是u的儿子，之后再回到fa[u]到达u：花费是1+g[u]+f[x]，概率是1/deg[u]

我们把这两个柿子化简一下：

f的求解我们从下往上，g的求解我们从上往下

这样我们就能通过两遍dfs求出f和g数组了
之后我们求出每个节点和根节点之间的f和g值分别的和
这样就可以在处理询问时候用logn的时间求出lca之后O(1)出解

注意：f[1]=0，g[1]=0

tip

注意dfs2的写法，尝试了几种不一样的写法，都不行。。。
只有这种写法才可以

本机跑有两个点RE了，原因玄学~

//这里写代码片
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define ll long long

using namespace std;

const ll mod=1000000007;
const int N=100010;
struct node{
    int x,y,nxt;
};
node way[N<<1];
int st[N],tot=0,n,q,lg;
int deep[N],pre[N][20];
ll f[N],g[N];

void add(int u,int w)
{
    tot++;
    way[tot].x=u;way[tot].y=w;way[tot].nxt=st[u];st[u]=tot;
    tot++;
    way[tot].x=w;way[tot].y=u;way[tot].nxt=st[w];st[w]=tot;
}

void dfs1(int now,int fa)
{
    pre[now][0]=fa;
    f[now]=0;
    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=fa)
        {
            dfs1(way[i].y,now);
            f[now]=(f[now]+f[way[i].y]+1)%mod;      //+1 把deg的计算分配出去  
        }
    f[now]=(f[now]+1)%mod;
}

void dfs2(int now,int fa)
{
    ll sum=0;
    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=fa)
            sum=(sum+f[way[i].y]+1)%mod;            //+1 把deg的计算分配出去
        else sum=(sum+g[now]+1)%mod;                //就是这里，这样写不会出错 

    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=fa)
        {
            g[way[i].y]=((sum-f[way[i].y])%mod+mod)%mod;
            dfs2(way[i].y,now);
        } 
}

void dfs3(int now,int fa,int dep)
{
    deep[now]=dep;
    f[now]=(f[fa]+f[now])%mod;
    g[now]=(g[fa]+g[now])%mod;

    for (int i=st[now];i;i=way[i].nxt)
        if (way[i].y!=fa)
           dfs3(way[i].y,now,dep+1);
}

void cl()
{
    for (int i=1;i<=lg;i++)
        for (int j=1;j<=n;j++)
            pre[j][i]=pre[pre[j][i-1]][i-1];
}

int LCA(int u,int w)
{
    if (deep[u]<deep[w]) swap(u,w);
    int d=deep[u]-deep[w];
    if (d)
        for (int i=0;i<=lg&&d;i++,d>>=1)
            if (d&1)
                u=pre[u][i];
    if (u==w) return u;
    for (int i=lg;i>=0;i--)
        if (pre[u][i]!=pre[w][i])
        {
            u=pre[u][i];
            w=pre[w][i];
        }
    return pre[u][0];
}

int main()
{
    //freopen("tree.in","r",stdin);  
    //freopen("tree.out","w",stdout);
    scanf("%d%d",&n,&q);   lg=log(n)/log(2)+1;
    for (int i=1;i<n;i++)
    {
        int u,w;
        scanf("%d%d",&u,&w);
        add(u,w);
    }

    dfs1(1,-1);
    f[1]=0; g[1]=0;
    dfs2(1,-1);
    dfs3(1,-1,0);
    cl();

    for (int i=1;i<=q;i++)
    {
        int u,w;
        scanf("%d%d",&u,&w);
        int lca=LCA(u,w);
        ll ans=(f[u]-f[lca]+g[w]-g[lca]+mod)%mod;
        printf("%lld\n",ans);
    }
    return 0;
}