概率与期望的学习

最新推荐文章于 2023-03-16 21:29:54 发布
最新推荐文章于 2023-03-16 21:29:54 发布
阅读量946 收藏 1
点赞数 1
分类专栏： 概率与期望
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sslz_fsy/article/details/89042715
版权

目录

一些公式

P1291 [SHOI2002]百事世界杯之旅

[WOJ3010] 骰子

[WOJ3007] Dumb Bones

[WOJ2276]挑战

[WOJ3806]收集邮票

[WOJ3083] 收集宝石

[WOJ3080]迷宫

[WOJ2658]单机游戏

[WOJ1111] 钉子和小球

简单游戏

P3211 [HNOI2011]XOR和路径

P2473 [SCOI2008]奖励关

[WOJ3481]Slay the Spire （稍难）

[WOJ3804]Easy

[WOJ3805]OSU

P3232 [HNOI2013]游走

一些公式

全概率公式

对于互不相容的事件B， 一个随机事件A

P(A)=\sum_{i=1}^nP(B_i)*P(A|B_i)

期望

E(x) =\sum_{i}p_ix_i

理解一下这个

例：抛一个骰子，求抛到6期望多少次

设Xk为抛k次抛到6的期望

X_k=(\frac{5}{6})^{k-1}*\frac{1}{6}        Ans=\sum_{k=1}X_k*k

当然， 因为 P(抛到6) 为 1/6， 所以期望自然是6

全期望公式

E(Y)=E(E(Y|X))=\sum_{i}P(X=x_i)E(Y|X=x_i)

计算期望的方法：1. 直接计算   2. 递推 或 DP   3. 迭代计算  4. 建立方程组

概率期望的最值问题一般用DP解决

P1291 [SHOI2002]百事世界杯之旅

E(x+1)=E(x)+\frac{n}{n-x}

考虑当前抽的， 有 x/n 的概率与前面的重复， n-x / n 的概率可以使人数多一个

于是当前的期望就是上一步的期望 + 上一步到这一步的期望，也就是 1 / （n-x / n） 

//一个不全的代码
#include<bits/stdc++.h>
using namespace std;
int gcd(int x,int y){ return !y ? x : gcd(y, x%y);}
struct Node{ 
	int x, y;
	friend Node operator + (const Node &a, const Node &b){
		Node c; int g = gcd(a.y, b.y);
		c.y = a.y / g * b.y;
		int k1 = a.y / g, k2 = b.y / g;
		c.x = a.x * k2 + b.x * k1;
		return c;
	}
}f[40]; int n;
int main(){
	scanf("%d", &n); f[1].x = f[1].y = 1;
	for(int i=1; i<n; i++){
		f[i+1] = f[i] + (Node){n, n-i};
	} cout << f[n].x<<" "<<f[n].y<<endl;
}

[WOJ3010] 骰子

f[i][j] 表示投了i次，和为j的个数，最后除以6^n输出就可以了

f(i,j)=\sum_{k=1}^6f(i-1,j-k)

#include<bits/stdc++.h>
#define LL long long
using namespace std;
LL tot=1, ans, f[30][200]; int n, x;
LL gcd(LL a,LL b){ return !b ? a : gcd(b, a%b);}
int main(){
	scanf("%d%d", &n, &x); f[0][0] = 1;
	for(int i=1; i<=n; i++){ tot *= 6;
		for(int j=1; j<=i*6; j++){
			for(int k=1; k<=6; k++){
				if(j - k >= 0) f[i][j] += f[i-1][j-k];
			}
		}
	}
	for(int i=x; i<=n*6; i++) ans += f[n][i]; 
	LL g = gcd(tot, ans); 
	if(ans/g == 0) cout << "0";
	else if(ans/g == 1 && tot/g == 1) cout << "1";
	else cout << ans/g << "/" << tot/g <<endl;
	return 0;
}

[WOJ3007] Dumb Bones

概率 + 最优， 很明显是一个区间DP

我们单纯地考虑一个区间，枚举区间的断点，那么当前区间的期望就是

E=E1+E2+ \frac{1}{1-pl-pr}+\frac{pl*E1}{1-pl-pr}+\frac{pr*E2}{1-pl-pr}

解释一下，当前位置期望放 1 / (1-pl-pr) 次是显然的，然后左右各期望重构 pl /  (1-pl-pr)， pr /  (1-pl-pr) 次

于是， 我们用 f(k) 表示长度为 k 的区间的答案, 然后枚举中间点更新就可以了

#include<bits/stdc++.h>
#define N 1050
using namespace std;
double f[N], pl, pr; int n;
double Solve(){
	for(int i=0; i<=n; i++) f[i] = 0;
	for(int i=1; i<=n; i++){
		double ans = 0x3fffffff;
		for(int j=0; j<i; j++){
			double tmp = f[j] * pl + f[i-j-1] * pr;
			tmp = f[j] + f[i-j-1] + (tmp + 1) / (1 - pl - pr);
			ans = min(ans, tmp);
		} f[i] = ans;
	} return f[n];
}
int main(){
	while(~scanf("%d", &n) && n){
		scanf("%lf%lf", &pl, &pr);
		printf("%0.2lf\n", Solve());
	} return 0;
}

[WOJ2276]挑战

如果不考虑碎片的限制， f[i][j] 表示 前i个 有j个成功的概率

f(i+1,j+1)+=f(i,j)*p[i+1]

f(i+1,j)+=f(i,j)*(1-p[i])

然后加一维就可以了， 注意到背包容量到 n就足够了，所以第3位只用枚举到n

#include<bits/stdc++.h>
#define N 205
using namespace std;
int n, a[N], L, K; double f[N][N][N<<1], p[N];
int main(){
	scanf("%d%d%d", &n, &L, &K);
	for(int i=1; i<=n; i++){
		scanf("%lf", &p[i]); p[i] /= 100.0;
	} 
	for(int i=1; i<=n; i++) scanf("%d", &a[i]);
	if(K > n) K = n;
	f[0][0][K+200] = 1;
	for(int i=0; i<n; i++){
		for(int j=0; j<=i; j++){
			for(int k=-i+200; k<=n+200; k++){
				f[i+1][j][k] += f[i][j][k] * (1 - p[i+1]);
				f[i+1][j+1][min(n+200, k+a[i+1])] += f[i][j][k] * p[i+1];
			}
		}
	}
	double ans = 0;
	for(int i=L; i<=n; i++)
		for(int j=0; j<=n; j++)
			ans += f[n][i][j+200];
	printf("%0.6lf", ans); return 0; 
}

[WOJ3806]收集邮票

我们先简单地考虑

令 f[i] 表示已经选了i张， 选到n张的期望张数

f[i]=f[i]*\frac{i}{n}+f[i+1]*\frac{n-i}{n}+1

令g[i] 为已经选了i张， 选到n张的期望价格 ，我们姑且令当前买的价格为1， 后面买的价格都 +1，那么总价格就加了f[i] + 1

 g[i]=(g[i]+f[i])*\frac{i}{n}+(g[i+1]+f[i+1])*\frac{n-i}{n}+1

#include<bits/stdc++.h>
#define N 10050
using namespace std;
double f[N], g[N], n;
int main(){
	scanf("%lf",&n); 
	for(int i=n-1; i>=0; i--){
		f[i] = f[i+1] + (n / (n-i));
		g[i] = f[i+1] + g[i+1] + f[i] * i / (n-i) + (n / (n-i));
	} printf("%0.2lf", g[0]); return 0;
}

[WOJ3083] 收集宝石

类似前面的套路， f[i][j] 表示 有i种宝石，从j个洞里挖出来的期望

#include<bits/stdc++.h>
#define N 1005
using namespace std;
double f[N][N], n, s;
int main(){
	scanf("%lf%lf", &n, &s); 
	for(int i=n; i>=0; i--){
		for(int j=s; j>=0; j--){
			if(i==n && j==s) continue; 
			if(j+1 <= s) f[i][j] += (f[i][j+1] * (i/n) * (1-j/s)) / (1 - (i/n) * (j/s));
			if(i+1 <= n) f[i][j] += (f[i+1][j] * (1-i/n) * (j/s)) / (1 - (i/n) * (j/s));
			if(j+1 <= s && i+1 <= n) f[i][j] += (f[i+1][j+1] * (1-i/n) * (1-j/s)) / (1 - (i/n) * (j/s));
			f[i][j] += 1 / (1 - (i/n) * (j/s));
		}
	} printf("%0.4lf", f[0][0]);
}

[WOJ3080]迷宫

题目明确了图是一棵树, 我们把蓝宝石作为根, 就是求每个点到根的期望

我们先考虑每个点到父亲的期望, 不妨设为 f(u)

f(u) =\sum_{i=1}^{k-1} \frac{1}{k}(f(son_i)+1+f(u))

加上父亲的1步, f(u)=1+\sum f(son)+1

设到根的期望为 E(u) 

E(u)=E(fa)+f(u)

#include<bits/stdc++.h>
#define N 6000
#define M 55
using namespace std;
int first[N], nxt[N], to[N], tot;
char Map[M][M]; int n, m, rt, E[N], f[N], sum, cnt;
int pos(int i,int j){ return (i-1) * n + j;}
int fx[5] = {0, 1, -1, 0, 0};
int fy[5] = {0, 0, 0, 1, -1};
void add(int x,int y){nxt[++tot] = first[x], first[x] = tot, to[tot] = y;}
void dfs(int u, int fa){
	f[u] = 1;
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == fa) continue;
		dfs(t, u); f[u] += f[t] + 1;
	} if(!fa) f[u] = 0;
}
void dfs2(int u,int fa){
	E[u] = f[u] + E[fa];
	for(int i=first[u];i;i=nxt[i]){
		int t = to[i]; if(t == fa) continue; dfs2(t, u);
	} sum += E[u];
}
int main(){
	scanf("%d%d", &n, &m); cnt = m * n;
	for(int i=1; i<=n; i++) scanf("%s", Map[i]+1);
	for(int i=1; i<=n; i++){
		for(int j=1; j<=m; j++){
			if(Map[i][j] == 'X'){ cnt--; continue;}
			if(Map[i][j] == '*') rt = pos(i, j);
			for(int k=1; k<=4; k++){
				int x = i + fx[k], y = j + fy[k];
				if(x>=1 && x<=n && y>=1 && y<=m && Map[x][y] != 'X'){
					add(pos(i, j), pos(x, y));
				}
			}
		}
	} dfs(rt, 0); dfs2(rt, 0); printf("%0.2lf",sum / (cnt*1.0));
	return 0;
}

[WOJ2658]单机游戏

f[i][j] 表示还剩i张红和j张黑的期望

f(i,j)=(f(i-1,j)+1)\frac{i}{i+j}+(f(i,j-1)-1)\frac{j}{i+j} 

记得小于0了就变成0

#include<bits/stdc++.h>
#define N 1050
using namespace std;
int n, m; double f[N][N];
int main(){
	scanf("%d%d", &n, &m);
	for(int i=1; i<=n; i++){
		f[i][0] = i;
		for(int j=1; j<=m; j++){
			f[i][j] = (i / ((i+j) * 1.0) * (f[i-1][j] + 1)) + (j / ((i+j) * 1.0) * (f[i][j-1] - 1));
			f[i][j] = max(f[i][j], 0.0);
		}
	} printf("%0.8lf", f[n][m]);
}

[WOJ1111] 钉子和小球

不妨放下来2 ^ n 个球, f[i][j] 表示到 i, j的方案数, 转移刷表就可以了

#include<bits/stdc++.h>
#define N 1005
#define LL long long
using namespace std;
LL f[N][N], tot; int n, m;
char Map[N][N];
LL gcd(LL a, LL b){ return !b ? a : gcd(b, a%b);}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1; i<=n; i++){
		for(int j=1; j<=i; j++) scanf("%s",&Map[i][j]);
	} f[1][1] = tot = (1ll << n);
	for(int i=1; i<=n; i++){
		for(int j=1; j<=i; j++){
			if(Map[i][j] == '.') f[i+2][j+1] += f[i][j];
			else{ 
				f[i+1][j] += f[i][j] / 2;
				f[i+1][j+1] += f[i][j] / 2;
			}
		}
	} LL g = gcd(tot, f[n+1][m+1]);
	cout << f[n+1][m+1] / g << "/" << tot / g; 
	return 0;
}

简单游戏

所谓简单游戏，相信大家小时候都玩过，就是那种掷出股子子，然后按掷的步数走的游戏。

现在有一个n(1≤n≤100)个格子的游戏，一些格子上有指令。指令分成若干种，如下：

0—空指令  -1—陷阱，到了这里后要掷出六才能继续向前，注意不是向前六步，而是要再掷一次决定步数。 -2—停一次

其它数字 ---- 转移指令，走到数字所代表的格子

走到陷阱中是很难出来的，因此大家都不希望走到陷阱里。

玩一次游戏走到陷阱里的平均次数到底是多少呢？这个问题将由你来解决。

[输入格式]

第一行n，表示游戏的格数。

第二行有n个数，表示每个格子的指令（第一个和最后一个都没有指令）。注意如果某次走到的位置达到或超过最后一个格子，

都表示游戏结束。

[输出格式] 输出走到陷阱里的平均次数。保留3位小数。

[样例输入]   4  0 -1 2 0        [样例输出]   0.400

不会做先建图, 每个点朝可以到达的点连边, 边权为走这条边的概率

我们用 Ei 表示到达过Ei的概率

E1=1

E2=\frac{1}{6}E1+E3

E3=\frac{1}{6}E2+\frac{1}{6}E1

解得 E2 = 0.4

高斯消元就可以了, 所有陷阱的E的和就是答案

#include<bits/stdc++.h>
#define N 500
using namespace std;
int first[N], nxt[N], to[N], tot; double w[N];
int n, vis[N]; double a[N][N];
void add(int x,int y,double z){
	if(y > n) return;
	nxt[++tot] = first[x], first[x] = tot;
	to[tot] = y, w[tot] = z;
}
void gauss(){
	for(int i=1; i<=n; i++){
		int k = i; 
		for(int j=i+1; j<=n; j++)
			if(fabs(a[j][i]) > fabs(a[k][i])) k = j;
		for(int j=i; j<=n+1; j++) swap(a[k][j], a[i][j]);
		double res = a[i][i];
		for(int j=i; j<=n+1; j++) a[i][j] /= res;
		for(int j=1; j<=n; j++){
			if(j != i){
				double tmp = a[j][i];
				for(int k=i; k<=n+1; k++) a[j][k] -= a[i][k] * tmp;
			}
		}
	}
}
int main(){
	scanf("%d", &n);
	for(int i=1; i<=n; i++){
		int x; scanf("%d",&x);
		if(x == 0 || x == -2){ 
			for(int k=1; k<=6; k++) add(i+k, i, 1.0/6); 
		} 
		else if(x == -1){
			vis[i] = 1;
			for(int k=1; k<=6; k++) add(i+k, i, 1.0/6); 
		} 
		else add(x, i, 1);
	} a[1][n+1] = -1;
	for(int i=1; i<=n; i++){
		for(int e=first[i];e;e=nxt[e]){
			int t = to[e]; a[i][t] = w[e];
		} a[i][i] = -1;
	} gauss(); double ans = 0;
	for(int i=1; i<=n; i++) 
		if(vis[i]) ans += a[i][n+1] / a[i][i];
	printf("%0.2lf",ans); return 0;
}

P3211 [HNOI2011]XOR和路径

异或一般按位考虑

我们令E(x) 位当前位，到n 的异或和位1的概率

E(x)=\sum_{w(x,v)=0}E(v)+\sum_{w(x,v)=1}1-E(v)

高斯消元就可以了

#include<bits/stdc++.h>
#define N 105
#define M 20050
using namespace std;
int first[N], nxt[M], to[M], w[M], tot;
int n, m, du[N], Max;
double a[N][N], ans;
void add(int x, int y,int z){
	nxt[++tot] = first[x], first[x] = tot;
	to[tot] = y, w[tot] = z, du[y]++;
}
void gauss(){
	for(int i=1; i<=n; i++){
		int k = i;
		for(int j=i+1; j<=n; j++)
			if(fabs(a[j][i]) > fabs(a[k][i])) k = i;
		for(int j=1; j<=n+1; j++) swap(a[k][j], a[i][j]);
		double res = a[i][i];
		for(int j=i; j<=n+1; j++) a[i][j] /= res;
		for(int j=1; j<=n; j++){
			if(j == i) continue;
			double tmp = a[j][i];
			for(int k=i; k<=n+1; k++) a[j][k] -= tmp * a[i][k];
		} 
	}
}
int main(){
	scanf("%d%d", &n, &m);
	for(int i=1; i<=m; i++){
		int x, y, z; scanf("%d%d%d", &x, &y, &z);
		if(x == y) add(x, y, z);
		else add(x, y, z), add(y, x, z);
		Max = max(Max, z);
	}
	for(int i=1; i<=Max; i<<=1){
		memset(a, 0, sizeof(a));
		for(int j=1; j<n; j++){
			a[j][j] = du[j];
			for(int e = first[j]; e; e = nxt[e]){
				int t = to[e], v = w[e] & i;
				if(v == 0) a[j][t]--;
				else a[j][t]++, a[j][n+1]++;
			} 
		} a[n][n] = 1; gauss();
		ans += i * a[1][n+1] / a[1][1];
	} printf("%0.3lf", ans); return 0;
}

P2473 [SCOI2008]奖励关

题目要求最优， 这启示我们用DP来解决

f [u][S] 表示选了u个，状态为S的期望

如果可以选i

f(u,S)=\sum_{i=1}^n \frac{1}{n}max(f(u+1, S|(1<<(i-1))+val_i,f(u+1,S))

否则

f(u,s)=\sum_{i=1}^n\frac{1}{n}f(u+1,s)

#include<bits/stdc++.h>
#define N 105
#define M (1<<15)
using namespace std;
double f[N][M], val[N];
int s[N], n, k;
double dfs(int u,int S){
	if(u >= k) return 0;
	if(f[u][S] != -1) return f[u][S];
	double res = 0;
	for(int i=1; i<=n; i++){
		if((s[i] & S) == s[i]) res += max(dfs(u+1, S|(1<<(i-1))) + val[i], dfs(u+1, S));
		else res += dfs(u+1, S);
	}
	return f[u][S] = res / (n*1.0);
}
int main(){
	scanf("%d%d", &k, &n);
	for(int i=1; i<=n; i++){
		scanf("%lf", &val[i]);
		int x; while(1){
			scanf("%d", &x); if(!x) break;
			s[i] |= (1<<(x-1));
		}
	} for(int i=0; i<=k; i++) for(int j=0; j<=(1<<n); j++) f[i][j] = -1; 
	printf("%0.6lf", dfs(0, 0)); return 0;
}

[WOJ3481]Slay the Spire （稍难）

首先得会暴力，我们dfs全排列一下，然后对于当前选出来的数，我们令选i张强化卡， m-i张攻击卡，有个很明显的贪心就是

当 i >= k 时， 选k-1张强化卡，1张攻击卡

当 i < k 时，选 i 张强化卡，k-i张攻击卡

这启示我们先将卡牌按攻击力与强化值从大到小排序， 然后怎么做呢？只能用DP计数了

我们令F(i,j) 表示随机选i个，从i个中选j个强化卡的期望倍数

G(i,j) 表示表示随机选i个，从i个中选j个强化卡的期望攻击力

这样还是不能转移

我们可以枚举最后出现的位置r

F(i,j)=\sum_{r=j}^nf(j,r)*C(n-r, i-j)

其中 f (j,r) 表示选j个， 最后一个在r的期望，因为最后的都在r，所以后面的i-j个只能在n-r个位置中全排列

G(i,j)=\sum_{r=j}^ng(j,r)*C(n-r, i-j)

现在考虑如何处理 f,g， 考虑当前位接到哪个后面

f(i,j)=a[j]*\sum_{r=i-1}^{j-1}f(i-1,r)

对于g， 考虑当前值有多少贡献

g(i,j)=a[j]*C(j-1,i-1)+\sum_{r=i-1}^{j-1}g(i-1,r)

前缀和优化可以O(n^2)， 然后不用处理全部的F， G，要哪些处理哪些

#include<bits/stdc++.h>
#define N 3050
#define Mod 998244353
#define LL long long
using namespace std;
LL f[N][N], g[N][N], c[N][N], Sf[N], Sg[N];
int T, n, m, k, a[N], b[N];
void prework(){
	for(int i=0; i<=N-50; i++){
		c[i][0] = 1;
		for(int j=1; j<=i; j++){
			c[i][j] = (c[i-1][j] + c[i-1][j-1]) % Mod;
		}
	}
}
void Init(){
	memset(f, 0, sizeof(f));
	memset(g, 0, sizeof(g));
	memset(Sf, 0, sizeof(Sf));
	memset(Sg, 0, sizeof(Sg));
}
bool cmp(int a,int b){ return a > b;}
LL F(int a, int b){
	LL ans = 0;
	for(int i=b; i<=n; i++){
		ans = (ans + c[n-i][a-b] * f[b][i] % Mod) % Mod;
	} return ans;
}
LL G(int a,int b){
	LL ans = 0;
	for(int i=b; i<=n; i++){
		ans = (ans + c[n-i][a-b] * g[b][i] % Mod) % Mod;
	} return ans;
}
int main(){
	scanf("%d", &T); prework();
	while(T--){
		scanf("%d%d%d", &n, &m, &k); Init();
		for(int i=1; i<=n; i++) scanf("%d", &a[i]);
		for(int i=1; i<=n; i++) scanf("%d", &b[i]);
		sort(a+1, a+n+1, cmp); sort(b+1, b+n+1, cmp);
		f[0][0] = 1;
		for(int i=1; i<=n; i++) f[1][i] = a[i], g[1][i] = b[i];
		for(int i=2; i<=n; i++){
			for(int j=i; j<=n; j++){
				Sf[i-1] = (Sf[i-1] + f[i-1][j-1]) % Mod;
				f[i][j] = Sf[i-1] * a[j] % Mod;
				Sg[i-1] = (Sg[i-1] + g[i-1][j-1]) % Mod;
				g[i][j] = (Sg[i-1] + (b[j] * c[j-1][i-1]) % Mod) % Mod;
			}
		}
		LL ans = 0;
		for(int i=0; i<=m && i<=n; i++){ // 选i张强化牌 
			if(m - i > n) continue;
			if(i >= k) ans = (ans + F(i, k-1) * G(m-i, 1) % Mod) % Mod;
			else ans = (ans + F(i, i) * G(m-i, k-i) % Mod) % Mod;
		} printf("%lld\n", ans); 
	} return 0;
}

[WOJ3804]Easy

L(x)表示期望长度，E(x) 表示期望价值，分情况转移就可以了

#include<bits/stdc++.h>
#define N 300050
using namespace std;
double L[N], E[N];
int n; char s[N];
int main(){
	scanf("%d%s", &n, s+1); L[n+1] = E[n+1] = 0;
	for(int i=n; i>=1; i--){
		if(s[i] == 'o'){
			L[i] = L[i+1] + 1;
			E[i] = E[i+1] + 2 * L[i+1] + 1;
		}
		if(s[i] == 'x'){
			L[i] = 0; E[i] = E[i+1];
		}
		if(s[i] == '?'){
			L[i] = (L[i+1] + 1) / 2.0;
			E[i] = E[i+1] + (2 * L[i+1] + 1)/ 2.0;
		}
	} printf("%0.4lf", E[1]); return 0;
}

[WOJ3805]OSU

跟上道题差不多，唯一需要注意的是平方的期望不是期望的平方，所以还有维护L^2的期望

#include<bits/stdc++.h>
#define N 100050
using namespace std;
double L[N], E[N], L2[N], p[N]; int n; 
int main(){
	scanf("%d", &n); L[n+1] = E[n+1] = 0;
	for(int i=1; i<=n; i++) scanf("%lf",&p[i]);
	for(int i=n; i>=1; i--){
		L2[i] = p[i] * (L2[i+1] + 2 * L[i+1] + 1);
		E[i] = p[i] * (E[i+1] + 3 * L2[i+1] + 3 * L[i+1] + 1) + (1 - p[i]) * E[i+1];
		L[i] = p[i] * (L[i+1] + 1);
	} printf("%0.1lf", E[1]); return 0;
}

P3232 [HNOI2013]游走

由于经过某条变的概率不好算，而且边太多，我们转换为求每个点的概率

E(x)=\sum \frac{E(t)}{du[t]}

点1与点n有些特殊， 由于"游走"是从点1开始,则计算点1期望时实际期望应该是原期望+1

若有点和n相连,那么在计算期望时是不需要将其算入的,因为到了点n的时候是不会继续"游走"了

#include<bits/stdc++.h>
#define N 505
#define M (N*N*2)
using namespace std;
int first[N], nxt[M], to[M], du[N], tot;
void add(int x,int y){
	nxt[++tot] = first[x], first[x] = tot;
	to[tot] = y, du[y]++;
}
int n, m, x[M], y[M];
double a[N][N], val[N], p[M];
void gauss(){
	for(int i=1; i<=n; i++){
		int k = i;
		for(int j=i+1; j<=n; j++) 
			if(fabs(a[j][i]) > fabs(a[k][i])) k = j;
		for(int j=1; j<=n+1; j++) swap(a[i][j], a[k][j]);
		double res = a[i][i];
		for(int j=i; j<=n+1; j++) a[i][j] /= res;
		for(int j=1; j<=n; j++){
			if(i == j) continue;
			double tmp = a[j][i];
			for(int k=i; k<=n+1; k++) a[j][k] -= tmp * a[i][k];
		}
	}
	for(int i=1; i<=n; i++) val[i] = a[i][n+1] / a[i][i];
}
int main(){
	scanf("%d%d", &n, &m);
	for(int i=1; i<=m; i++){
		scanf("%d%d",&x[i], &y[i]);
		add(x[i], y[i]); add(y[i], x[i]);
	}
	n--; a[1][n+1] = 1;
	for(int i=1; i<=n; i++){ a[i][i] = 1;
		for(int e = first[i]; e; e=nxt[e]){
			int t = to[e]; if(t <= n)
			a[i][t] = -1.0 / du[t]*1.0;
		}
	} gauss();
	for(int i=1; i<=m; i++){
		if(x[i] <= n) p[i] += val[x[i]] / du[x[i]];
		if(y[i] <= n) p[i] += val[y[i]] / du[y[i]];
	} sort(p+1, p+m+1);
	double ans = 0;
	for(int i=1; i<=m; i++){
		ans += p[i] * (m-i+1);
	} printf("%0.3lf", ans); return 0;
}

 

FSYo
关注
专栏目录
概率与期望
LO_XJY_VE的博客
05-23 4861
目录1 > 概率 :( 1 )集合观下的概率( 2 )概率的相对性 ：1.绝对概率 ：2.相对概率 ：( 3 ) 概率的几种类型( 4 ) 基本公式：1.全概率公式：2.贝叶斯公式：3.独立重复实验的伯努利大数定理：2 > 期望 ：( 1 ) 随机变量：( 2 ) 数学期望：( 3 ) 期望的计算：1.根据期望定义式2.期望的线性性质 E[aX+bY]=aE[X]+bE[Y]3.期望的积：4.全期望公式：E( X ) = ∑P( Y = yi )E( X | Y = yi ) =
概率与期望学习心得
BlessingXRY的博客
01-30 1310
修正信息备注： 1.【2018-01-30】创作博文基础 2.【2018-01-30】增加样例2.2 一、基本定义 1.数学期望：在概率论和统计学中，数学期望(mean)（或均值，亦简称期望）是试验中每次可能结果的概率乘以其结果的总和，是最基本的数学特征之一。它反映随机变量平均取值的大小。（百度百科） 二、例题解析 2.1【求期望：转化为n重伯努利实验】 2.2【求期望：递推式移项化
关于概率与期望
weixin_34209851的博客
08-31 201
机器人小 E 是博士的助手, 现在它需要帮助博士收集制造新机器需要的 能量. 小 E 的任务在一个长度为 N 的序列上进行, 初始时刻小 E 在 0 号点, 效率 Q 为 0, 每一次它会向右移动一个位置到达编号加一的点, 并且在这个 瞬间小 E 的效率会变化, 具体地: • 若效率变化以前等于 0, 则 Q 有 x 的概率加一, 1 − x 的概率不变. • 若效率...
【学习笔记】概率与期望
abc0372的博客
07-29 511
基本概念 随机变量：有多种可能的取值的变量 \(P(A)：\)事件\(A\)发生的概率 \(E(X)：\)随机变量X的期望值，\(E(X)=\Sigma[P(X=i)*i]\) 独立事件：互相不影响的事件，满⾜\(P(AB)=P(A)P(B)\) 前提：\(A,B\);两个随机变量是独立的 对于独立事件，我们有\(E(AB)=E(A)E(B)\) 常用公式 （等比数列求和公式+极限法...
[学习笔记]概率与期望
C202044zxy的博客
10-31 292
老师在讲概念时一直在摸鱼，可怜的我就做了几道题。。 跳一跳 一、题目 题目描述 现有一排方块，依次编号为 1…n1\ldots n1…n。 方块 111 上有一个小人，已知当小人在方块 iii 上时，下一秒它会等概率地到方块 iii（即不动），方块 i+1i+1i+1，方块 i+2i+2i+2……方块 nnn 上。 求小人到达方块 nnn 所需要的期望时间（单位：秒）。 输出格式 若答案 an...
高中数学概率期望与方差PPT学习教案.pptx
10-06
高中数学中的概率期望与方差是统计学中的基本概念，主要应用于分析随机事件发生的平均结果和数据波动的程度。在这个PPT学习教案中，主要讲解了以下几个知识点： 1. **离散型随机变量的分布列**：离散型随机变量X的...
深度学习基础8（概率，期望，方差）
FLR的博客
03-26 1446
概率 简单地说，机器学习就是做出预测。 第一个例子：根据照片区分猫和狗 首先，问题的难度可能取决于图像的分辨率。 虽然人类很容易以160×160像素的分辨率识别猫和狗， 但它在40×40像素上变得具有挑战性，而且在10×10像素下几乎是不可能的。 换句话说，我们在很远的距离（从而降低分辨率）区分猫和狗的能力可能会变为猜测。 如果完全肯定图像是一只猫，我们说标签𝑦是"猫"的概率，表示为𝑃(𝑦=“猫”)等于1。 第二个例子：给出一些天气监测数据，预测明天北京下雨的概率。 如果是夏天，下雨的概率是0.5。 在这
统计与概率离散型随机变量的期望方差与正态分布理PPT学习教案.pptx
10-11
离散型随机变量的期望和方差是统计与概率领域中的基本概念，它们用来描述随机变量的平均行为和数据的波动程度。期望，也被称为均值或数学期望，是随机变量所有可能取值与其对应概率乘积的加权平均。在离散型随机变量...
高中数学概率期望与方差PPT课件.pptx
10-10
本PPT课件提供了高中数学概率期望与方差的系统讲解和实践指导，是高中学生学习和掌握这些概念的不错选择。 资源摘要信息续: 在本课件中，学生可以学习到以下知识点： * 离散型随机变量的分布列和性质 * 数学期望...
有关概率和期望问题的研究
02-01
在各类信息学竞赛中（尤其是ACM竞赛中），经常出现一些与概率和期望有关的题目。这类题目需要较高的数学水平和一定的算法技巧，必须经过仔细分析，选择合适的数学模型和算法才能顺利的解决问题。本文就对这类题目的一些常见方法进行了研究。
概率和期望
热门推荐
蒟蒻柴犬首相的博客
11-02 1万+
（在此鸣谢yty提供故事的人物材料）引子概率是一个玄学的东西 。有个认知方面的误区就是，各位oier在小学和初中的时候接触到的概率都是一个叫做“古典概率”的东西，这是很只是概率这一个大旗帜下的一个小喽啰，真正的概率水深着呢。先讲个故事吧（about Pascal & Fermat）by《数学一本通》yty是hh的基友，有一天，yty跟hh说，他对赌博饥渴难耐，hh很无奈，只能陪yty进行了一场赌博。
【总结】概率与期望
氧化钠的博客
05-31 2523
前言 作为NOIP级的知识点，概率与期望算是比较困难的类型了。 但其实也不是无法解决的难题。 本文主要通过作者本人的刷题经历，对概率期望类题目进行总结。 概率 51Nod1639绑鞋带： 有n根鞋带混在一起，每根鞋带有两个鞋带头。现在重复n次以下操作：随机抽出两个鞋带头，把它们绑在一起。求最终只形成一个环的概率？ 依次考虑每一步操作，现在已经选出来了一个头，它必须和非它所在的链的另一...
数学知识——概率与数学期望
最新发布
qq_57150526的博客
03-16 1274
关于概率论的一些讲解
学习期望与看法
weixin_34409703的博客
03-20 302
在学习这门课之前，对这门课的认识是，一门很理论的课，毕竟在上学期期末时候看到一个有这门课学习的同学拿着一本厚厚的复印小手册在背。但至少在上这门课到现在，我还没有觉得这是一门纯理论的课程，如果理论没有和实际操作结合起来是很枯燥的一件事情。软件工程从老师说的可以看出来是方便人们管理软件的东西，就算不是这个软件的开发者的程序员也可以管理和理解这些软件。学习这门课，我主要的目的是想学好python，做一...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FSYo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值