蓝桥杯练习 ALGO-132 算法训练 Maze

原题

原题链接

问题描述

   一个含有n个点的迷宫是一棵树（一个任意两点之间都恰好有一条路径的无向图）。每个点都有一定的概率成为这个迷宫的入口和出口。
   从这个迷宫走出去的方法是从入口开始进行深度优先搜索。如果当前有多个移动方案，那么等概率的选择移动方案中的一个。DFS的过程为以下的伪代码：
   DFS(x)
   if x == exit vertex then
   finish search
   flag[x] <- TRUE
   random shuffle the vertices' order in V(x) // here all permutations have equal probability to be chosen
   for i <- 1 to length[V] do
   if flag[V[i]] = FALSE then
   count++;
   DFS(y);
   count++;
   V(x)是与x点相邻的点的序列。Flag数组初始时是全部为FALSE的。DFS 初始时从入口开始。当搜索结束时，变量count将会统计移动的次数。
   你的任务是统计一个人从这个迷宫的入口走到出口步数的数学期望值。

输入格式

   第一行一个数n，表示这个图的节点数。
   下面n-1行，每行包括两个数ai,bi，表示一条连接ai和bi的边。
   下面n行，每行包括两个非负整数xi,yi，表示选择i为入口的可能性和出口的可能性。
   选择i为入口的概率和选择i为出口的概率分别为xi/sumx和yi/sumy，sumx表示x的总和，sumy表示y的总和。sumx以及sumy均为正数且不超过10^6。

输出格式

   输出期望的步数，要求误差不超过10^-9。

样例输入

   输入格式
   2
   1 2
   0 1
   1 0
   输入格式
   3
   1 2
   1 3
   1 0
   0 2
   0 3
   输入格式
   7
   1 2
   1 3
   2 4
   2 5
   3 6
   3 7
   1 1
   1 1
   1 1
   1 1
   1 1
   1 1
   1 1
   样例输出
   输出格式
   1.00000000000000000000
   输出格式
   2.00000000000000000000
   输出格式
   4.04081632653

样例说明

   第一个样例中，入口总是1，出口总是2。
   第二个样例的入口总是1且出口有2/5的概率是2，3/5的概率是3。对于出口为2和3的数学期望是相同的（对称的情况），第一步有0.5的概率直接到达出口，0.5的概率走错到另一个点（然后再走两步到终点）。所以数学期望等于2/5*(1*0.5+3*0.5)+3/5*(1*0.5+3*0.5) = 2。

数据规模和约定

   20% 的数据n <= 100
   50% 的数据n <= 1000
   70% 的数据n <= 10000
   100%的数据n <= 100000

题解

这道题要算的是数学期望，那么在做这道题之前先要看得懂伪代码

就拿这颗简单的二叉树举例子，将1号节点作为起点，4号节点作为终点，它的长度期望值是多少呢？
不妨计算一下，从1号点开始DFS，有1/2的几率进入3号点，而一旦进入3号点，它就必须遍历完整颗子树才会出来，而进入2号点之后还有1/2的几率进入5号点。而且不管如何都必须以进入正确的节点作为结束。
因此总的期望为(1 + 1/2 * (1 * 2) + 1)+1/2 * (2*3) = 6

如果稍微机智一点，就能从上面那个期望的公式当中发现一些规律出来：
从某一个节点到达另一个节点的路径期望值等于路径中所有可能被遍历的边数之和

打个表的话大概是这个样子：

终\起	1	2	3	4	5	6	7
1	0	4	4	6	6	6	6
2	3	0	4	6	6	6	6
3	3	4	0	6	6	6	6
4	3	1	4	0	6	6	6
5	3	1	4	6	0	6	6
6	3	4	1	6	6	0	6
7	3	4	1	6	6	6	0

于是乎，我们可以从表格中总结出这样一条规律：

IF 终点为起点的祖先节点 Val = (为起点祖先的终点的子节点的儿子数+1)
ELSE   Val = (总结点数 - 1 - 终点的儿子数)

举个例子，
1是4的祖先节点，而2是4的祖先节点，且2是1的儿子，因此4->1的期望路径长=2->1的期望路径长=2的儿子数+1=4
然后表格里各种666就是else的那种情况啦

于是乎 我们可以愉快的写下一个转移方程(伪代码)：

for(int u = 0 ~ n) 
    for(int i = 0 ~ n except u)
        if (i 是 u 的祖先) sum += (find(u).son + 1) * u.st * i.ed;
        else sum += (n - 1 - i.son) * u.st * i.ed;`

复杂度在O(N^2)和O(N^3)之间，在100,000的数据量下不TLE才有鬼，所以需要改进
首先，可以明确的是一个节点的祖先节点终究是有限的，更多的是情况2，也就是Val = (总结点数 - 1 - 终点的儿子数)
所以我们可以先进行预处理sum += (n - 1 - son[u]) * (tst - st[u]) * ed[u];
然后再对所有u的祖先节点进行一次更新

x = u;
do{
    sum += (x.son + 1) * u.st * x.fa.ed;
    x = fa[x];
    sun -= (n - 1 - x.son) * u.st * x.ed;
}while(x != 根节点);

这样复杂度就大幅下降了，不过还是有可能会有一条链的情况，最坏复杂度依旧高达O(N^2)，因此我们需要进一步优化
从表中可以看出 每一个节点到达它父节点的期望路径值与它的子节点到达父节点的期望路径值是完全相等的，因此我们可以在DFS中储存节点u和u的所有子节点作为起点的概率和lf，然后一并进行处理。

这样复杂度就降到了O(N)

万事俱备

另外要注意的是，本体对于精度的要求相当的高，所以要用long long来储存数值，输出前再做除法。

程序如下：

#include<iostream>
#include<string>
#include<cstdio>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<fstream>
using namespace std;

const int maxn = 100010;

int fa[maxn],son[maxn],st[maxn],ed[maxn],n;
long long sum = 0,tst = 0,ted = 0,lf[maxn];
vector<int> e[maxn];

void dfs1(int u,int f){
    son[u] = 0;
    fa[u] = f;
    for(int i = 0;i < e[u].size();++i){
        int ff = e[u][i];
        if (ff == f) continue;
        dfs1(ff,u);
        son[u] += son[ff];
        son[u]++;
    }
}

void dfs2(int u){
    lf[u] = st[u];
    sum += (n - 1 - son[u]) * (tst - st[u]) * ed[u]; //预处理情况2
    for(int i = 0;i < e[u].size();++i){//更新lf，集中处理情况1
        int ff = e[u][i];
        if (ff == fa[u]) continue;
        dfs2(ff);
        lf[u] += lf[ff];
        sum += (son[ff] + 1 - (n - 1 - son[u])) * lf[ff] * ed[u];
    }
    if(u == 1) return;
}

void init(){
    cin >> n;
    int l,r;
    for(int i = 1;i < n;++i){
        cin >> l >> r;
        e[l].push_back(r);
        e[r].push_back(l);
    }
    for(int i = 1;i <= n;++i){
        cin >> l >> r;
        st[i] = l;
        tst += l;
        ed[i] = r;
        ted += r;
    }
}

int main(){
    init();
    dfs1(1,1);
    dfs2(1);
    printf("%.11lf\n",sum * 1.0 / tst / ted);
}