想必对于概率，大家都是挺熟悉的，从小学就开始学习
概率定义
- 概率 ： 我们可以简单的理解为 事情发生的可能性
- 样本空间：事情所在的全集集合
我们也有如下性质，就是对于样本空间的一些事件来说的，我们假设样本空间的事件为 (A) ，设 (P(A)) 代表的是事件 (A) 概率，则有
- (0leq P(A)leq 1)
- (sum p(A) = 1)
- 设 (A_1,A_2…) 是两两独立的事件，那么 (P(A_1cup A_2…) = P(A_1) + P(A_2) + …)
一些性质
- (P(phi) = 0)
- 如果 (Asubset B) , 则有 (P(B-A) = P(B) - P(A)) ，更一般的则有：(P(B-A)=P(B)-P(AB))
- (P(Acup B) = P(A) +P(B) - P(AB))
条件概率
定义及其计算式
定义 ：在已知 (B) 事件发生时事件 (A) 发生的概率为 (P(A｜B) = frac{P(AB)}{P(B)})
- 乘法法则： (P(AB) = P(A｜B) ast P(B))
条件概率性质
- $P(phi｜A) = 0 $
- 若 (B_1,B_2…B_n) 互不相容，则 (P(U_{i=1}^{n}B_i｜A) = sum_{i=1}^{n}P(B_i｜A))
- (P(ar{B}｜A) = 1 - P(B｜A))
- (P(Bcup C｜A) = P(B｜A) + P(C｜A) - P(BC｜A))
期望定义
为什么叫期望呢，就是你在一个样本空间内选择事件，然后每一个事件都有一个权值(扔色子) ，不同的事件对应着不同的权值，然后我们肯定不能只拿小的，我们不乐意（你乐意我不乐意），我们也不可能只拿大的，显然这是不可能(欧皇也没这么欧)，所以我们期望能够获得多少的权值。这就叫做期望。
计算式和小性质
- (E[f(x)] = sum f(x)P(X == x))
- 还有一个能够简化计算的，就是 和的期望 等于 期望的和。
- (E[c_1 X_1 + c_2X_2+…] = c_1 E(X_1) + c_2E(x_2)+…)
- 如果 (X_1,X_2) 独立，则有 (E(X_1X_2)=E(X_1)E(X_2))
贝叶斯公式
设 (B_1,B_2…B_n) 为样本空间的划分 ， 则有
独立事件
如果 (P(A)P(B) = P(AB)) , 那么就有 (AB) 事件独立
我们可以认为， (AB) 事件无交集
- 其中不可能事件，必然事件和任何事件都是相互独立的。
(AB) 独立的 (P(B ｜A) = P(B))
三门问题
【description】:
现在有 (3) 扇门，门后面有 (3) 个物件，可能是一块石头，也可能是一块黄金，现在你打开了一扇门，然后主办方又打开了一扇门，门后面是一块石头，现在你是选择坚持你选择的门，还是选择换一扇门。
【solution】:
换一扇门 ： 首先我们要知道一个内幕，那就是，主办方当然知道哪一扇门后面有黄金，但是主办方是不会将黄金翻开的，也就说，主办方只会翻开带有石头的。那么我们显然是有几种可能
我们从左到右分别第 (1,2,3) 扇门 ，其中 (1) 表示黄金，(0) 表示石头
我们假设 (1) 号门中有黄金，其中 (2,3) 有的只是石头。然后我们开始模拟你选择的过程：
我们运气很好，直接翻开了 (1) 号门 ，那么主办方显然随便翻开了 (2,3) 门即可。
我们运气不好，选择翻开了 (2) 号门，那么这个时候，主办方只能够选择 (3) 号门，
我们运气不好，选择翻开了 (3) 号门，那么这个时候，主办方只能够选择 (2) 号门。
最后这个游戏随机放置 ，我们怎么知道哪一号门有黄金，然后我们只知道，我们选择换门的话，我们能够得到黄金的概率是 (frac{2}{3}) ，但是不换门的概率能够得到黄金的概率却只有 (frac{1}{3})。所以我们呢选择换一扇门 。
三门问题的别样
这个说是三门问题的别样，但是却和三门问题是没什么联系。
【description】:
现在在小明和小泽面前有三瓶药，其中两瓶是毒药，每个人必须喝一瓶。 但是小泽手速很快，抢了一瓶，立马干了，死了，然后小聪很疑惑，他到底是喝手里这瓶还是另外的一瓶。
【solution】:
换不换一样
我们发现这货很三门问题很像，有一个质的区别，就是三门问题中的主办方知道哪一个黄金，但是他选择的是只能是石头，但这个题不一样，小泽也想活下去，他可能选择了不是毒药的那瓶，但是主办方是绝对不会选择的。然后就一样了。
概率的一个问题
准确的说，是颠覆了我对于概率的认知。
【description】：
小胡站在原点，手里拿着两枚硬币。抛第一枚硬币正面向上的概率为 (p) ，第二枚正面向上的概率为 (q) 。
- 现在小胡开始抛第一枚硬币，每次抛到反面小胡就向 (x) 轴正方向走一步，直到抛到正面。
- 接下来小胡继续抛第一枚硬币，每次抛到反面小胡就向 (y) 轴正方向走一步，直到抛到正面。
- 现在小胡想回来了，于是他开始抛第二枚硬币，如果小胡抛到正面小胡就向 (x) 轴的负方向走一步，否则小胡就向 (y) 轴的负方向走一步。
- 现在他在往回走的时候经过原点的概率是多少？
【solution】:
可能分开后有利于理解题意
我可以先告诉你答案为无限无限无限近似于 (p)（我们可以认为其就是 (p)） ,惊讶吗？我当时被颠覆了 。
我们发现在一开始的两步，我们是可能走遍整个第一象限的，所以我们枚举第一象限的所有点。我们就有到达 ((x,y)) 这个点的概率为 ((1-p)^x imes p imes (1-p)^y imes p) 这么个玩意。同时也就是对应上面的过程 (1,2) , 那么我们考虑一下过程 (3) ,那么我们让 ((x,y)) 回到 ((0,0)) 那么我们需要抛 (x) 次正面， (y) 次反面 ， 那么也就是 (q^x imes (1-q)^y)
但是我们这里有一个顺序问题，就是 (x) 次正面，你怎么抛，那么就有 (C_{x+y}^{x}) 的可能，那么我们过程 (3) 的概率就是 (q^x imes (1-q)^y imes C_{x+y}^{x}) .
那么我们把过程 (1,2,3) 综合起来，就是 ((1-p)^x imes p imes (1-p)^y imes p imes q^x imes (1-q)^{y} imes C_{x+y}^{x})
由于这个 ( imes) 长有点像 (x) ,所以我们用 (ast) 代替一下
那么答案就是
我们是傻逼，考虑暴力
我们考虑一下换元 我们令 (t = x + y) , 然后我们枚举 (t,x) , 我们就能得到
我们有一些项和 (x) 无关，我们将其移到前面来。
我们发现后面其实是二项式定理 。
我们发现 (p^2) 和 (t) 没关系，提到前面来，就能够得到。
涉及一个等比数列，后面再说一下，并不打算给出证明，不会
其中 ((1-p)^{infty}) 很显然是无限近似于 (0) 的，然后就能够得到 (p^2 ast frac{1}{p} = p)
神奇。
等比数列求和：
因为上面是 ((1-p)^0,(1-p)^1,(1-p)^2) 之间比值为 ((1-p)) ，所以是一个等比数列。
因为这里表示太麻烦了，我们用 (a , 1,n) 表示
(sum_{i = 0}^{n} a^i = frac{1-a^{n+1}}{1-a})
刷矩形
【(description)】:有一个 (n imes m) 格子的矩形，每次随机刷掉一个矩形，问 (k) 次之后期望刷掉多少个格子， (n,mleq 10^3 , k leq 100)
【(solution)】: 我们有期望的和 = 和的期望，我们就可以将这个问题转化成求解每一个格子的期望，我们发现刷掉的贡献为 (1) , 没有刷掉的贡献为 (0) , 所以，整个矩形的格子期望值就得到每一个格子的概率之和。
/*
By : Zmonarch
知识点
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#include <set>
#define int long long
#define qwq register
#define inl inline
#define inf 2147483647
const int kmaxn = 1e6 + 10 ;
const int kmod = 998244353 ;
inline int read() {
int x = 0 , f = 1 ; char ch = getchar() ;
while(!isdigit(ch)) {if(ch == '-') f = - 1 ; ch = getchar() ;}
while( isdigit(ch)) {x = x * 10 + ch - '0' ; ch = getchar() ;}
return x * f ;
}
int n , m ;
double quick(double a , int b) {
double ret = 1.0 ;
while(b)
{
if(b & 1) ret = ret * a ;
a = a * a ;
b >>= 1 ;
}
return ret * 1.0 ;
}
double P(double a , double b ) {
double A = 4.0 * a * b * (n * 1.0 - a + 1.0) * (m * 1.0 - b + 1.0) ;
double B = 2.0 * (a * (n * 1.0 - a + 1.0) + b * (m * 1.0 - b + 1.0)) ;
double C = 1.0 ;
return (double)(A - B + C ) / (n * 1.0 * m * 1.0 * n * 1.0 * m) ;
}
signed main() {
double ret = 0.0 ;
int k = read() ; n = read() , m = read() ;
for(qwq double i = 1.0 ; i <= n * 1.0 ; i += 1.0)
for(qwq double j = 1.0 ; j <= m * 1.0 ; j += 1.0)
ret += 1.0 - quick((1.0 - P(i , j)) , k ) ;
//printf("%lf" , ret) ;
printf("%.0lf
" , ret ) ;
return 0 ;
}
神奇的矩形
【(description)】给出三个行数和列数均为(N)的矩阵(A,B,C)，判断(A imes B=C)是否成立。 (nleq 10^3)
【(Solution)】: 我们随机一个 (n imes 1) 的矩阵 (k) , 然后让 (A imes B imes k , C imes k) 看一下左右边是否相等，其中矩阵虽然不满足交换律，但是它满足结合律，我们可以先让 (b imes k) ,然后再和 (A) 想乘，所以复杂度是 (O(n^2)) 的，可过。
【(Code)】:
/*
By : Zmonarch
知识点
只要是正义的一方，无论手段多么卑鄙都可以被原谅
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#include <set>
#include <cstdlib>
#define int long long
#define qwq register
#define inl inline
#define inf 2147483647
const int kmaxn = 1e6 + 10 ;
const int kmod = 19260817 ;
inline int read() {
int x = 0 , f = 1 ; char ch = getchar() ;
while(!isdigit(ch)) {if(ch == '-') f = - 1 ; ch = getchar() ;}
while( isdigit(ch)) {x = x * 10 + ch - '0' ; ch = getchar() ;}
return x * f ;
}
int n ;
struct Matrix{
int n , m ; int a[1001][1001] ;
Matrix() {n = m = 0 ; memset(a , 0 , sizeof(a));}
};
Matrix operator * (const Matrix &m1 , const Matrix &m2) {
Matrix m3 ; m3.n = m1.n ; m3.m = m2.m ;
for(qwq int i = 1 ; i <= m3.n ; i++)
for(qwq int j = 1 ; j <= m3.m ; j++)
for(qwq int k = 1 ; k <= m1.m ; k++)
m3.a[i][j] = (m3.a[i][j] + m1.a[i][k] * m2.a[k][j]) % kmod ;
return m3 ;
}
bool operator == (const Matrix &m1 , const Matrix &m2) {
if(m1.m != m2.m || m1.n != m2.n) return 0 ;
for(qwq int i = 1 ; i <= m1.n ; i++)
for(qwq int j = 1 ; j <= m1.m ; j++)
if(m1.a[i][j] != m2.a[i][j]) return 0 ;
return 1 ;
}
signed main() {
srand(kmod) ;
while(scanf("%lld" , &n) != EOF)
{
Matrix a , b , c , t ; t.n = n ; t.m = 1 ;
a.n = b.n = c.n = a.m = b.m = c.m = n ;
for(qwq int i = 1 ; i <= n; i++)
for(qwq int j = 1 ; j <= n ; j++)
a.a[i][j] = read() % kmod ;
for(qwq int i = 1 ; i <= n; i++)
for(qwq int j = 1 ; j <= n ; j++)
b.a[i][j] = read() % kmod ;
for(qwq int i = 1 ; i <= n; i++)
for(qwq int j = 1 ; j <= n ; j++)
c.a[i][j] = read() % kmod ;
int T = 15 ; bool flag = 0 ;
while(T--)
{
for(qwq int i = 1 ; i <= n ; i++) t.a[i][1] = rand() % kmod ;
if(!(a * (b * t) == c * t)) {flag = 1 ; break ;}
}
if(flag) printf("No
") ;
else printf("Yes
") ;
}
return 0 ;
}
OSU！
【description】:
osu是一款群众喜闻乐见的休闲软件。
我们可以把osu的规则简化与改编成以下的样子:
一共有(n)次操作，每次操作只有成功与失败之分，成功对应(1)，失败对应(0)，(n)次操作对应为(1)个长度为(n)的(01)串。在这个串中连续的$ X$个(1)可以贡献(X^3)的分数，这(X)个(1)不能被其他连续的(1)所包含。
现在给出(n)，以及每个操作的成功率，请你输出期望分数，输出四舍五入后保留(1)位小数。
【solution】
我们先来考虑贡献的不是 (x^3) 而是 (x) 的情况，那么就是其中有多少个 (1) 就好。
这里直接给出正解： 我们设 (f_i) 表示前 (i) 个进程完成后末尾有多少个 (1) 的期望，那么我们在推导 (f_{i+1}) 的时候，$f_{i+1} = (f_{i} + 1 ) * p_{i+1} + 0 * (1 - p_{i+1}) $
然后我们考虑一下贡献为 (x^2) 的时候 ， ((x+1)^2 = x^2 + 2x + 1 = g_{i-1}+2f_{i-1}+1) 概率同样为 (p_{i}) 我们照猫画虎，就能够得到考虑贡献 (x^3) 也是一样的。但是这里注意的是，这里不再是末尾为多少个 (1) 的期望值，而是整体的期望值。
【Code】
/*
By : Zmonarch
知识点
只要是正义的一方，无论手段多么卑鄙都可以被原谅
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#include <set>
#define int long long
#define qwq register
#define inl inline
#define inf 2147483647
const int kmaxn = 1e6 + 10 ;
const int kmod = 998244353 ;
inline int read() {
int x = 0 , f = 1 ; char ch = getchar() ;
while(!isdigit(ch)) {if(ch == '-') f = - 1 ; ch = getchar() ;}
while( isdigit(ch)) {x = x * 10 + ch - '0' ; ch = getchar() ;}
return x * f ;
}
int n ;
double f[kmaxn] , g[kmaxn] , h[kmaxn] , p[kmaxn] ;
signed main() {
n = read() ;
for(qwq int i = 1 ; i <= n ; i++) std::cin >> p[i] ;
for(qwq int i = 1 ; i <= n ; i++)
{
f[i] = (f[i - 1] + 1) * p[i] ;
g[i] = (g[i - 1] + 2 * f[i - 1] + 1) * p[i] ;
h[i] = h[i - 1] + (3 * g[i - 1] + 3 * f[i - 1] + 1) * p[i] ;
}
printf("%.1lf" , h[n]) ;
return 0 ;
}