宝藏

题目大意及模型转换

给定一颗由N个结点组成的树，并有q组询问，每个询问给定a0,a1…ap，求初始站在a0，接下来去a1，再去a2，一直到ap的期望耗时。每条边经过需要花费一个单位时间，站在一个点上，下一步走动会随机等概率选择一个相邻结点。

暴力作法

显然答案为每一对从ai到ai+1的期望时间之和。那么我们每次将ai当作根，开始搜索。每一个点我们都设出它前往ai+1的期望时间，然后通过递归处理解出方程，将含有其父亲到ai+1的期望时间的未知数的方程迭代回去。

#include<cstdio>
#include<iostream>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
typedef double db;
const int maxn=50000+5;
db k1[maxn],k2[maxn],k3[maxn],d[maxn],ans;
int h[maxn],next[maxn*2],go[maxn*2];
int i,j,k,l,t,n,m,p,tot,ca;
void add(int x,int y){
    go[++tot]=y;
    next[tot]=h[x];
    h[x]=tot;
}
void dfs(int x,int y){
    if (x==k){
        k1[x]=k2[x]=k3[x]=0;
        return;
    }
    k1[x]=k2[x]=k3[x]=0;
    int t=h[x];
    while (t){
        if (go[t]==y){
            k1[x]=1/d[x];
            k3[x]=k3[x]+1/d[x];
        }
        else{
            dfs(go[t],x);
            k2[x]=k2[x]+k1[go[t]]/d[x];
            k3[x]=k3[x]+(k3[go[t]]+1)/d[x];
        }
        t=next[t];
    }
    if (k2[x]==0) return;
    if (y==0) return;
    k1[x]=k1[x]/(1-k2[x]);
    k3[x]=k3[x]/(1-k2[x]);
}
int main(){
    freopen("c.in","r",stdin);freopen("c.out","w",stdout);
    scanf("%d",&ca);
    while (ca--){
        scanf("%d",&n);
        tot=0;
        fill(h,h+n+1,0);
        fill(d,d+n+1,0);
        fo(i,1,n-1){
            scanf("%d%d",&j,&k);
            j++;k++;
            add(j,k);
            add(k,j);
            d[j]=d[j]+1;d[k]=d[k]+1;
        }
        scanf("%d",&m);
        fo(l,1,m){
            scanf("%d",&p);
            ans=0;
            fo(i,1,p+1){
                scanf("%d",&k);
                k++;
                if (i>1){
                    dfs(j,0);
                    ans=ans+k3[j]/(1-k2[j]);
                }
                j=k;
            }   
            printf("%.4lf\n",ans);
        }
        printf("\n");
    }
    fclose(stdin);fclose(stdout);
    return 0;
}

正解

容易发现，如果对于三个点A,B,C，B在A到C的必经之路上，那么A到C的期望时间等于A到B的期望时间加B到C的期望时间。
先将树转化为有根树，递推出f[i]与g[i]，分别表示i到其父亲的期望时间，i的父亲到其的期望时间。然后处理sum[i]和num[i]分别表示i到根的期望时间和根到i的期望时间，接下来对于询问用lca即可。
至于递推式，如果理解了60分做法，自己推一推就可以了。以下给程序作参考。

#include<cstdio>
#include<iostream>
#include<cmath>
#define fo(i,a,b) for(i=a;i<=b;i++)
using namespace std;
const int maxn=50000+10;
int f[maxn],g[maxn],sum[maxn],num[maxn],ans;
int fa[maxn][21],dep[maxn];
int h[maxn],next[maxn*2],go[maxn*2];
int i,j,k,l,t,n,m,p,q,ca,tot;
void add(int x,int y){
    go[++tot]=y;
    next[tot]=h[x];
    h[x]=tot;
}
void dfs(int x,int y){
    int b=1;
    int t=h[x];
    while (t){
        if (go[t]!=y){
            dfs(go[t],x);
            b=b+(f[go[t]]+1);
        }
        t=next[t];
    }
    if (!y) return;
    f[x]=b;
}
void dg(int x,int y){
    int b=2+g[x];
    int t=h[x];
    while (t){
        if (go[t]!=y) b=b+(f[go[t]]+1);
        t=next[t];
    }
    t=h[x];
    while (t){
        if (go[t]!=y){
            b=b-(f[go[t]]+1);
            if (!y) g[go[t]]=b-g[x]-1;
            else g[go[t]]=b;
            b=b+(f[go[t]]+1);
            dg(go[t],x);
        }
        t=next[t];
    }
}
void dfsg(int x,int y){
    fa[x][0]=y;
    dep[x]=dep[y]+1;
    sum[x]=sum[y]+f[x];
    num[x]=num[y]+g[x];
    int t=h[x];
    while (t){
        if (go[t]!=y) dfsg(go[t],x);
        t=next[t];
    }
}
int lca(int x,int y){
    if (dep[x]<dep[y]) x^=y^=x^=y;
    int j;
    if (dep[x]>dep[y]){
        j=floor(log(dep[x]-dep[y])/log(2));
        while (j>=0){
            if (dep[fa[x][j]]>dep[y]) x=fa[x][j];
            j--;
        }
        x=fa[x][0];
    }
    if (x==y) return x;
    j=floor(log(dep[x])/log(2));
    while (j>=0){
        if (fa[x][j]!=fa[y][j]){
            x=fa[x][j];
            y=fa[y][j];
        }
        j--;
    }
    return fa[x][0];
}
int dis(int x,int y){
    if (x==y) return 0;
    int z=lca(x,y);
    return sum[x]-sum[z]+num[y]-num[z];
}
int main(){
    scanf("%d",&ca);
    while (ca--){
        scanf("%d",&n);
        fill(h,h+n+1,0);
        tot=0;
        fo(i,1,n-1){
            scanf("%d%d",&j,&k);
            j++;k++;
            add(j,k);
            add(k,j);
        }
        dfs(1,0);
        dg(1,0);
        dfsg(1,0);
        fo(j,1,floor(log(n)/log(2)))
            fo(i,1,n)
                fa[i][j]=fa[fa[i][j-1]][j-1];
        scanf("%d",&q);
        fo(i,1,q){
            scanf("%d",&p);
            ans=0;
            fo(j,1,p+1){
                scanf("%d",&l);
                l++;
                if (j>1) ans=ans+dis(k,l);
                k=l;
            }
            printf("%d.0000\n",ans);
        }
        printf("\n");
    }
}

注意

最后可以发现期望时间一定是整数。