期望与概率

预备知识

定义
$P（A）$：事件A发生的概率；
$E（A）$：事件A的期望。
对于离散的事件$A_1，A_2，A_3...A_n$，则定义其期望为$P（A）\times A$，这里可以推出，若概率为$P（A）$，设此概率为$\frac{p}{q}$，则不妨设样本容量为$q$，则其发生次数为$p$，从而其期望为$A\times \frac{p}{q}$，若其样本为等地位的，则其期望中$A$可以省去，故有：$E（A）=\frac{1}{P(A)}$。
从而可以以其解题。

题目

经典

下飞行棋，每次投骰子1-m，扔多少前进多少，求一开始在一，走到n的期望次数。（超过n也算走到n）

题解
最入门的题目。令$dp[i]$表示距离终点还有$i$步时的期望。那么显然$dp[0]=0$。为了方便起见，我们设$dp[i\le 0]=0$。考虑转移，就是枚举这一次甩了多少，那么
$$dp[i]=1+\frac{1}{m}\sum _{j=i-m}^{i-1}dp[j]$$

化简得$$dp[i]=\frac{m+1}{m}dp[i-1]-\frac{1}{m}dp[i-m-1]$$。一个简单的做法是矩阵快速幂，复杂度$O(m^{3}logN)$。注意到特殊性，转移只与两项有关，考虑一项贡献，为$$\sum _{x+(m+1)y=n-1}(\frac{m+1}{m}{)}^x(-\frac{1}{m}{)}^y\times C_{x+y}^x$$，那么$x=n-1-(m+1)\ast y$，从而原式

$$(\frac{m+1}{m}{)}^{n-1}\sum _{(m+1)y\le n-1}[(\frac{m}{m+1}{)}^m(-\frac{1}{m}){]}^y\times C_{n-1-my}^y$$

bzoj 1426

          有n种不同的邮票，皮皮想收集所有种类的邮票。唯一的收集方法是到同学凡凡那里购买，每次只能买一张，并且买到的邮票究竟是n种邮票中的哪一种是等概率的，概率均为1/n。但是由于凡凡也很喜欢邮票，所以皮皮购买第k张邮票需要支付k元钱。 现在皮皮手中没有邮票，皮皮想知道自己得到所有种类的邮票需要花费的钱数目的期望。

首先，我们先做一个入门版本的此题：
有$n$种不同的邮票，皮皮想收集所有种类的邮票。唯一的收集方法是到同学凡凡那里购买，每次只能买一张，并且买到的邮票究竟是n种邮票中的哪一种是等概率的，概率均为$\frac{1}{n}$。现在皮皮手中没有邮票，皮皮想知道自己得到所有种类的邮票需要花费的钱数目的期望。
我们假设$f( i ) $为已经有了i种,接着买完剩下$（n-i）$种的期望，那么明显有
$f（i）=\frac{n-i}{n}\times f(i+1)+\frac{i}{n}\times f(i)+1$;即化简得$f(i)=f(i+1)+\frac{n-i}{n}$。
为什么呢？这是因为当我们买下一张票的时候，有的概率买到新的一种，有概率买到原有的，而由于已经买了一张新的，那么买一张的新的概率就为1，所以由期望的公式得，要加上$1$，有些题解说还要记录一个$g（i）$数组表示得到i种的概率，实际上没必要。原因马上讲。注意之前的定理，有$E（A）=\frac{1}{P(A)}$，条件是事件地位平等，我们不妨这样，买一张买到一张新的概率是$\frac{n-i}{n}$那么由公式得其期望为$\frac{n-i}{n}$，那么有全期望公式可得，$f(i)=f(i+1)+\frac{n-i}{n}$，与之前一模一样。

所以正解是
我们可以得到，对于这个$g$，实际上是等概率的(都是一个收敛的级数，分布均匀),所以不用记录$g$数组。而且，我们也更加可得$E（A）=\frac{1}{P(A)}$的重要性与巧妙性了。
好了，回到这道题，注意到每张邮票买的钱不一样，那么，我们可以理解为当概率相同时，权值不一样，所以期望不一样。所以也可以看成当权值相同时，概率不一样，所以这次要记录一个$g$表示还要多少钱，当然也可以记概率，但更复杂。所以用$f[i]$表示已经拥有了$i$张邮票，则期望还需要购买的邮票数。
$f[i]=f[i]\times \frac{i}{n}+f[i+1]\times \frac{n-i}{n}+1$
$ f[i]=f[i+1]+\frac{n}{n-i};$
又有
$ g[i]=\frac{n-i}{n} \times (g[i+1]+f[i+1])+\frac{i}{n}\times( g[i]+f[i] )+1$
化简得
$g[i]=g[i+1]+f[i+1]+\frac{n\times i}{(n-i)\times n}\times f[i]+\frac{n}{n-i}$。
然后，就两个数组一起搞啊~~~。
（权限题，所以我也不确定正不正确，如果想要，找其他人吧。）

bzoj4832

（好题，以后玩炉石可以用）。题意是告诉你克苏恩的攻击力，你场上的随从状态（只有奴隶主，可能一血，二血，三血），问你克苏恩对英雄的伤害的期望。
题解
记录$dp[i][m][n][k]$表示克苏恩i点攻击力，$1—3$血分别有$m,n,k$个时，把攻击打完受到的伤害（最好不要倒着定义成现在到打完还要受多少，时间会多一个常数）。然后，概率$dp$转一转就好了。注意这里的概率的分母为$1+m+n+k$，因为还有个英雄。而且要注意，有可能造不出奴隶主了。（好题）
代码如下

#include<cstdio>
#include<algorithm>
using namespace std;
int i,m,n,k;
double dp[70][10][10][10];//已经受了这么多伤[m][n][k] m 1,n 2,k 3 
int main()
{

	for (int i = 1; i<=50 ;i++)
	   for (int m = 0;m <= 7;m++)
		for (int n = 0; n <= 7 - m;n++)
		  for (int k = 0;k  <= 7 - m - n ;k++)
		  {
		  	int j = m + n + k;
		  	double seg = 1.0 / (m + n + k + 1.0);
		  	dp[i][m][n][k] += seg * ( dp[i-1][m][n][k] + 1.0);
		  	if (m) dp[i][m][n][k] +=  (double)m * seg * dp[i-1][m-1][n][k];
		  	if (n)
		  	{
		  		if (j<7) dp[i][m][n][k] += seg * (double)n * dp[i-1][m+1][n-1][k+1];
		  		else dp[i][m][n][k] += seg * (double)n * dp[i-1][m+1][n-1][k];
			}
		  	if (k)
		  	{
		  		if (j<7) dp[i][m][n][k] += seg * (double)k * dp[i-1][m][n+1][k];
		  		else dp[i][m][n][k] += seg * (double)k * dp[i-1][m][n+1][k-1];
			}
		}	
	int t;scanf("%d",&t);	 
	while (t--)
	{
		
		scanf("%d%d%d%d",&i,&m,&n,&k);
		printf("%.2lf\n",dp[i][m][n][k]);
	}
	
	return 0;
 } 

bzoj 1419##

翻钱，给定红钱个数，黑钱个数，一个一个翻，但是你只能知道还剩几个红，几个黑，翻到红就$+1s$，黑就$-1s$，可以随时不翻，然后就算成一种情况，求在最优策略下的期望。
题解
首先，最优策略明显就是当剩下的钱黑的多就不翻了,然后，就没别的策略了，拼$RP$了。设$dp[i][j]$为剩下$i$个红色，$j$个黑色的期望，转移就是一般的转移，但是注意，我们得从后推$dp$，因为从前推我们不一定能推到最优策略（想想我们的最优策略，是看之后还要怎么翻，而明显，从后推时，$dp[1][1]$，$dp[1][0]$这些我们都可以直接推出，所以从后推（我是指相对答案从后推，答案是$dp[i_{max}][j_{max}]$））。（还是水）。
代码如下(权限题，错了不怪我，我也没试过)

#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
double dp[3][5010];
int r,b;
double k;
int main()
{
	scanf("%d%d",&r,&b);
	for (int i = 1;i <= r;i++)
	{
		dp[i%2][0] = i;
		for (int j = 1 ;j <= b;j++)
		{
		double A = (double)i/(i+j),B = (double)j/(i+j);
		k = A * ( dp[ (i-1)%2 ][j] + 1) + B* ( dp[i%2][j-1] -1);
		dp[i%2][j] = max(0.0, k);
		}
	}
	dp[r%2][b]=floor(dp[r%2][b]*=100000);
	dp[r%2][b]/=1000000;
	printf("%.6lf",dp[r%2][b]);
	return 0;
}

bzoj1415##

（题太长了，自己去看吧…）
题解
组合题，但实际上并不难，只需要首先用$bfs$搜一遍路径，用$x[i][j]$表示从$i$走到$j$下一步的点，由于要去最小的，所以还要记一个$dis$数组，然后判定距离加打擂台确定$x[i][j]$的值,接着就简单了，简单的期望$dp$转移，但是还要加上那只耗子不动的可能。$dp$的时候，由于是图上$dp$，最好写一个记忆化搜索，当然大佬可以写其他方法（膜）。（没那么水）（汤姆表示自己也想要一个这样的$GPS$）。
代码如下：

#define f(x,y,z) for (int x=(y);x<=(z);x++)
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int maxn =1005;
struct Edge{
    int fr,to,next;
}edge[maxn*2];int line_cnt=0;
int head[maxn] , val[maxn]; int head_cnt = 0;
int x[maxn][maxn],dis[maxn][maxn];
double f[maxn][maxn];
int n,e;
int mou,cat;
void addedge(int f,int t)
{
    int a = head[f];
    edge[++line_cnt] = (Edge){f,t,a} ;
    head [f] = line_cnt;
}
void adde(int f,int t)
{
    addedge(f,t);
    addedge(t,f);
}
void bfs(int start)//要记录距离
{
    queue<int> q;
    dis[start][start] =0;
    q.push(start);
	    while (!q.empty())
    {
        int r = q.front();q.pop();int tmp = x[start][r];
        for (int i = head[r]; i ;i = edge[i].next)
        {
            int u = edge[i].to;
            if (dis [start][u]==-1 || (dis[start][r] +1 == dis[start][u] && tmp < x[start][u]))    
            {
            dis[start][u] = dis[start][r] +1;
            if (tmp) x[start][u] = tmp;else x[start][u] = u;
            q.push(u);
            }
        }
    }
}
double dp(int cc,int kk)//记忆化搜索
{
    int n1 = x[cc][kk];
    int n2 = x[n1][kk]; 
    if (f[cc][kk] != -1) return f[cc][kk];
    if (cc == kk) return f[cc][kk] = 0;
    if (n1  == kk) return f[ cc ][kk] = 1;
    if (n2 == kk) return f[ cc ][kk] = 1;
    f[cc][kk] = 0;
    for (int i = head[kk]; i ;i = edge[i].next)
    {
        int u = edge[i].to;
        f[cc][kk] += dp(  n2 , u );
    }
    f[cc][kk] = ( f[cc][kk] + dp( n2 , kk) ) / (double) ( val[kk] + 1 ) +1;
    return f[cc][kk];
}
 
int main()
{
    scanf("%d%d",&n,&e);
    scanf("%d%d",&cat,&mou);
    int ua,ub;
    memset(dis,-1,sizeof dis);
	memset(val,0,sizeof val);
    for (int i = 1;i<=n;i++)
      for (int j = 1;j<=n;j++)
         f[i][j]=-1;
    for (int i=1;i<=e;i++)
    {
        scanf("%d%d",&ua,&ub);
        val[ua]++;val[ub]++;
        adde( ua , ub);
    }
    for (int i = 1 ;i<=n;i++) {bfs(i);x[i][i]=i;}
 	printf("%.3lf", dp(cat , mou));
    return 0;
}
 

树上期望：

• 树上随机游走的期望（求从根节点第一次到其他节点的期望步数）：

由期望的可加性，有从$root$到$i$的期望等于$root$到$i$的父亲$fa$的期望加上$fa$到$i$的期望，明显$root$到$fa$的期望就变成了一个递归的问题，从而只需求出$fa$到$i$的期望就行了。 $d[i]$表示$i$的度数，每条边的长度均为1。$F[i]$表示从$i$走到其父亲的期望步数，$G[i]$表示从$i$的父亲$fa$走到$i$的期望，所以有对于$F[i]$，则有如下可能：直接走到父亲，走到i的某一个儿子又走回来又走到父亲，即有$F[i]=\frac{(1+\sum F[son] + 1 + F[i])}{d[i]}$，化简得 $F[i]=d[i] + \sum F[son]$（因为$i$的儿子有$d[i]-1$那么多个）

接着看$G[i]$，我们有从$fa$走到一个错误的儿子，走到$fa$的父亲，走到$i$这三种情况。
$G[i]=\frac{1+G[fa]+G[i]+1+\sum F[brother]+G[i]+1}{d[fa]}$，
化简得
$G[i]=G[fa]+d[fa]+\sum F[brother]$。
即：
$F[fa]-F[i]=d[fa]+\sum F[brother]$。
$G[i]=G[fa]+F[fa]-F[i]$。

• 更简单的方法：

上面的实际上就足够了，复杂度是$O（n）$的，常数为$2$（两遍$dfs$），但是还有更好的，一边$dfs$就可以搞定，而且更简单。
不仿设第$i$个点的期望是$ans[i]$，那么有$ans[i]=ans[fa]+G[i]$（$G[i]$就是之前的东西）。
那么这个$G[i]$由之前的式子可得
$G[i]=G[fa]+d[fa]+\sum F[brother]$
，$G[fa]$又是什么呢？
再迭代可得
$G[fa]=G[grandfa]+d[grandfa]+\sum F[brother]$。
如此下去，直到$root，G[root]=0$，将这些式子加起来，可得
$G[i]=\sum d[ancester]（除了i）+\sum \sum F[brother]$（这个双segma表示的是对于每一个$ancester$而言，其除了$i$的祖先的儿子的$F$之和）。
注意到
$F[j]=d[j]+\sum F[son]$
，那么对于一个$F[j]$，我们递归可以得到
$F[j]=以j为根的子树的度数总和+1$（加一是因为i还有一个特殊的度是通向其父亲的）
，那么这个$f[j]+d[j]$不就是这个树的度数$+1$。
又因为其度数中，一条边算了两次（除了j通向其父亲的），所以这棵树的度数=$2\times $其点数$-1$（不忘特殊边只算过一次），所以这个式子是以$j$为根的的子树的大小，出了$j$走向$i$的那颗子树，所以求和之和是长这样的：蛤？那不就是除了$i$以外的树的大小的两倍？但是我们还是要注意，根节点没有头上的那根，所以还要减一，所以将每个$\sum F[son]与d[ancester]KaTeX parse error: Expected 'EOF', got '#' at position 33: …ize=4 color = #̲0000FF>G[i] = 2（n-Size[i]）+1$ 。

从而$ans[i]=ans[fa]+2(n-size[i])+1$。那这个就可以一遍搞定了。

• 另解：

对于这个式子证明还有一个感性的理解，因为我们想，$G[i]$而言，从$fa$走到$i$的期望，我们不管什么树，什么路径，我们这样想，从$n$个节点中随便选一个，如果选到$i$及其子树上的点，那么肯定走到过$i$，反之，就没走到过，所以选到其子树概率是$\frac{size}{n}$，又因为概率等于期望的倒数，所以有$G[i]=2（n-size[i]）+1$。（乱证的，请自行跳过。）

连续样本的期望

作为一个数竞党，再发一个对连续样本期望的求法（实际上就是积分一下就好了）（转自百度百科）：

最后要说的

好吧，最后说一下，这是我的第一篇博客，其中一些想法借鉴了许多大犇的题解，所以如果发现有雷同，那很可能是我从前看过的，然后整理了一下吧…