jzoj5814. 【NOIP提高A组模拟2018.8.14】 树

题目描述

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.

20%

每次询问dp来求期望，做10000次就可以得到正确答案了

另20%

找找规律？

40%

其实是之前的 4890. 【NOIP2016提高A组集训第14场11.12】随机游走 那道题的弱化版。。。
连后来的DP都不用了

---

考虑每条边的期望
设f[i,j]表示从i走到j的期望步数（i与j相邻）
设d[i]表示i的度数
则
$f[i,j]=\frac{1+\sum_{k∈son\{i\}}{1+f[k,i]+f[i,j]}}{d[i]}$

解释一下。
首先从i出发有d[i]种可能，所以结果$*\frac{1}{d[i]}$
$f[i,j]=\frac{1+\sum_{k∈son\{i\}}{1+f[k,i]+f[i,j]}}{\color {#ff0000}{d[i]}}$

第二，从i有$\frac{1}{d[i]}$的概率直接走到j，所以要+1
$f[i,j]=\frac{\color {#ff0000}{1}+\sum_{k∈son\{i\}}{1+f[k,i]+f[i,j]}}{d[i]}$

第三，从i可以先走到一个相邻的点k（步数为1）,接着从k走回i（步数为f[k,i]），最后从i走到j（步数为f[i,j]）
$f[i,j]=\frac{1+\color {#ff0000}{\sum_{k∈son\{i\}}{1+f[k,i]+f[i,j]}}}{d[i]}$

---

接着化简这个式子
$f[i,j]=1+\frac{\sum_{k∈son\{i\}}{f[k,i]+f[i,j]}}{d[i]}$
$d[i]*f[i,j]=d[i]+\sum_{k∈son\{i\}}{f[k,i]+f[i,j]}$
$d[i]*f[i,j]=(d[i]-1)*f[i,j]+d[i]+\sum_{k∈son\{i\}}{f[k,i]}$
$f[i,j]=d[i]+\sum_{k∈son\{i\}}{f[k,i]}$

已经可以看出来了，f[i,j]=当j为根时i子树中所有点的度数和
再推一推，
$f[i,j]=2size[i]_{\text{以j为根}}-1$

emmmmmmmm
因为期望的线性性，一条路径的期望就是上面所有边的期望和，所以直接暴力走就行了
别问我我也不知道这是smg

100%

把暴力改成倍增
没了

code

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define mod 1000000007
using namespace std;

int a[200001][2];
int ls[100001];
int size[100001];
int f[100001];
int g[100001];
int fa[100001][17];
int F[100001][17];
int G[100001][17];
int d[100001];
int n,len,Q,i,j,k,l,x,y,ans;

void New(int x,int y)
{
    len++;
    a[len][0]=y;
    a[len][1]=ls[x];
    ls[x]=len;
}

void dfs(int Fa,int t)
{
    int i;

    fa[t][0]=Fa;
    fo(i,1,floor(log(d[t]-1)/log(2)))
    fa[t][i]=fa[fa[t][i-1]][i-1];

    size[t]=1;
    for (i=ls[t]; i; i=a[i][1])
    if (a[i][0]!=Fa)
    {
        d[a[i][0]]=d[t]+1;

        dfs(t,a[i][0]);
        size[t]+=size[a[i][0]];
    }
}

void Dfs(int Fa,int t)
{
    int i;

    f[t]=size[t]*2-1;
    g[t]=(n-size[t])*2-1;

    F[t][0]=f[t];
    G[t][0]=g[t];
    fo(i,1,floor(log(d[t]-1)/log(2)))
    {
        F[t][i]=(F[t][i-1]+F[fa[t][i-1]][i-1])%mod;
        G[t][i]=(G[t][i-1]+G[fa[t][i-1]][i-1])%mod;
    }

    for (i=ls[t]; i; i=a[i][1])
    if (a[i][0]!=Fa)
    Dfs(t,a[i][0]);
}

int main()
{
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);

    scanf("%d%d",&n,&Q);
    fo(i,2,n)
    {
        scanf("%d%d",&x,&y);

        New(x,y);
        New(y,x);
    }

    d[1]=1;
    dfs(0,1);
    Dfs(0,1);

    for (;Q;Q--)
    {
        ans=0;
        scanf("%d%d",&x,&y);

        if (d[x]>d[y])
        {
            fd(i,16,0)
            if (d[fa[x][i]]>=d[y])
            {
                ans=(ans+F[x][i])%mod;
                x=fa[x][i];
            }
        }
        else
        if (d[x]<d[y])
        {
            fd(i,16,0)
            if (d[fa[y][i]]>=d[x])
            {
                ans=(ans+G[y][i])%mod;
                y=fa[y][i];
            }
        }

        fd(i,16,0)
        if (fa[x][i]!=fa[y][i])
        {
            ans=((ans+F[x][i])%mod+G[y][i])%mod;
            x=fa[x][i];
            y=fa[y][i];
        }

        if (x!=y)
        ans=((ans+F[x][0])%mod+G[y][0])%mod;

        printf("%d\n",ans);
    }

    fclose(stdin);
    fclose(stdout);

    return 0;
}

后记

期望真奇(sang)妙(bing)

lking123说这道题还可以改得更丧病
在原题的基础上+莫比乌斯反演求边权+LCT维护树的形态、子树大小+动态删边加边询问
但我估计出题人会被爆日一顿