概率期望 / dp

正整数随机变量 $x$ 的期望值：$E(x)={\sum }_{i=1}^{\infty }P(x>=i)$

Blocks
期望dp，从已经满足的点倒着推，首先考虑状态，发现$n$很小，直接状压，然后暴力枚举状态看是否全部覆盖，发现坐标跨度很大，对坐标离散化，依次差分修改，$O(n^2{2}^n)$，然后就可以直接dp了
$d{p}_i=\frac{{\sum }_{j}d{p}_i[(1<<j)\&i]+1+{\sum }_{j}d{p}_{i|j}+1[(1<<j)\&1==0]}{n}$
化简得：$d{p}_i=\frac{n+{\sum }_{j}d{p}_{i|j}[(1<<j)\&1==0]}{n-cnt1(i)}$

P3239 [HNOI2015] 亚瑟王
一张卡牌一整局只会产生一次贡献，不妨直接考求出这一次贡献所产生的的概率为多少。

设$g_i$表示第$i$张牌在$r$轮中发动一次技能的概率，发现这个东西不太好找前后的递推关系。我们发现当前卡牌是否发动技能的概率受到前面卡牌的影响（前面选了几张卡，那么我再怎么也要有几轮把前面的卡选完），但不受到后面卡牌的影响，所以我们设$f_{i,j}$，表示在这$r$轮中，前$i$张牌有$j$张牌被选的概率，这样我们就知道有多少轮能在$i$这个地方做出决策（产生被选的概率），从而算出$g_i$

然后$f_{i,j}$每次只要看在$r$轮中$i$这张卡牌是否产生发动一次技能，分类转移

    std::vector<std::vector<double>> f(n+1,std::vector<double>(r+1));
    f[0][0]=1;
    for (int i=1;i<=n;i++){
        for (int j=0;j<=r;j++){
            f[i][j]=f[i-1][j]*ksm(1-p[i],r-j);
            if (j) f[i][j]+=f[i-1][j-1]*(1-ksm(1-p[i],r-j+1));
        }
    }

    std::vector<double> g(n+1);
    double ans=0;
    for (int i=1;i<=n;i++){
        for (int j=0;j<=r;j++){
            g[i]+=f[i-1][j]*(1-ksm(1-p[i],r-j));
        }
        ans+=g[i]*d[i];
    }
    std::cout<<std::fixed<<std::setprecision(10)<<ans<<"\n";

P3750 [六省联考 2017] 分手是祝愿
50%的数据 $k==n$，也就是说只要找到最小的关灯次数
直接从后往前遍历，当前点为$i$，如果现在$i$这个位置为1，那只能在这按一次开关，然后$O(\sqrt{n})$去修改其它位置的状态。

考虑有等概率随机按开关的情况，其实在前面我们就能知道，给出的数据我们一共要按的开关就只有那几个，一个开关重复按两次是没有效果的，按错了开关到最后也得按回去，所以我们状态设计就是已经按了几个要按的开关,$f_i$表示已经按了$i$个要按的开关的期望。
$i<=k,f_i=k$
$i>k$ 我们分类按对了开关或按错了开关:
$f_i=\frac{i}{n}\cdot f_{i-1}+\frac{n-i}{n}\cdot f_{i+1}$
令$f_i=f_{i-1}+b_i$ $b_i$代入式子中解出$b_i$的递推式，然后根据推出$f_i$

另一种状态设计就是$f_i$表示剩下$i$个开关要按，到剩下$i-1$个开关要按的期望为多少
$f_i=\frac{i}{n}+\frac{n-i}{n}(1+f_{i+1}+f_i)$ 然后移项即可得到递推式
最后累加

代码是第一种方法

    std::vector<ll> b(n+1);
    b[n]=1;
    int cnt=0;
    for (int i=n;i>=1;i--){
        if (a[i]){
            cnt++;
            for (int j=1;j*j<=i;j++){
                if (i%j==0){
                    a[j]^=1;
                    if (i/j!=j) a[i/j]^=1;
                }
            }
        }

        if (i<n){
            b[i]=(n-i+mod)%mod*b[i+1]%mod*ni(i)%mod+n*ni(i)%mod;
            b[i]%=mod;
        }
    }
    std::vector<ll> f(n+1);
    for (int i=1;i<=k;i++){
        f[i]=i%mod;
    }
    for (int i=k+1;i<=cnt;i++){
        f[i]=(f[i-1]+b[i])%mod;
    }
    ll ans=f[cnt];
    for (int i=1;i<=n;i++){
        ans=ans*i%mod;
    }
    std::cout<<ans;

P3412 仓鼠找sugar II
首先考虑固定终点，令终点为根节点，$f_i$表示从$i$到其父亲节点的期望步数，对于叶子结点$f_i=1$，然后推式子：
$$f_i=\frac{1}{de{g}_i}+\frac{{\sum }_{son}1+f_{son}+f_i}{de{g}_i}$$
$$f_i=de{g}_i+\sum _{son}{f}_{son}$$
然后计算不同起点每个$f_i$的贡献$f_i\cdot s{z}_i$
然后换根求不同终点的期望

P3232 [HNOI2013] 游走
这道跟上一道的区别是这道变成了图，上一道因为可以根据dfs序直接推过去，但这一道可能会形成多元环，所以用高斯消元
计算每个点经过次数的期望$f_i$，那么对于一条边其经过的期望次数为$\frac{f_u}{de{g}_u}+\frac{f_v}{de{g}_v}$，然后贪心求贡献

$f_i$式子很简单，注意特判一下$i==1$

P3830 [SHOI2012] 随机树
第一个询问：$f_i$表示叶子个数为$i$个点的期望
$f_i=\frac{(i-1)\ast f_{i-1}+f_{i-1}+2}{i}$化简得$f_i=f_{i-1}+\frac{2}{i}$

第二个询问
$E(x)={\sum }_{i=1}^{\infty }P(x>=i)$
那么设$f_{i,j}$ ，表示叶子个数为$i$，深度大于等于$j$的概率，那么根据公式就很好求期望了

发现不好转移，因为不知道每种情况的出现的概率，转移肯定是由左右子树叶子数转移，所以去想一个树，左右子树叶子数确定的情况下，出现的概率为多少：比如已知总叶子为$i$，左子树叶子有$k$个，那么右子树叶子有$i-k$个，那么这样构造的方案数：首先只考虑每次选左或右方案数 $C_{i-1}^k=\frac{(i-1)!}{k!(i-k-1)!}$，然后考虑左右子树的形态$k!(i-k-1)!$，最终得$(i-1)!$，发现和左右子树叶子数无关，那么$i$个叶子的树种，左子树有$k$个叶子的概率为$\frac{1}{i-1}$

$f_{i,j}=\frac{f_{k,j-1}+f_{i-k,j-1}-f_{k,j-1}\cdot f_{i-k,j-1}}{i-1}$

P4206 [NOI2005] 聪聪与可可
易证猫跟老鼠的距离一定是递减的，所以不会有后效性，状态设为$i,j$表示猫和老鼠的位置
猫运动可以预处理，然后按照题意记忆化搜索即可

CF 908D New Year and Arbitrary Arrangement
倒推 $f_{i,j}$表示前缀中有$i$个$a$，已有的$ab$对有$j$组的期望对数
$f_{i,j}$由$f_{i+1,j},f_{i,i+j}$转移 特判一下边界$i+j>=k$时所需要的期望

推式子：$$p_b\sum _{a=0}^{\infty }(i+j+a)p_a^a$$
$$p_b((i+j)\sum _{a=0}^{\infty }{p}_a+\sum _{a=0}^{\infty }a{p}_a^a)=p_b(\frac{i+j}{1-p_a}+p_a\sum _{a=0}^{\infty }a{p}_a^{a-1})$$

$$i+j+p_b{p}_a(\sum _{a=0}^{\infty }{p}_a^a{)}^{\prime }=i+j+p_b{p}_a(\frac{1}{1-p_a}{)}^{\prime }$$
$$i+j+p_b\frac{p_a}{(1-p_a{)}^2}=i+j+p_b\frac{p_a}{p_b^2}=i+j+\frac{p_a}{p_b}$$

CF 398B Painting The Wall
找规律，状态为已经有几行几列合法，然后推出对所有点分类：
无贡献，贡献行，贡献列，贡献行列

CF 280C Game on Tree
考虑每一个点被选择的概率，如果它有一个祖先先选，该点不产生贡献；如果它在所有祖先前先选，产生$\frac{1}{su{m}_{祖先}}$的贡献,$su{m}_{祖先}=dep$

CF 248E Piglet’s Birthday
发现$i$货架没吃过的罐子<=$a_i$ ，设$f_{i,j}$表示第$i$个货架，有$j$个罐子没吃过的概率，然后可以模拟题目过程求出当前货架罐子数，每次贡献只会从移出罐子的货架产生，所以枚举每次转移中已经吃过的罐子数，组合数求概率

CF 123E Maze
固定起点为根节点$s$，发现很难直接dp，考虑此题的一些特殊性质
假设现在要到$t$,仅存在一条路径，假设当前点为$u$,对其儿子随机排序，令当前正确走向的儿子为$v$,则其它儿子有两种选择，一种排在$v$前，另一种排在$v$后，一旦排在$v$前，会产生$2\cdot sz$的贡献，期望贡献为$sz$ ；排在$v$后无贡献。

转换为，去掉$t$子树后，树的大小为$s$到$t$的期望步数。
那么跟节点固定后，只需要维护去掉子树的期望大小$f$，最后根节点$s$的贡献为$(n-f)\ast s{p}_s$；

后续只需要通过换根dp，就可以求出各点作为根节点的贡献

CF103687 E
首先分类：
$T1>=T2/S==0$，说明只能用第二种回血方式，贪心的想，只要每次在还剩两滴血并且$(1-p_i)$的概率下花费$T2$时间即可

$T1<T2$，首先还是能不回血就不回血，然后有法力优先用$T1$,没法力用$T2$。但是如果当前点是无限回蓝点，转移时可以直接从$f_{i+1,j,S}$转移到$f_{i,j,S}$（法力越高，期望肯定越低）。然后为了更好转移到$i-1$,我们要更新一下不是满法力的状态（有个细节就是要注意转移的顺序，详见代码）

#include <bits/stdc++.h>
#define ll long long
double f[1005][15][10],p[1005];
bool vis[1005];
void yrzr(){
    int n,H,S;
    std::cin>>n>>H>>S;
    for (int i=0;i<n;i++){
        std::cin>>p[i];
        p[i]/=100;
    }
    int K;
    std::cin>>K;
    for (int i=1;i<=K;i++){
        int x;
        std::cin>>x;
        vis[x-1]=1;
    }
    double T1,T2;
    std::cin>>T1>>T2;
    for (int i=0;i<n;i++){
        for (int j=0;j<=H;j++){
            for (int k=0;k<=S;k++){
                f[i][j][k]=1e15;
            }
        }
    }
    if (T1>=T2||S==0){
        for (int i=n-1;i>=0;i--){
            f[i][2][0]=(1+p[i]*f[i+1][2][0]+(1-p[i])*T2)/p[i];
            for (int j=3;j<=H;j++){
                f[i][j][0]=1+p[i]*f[i+1][j][0]+(1-p[i])*f[i][j-1][0];
            }
        }
        std::cout<<std::fixed<<std::setprecision(7)<<f[0][H][0];
    }else{
        for (int i=n-1;i>=0;i--){
            if (!vis[i]){
                f[i][2][0]=(1+p[i]*f[i+1][2][0]+(1-p[i])*T2)/p[i];
                for (int k=1;k<=S;k++){
                    f[i][2][k]=1+p[i]*f[i+1][2][k]+(1-p[i])*(f[i][2][k-1]+T1);
                    for (int j=3;j<=H;j++){
                        f[i][j][k]=1+p[i]*f[i+1][j][k]+(1-p[i])*f[i][j-1][k];
                    }
                }
            }else{
                for (int j=2;j<=H;j++){
                    if (j==2){
                        f[i][2][S]=(1+p[i]*f[i+1][2][S]+(1-p[i])*T1)/p[i];
                    }else{
                        f[i][j][S]=1+p[i]*f[i+1][j][S]+(1-p[i])*f[i][j-1][S];
                    }
                    for (int k=j;k<=H;k++){
                        // f[i][j][S]=std::min(f[i][j][S],(k-j)*T1+f[i][k][S]);
                        //转移时不能直接这么转移，因为此时f[i][k][S]还没更新，所以我们可以直接手动化成f[i+1]的式子
                        f[i][j][S]=std::min(f[i][j][S],(k-j)*T1+(1+p[i]*f[i+1][k][S]+(1-p[i])*T1)/p[i]);
                    }
                    for (int k=0;k<=S;k++){
                        f[i][j][k]=std::min(f[i][j][k],f[i][j][S]);
                    }
                }

            }
        }
        std::cout<<std::fixed<<std::setprecision(7)<<f[0][H][S];
    }
}