kuangbin 带你飞 概率期望

最新推荐文章于 2024-06-14 20:43:21 发布
最新推荐文章于 2024-06-14 20:43:21 发布
阅读量160 收藏
点赞数 1
文章标签： 人工智能 数据结构与算法
原文链接：http://www.cnblogs.com/Commence/p/5316959.html
版权

正推不行就逆推！

　　经典问题：生日悖论

　　换成其互斥事件：m个人， 每个人生日都不相同的概率 ≤ 0.5 时最小人数。

　　这就是邮票收集问题的变形：每个邮票至少出现一次的概率 小于等于 0.5

 

邮票收集问题资料：https://en.wikipedia.org/wiki/Coupon_collector%27s_problem

我们现在面对的是一个n面的骰子， 骰子的每面都是随机出现的， 求问将所有面都被看完所期望的投掷次数（假设只看最上面那一面）

　　那么， 问题的解就是：

　　　　　　　　　　　　H[n] = (1 + 1/2 + 1/3 + 1/4 + ... + 1/n),  这就是调和级数的前n项。

　　　　　　　　　　　　这个值近似等于欧拉常数约为：0.57721566490153286060651209。（不过这是一个当n接近无穷时的近似值， 并不能代替具体的H[n]， 比如当 n = 1 || 2时）

　　而所求的是期望的权值， 根据期望的线性性质E(XY) = E(X)*E(Y) 

　　所以， 总的权值期望就等价于 每次的权值期望 * 次数的期望。

　　n个面， 每个面至少出现一次的期望次数是：E(x) = n * H[n]，那么， 某个指定的面至少出现一次的期望次数就是E(z) = E(x)/n = H[n]。

 

Light Oj 1027 A Dangerous Maze

题意 ： 在n个门前选择一扇门出去， 然后如果第i扇门的 Xi值是正的话，你会花费Xi时间后出去 ， 如果Xi是负数的话你会花费-Xi时间后回到老地方，并且忘记了刚才的选择， 选择一扇门的概率是等概的。求出去的期望。

思路 ：定义一次选择选择到Xi是整数的概率为P1,选择到负数的概率是P2，然后选择了正数后平均在T1时间后出去， 选择了负数后平均在T2时间后回到原地。接着设出去的期望是Y，那么可以写出一个式子 ：Y = P1 * T1 + P2 * (T2 + Y)， 这样的话问题就得到了解决， 最后整理下式子就是 ： Y = 正数个数的倒数 * ∑abs(Xi) ；

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
LL gcd(LL a, LL b) {return a % b == 0 ? b : gcd(b, a % b);}
LL tot,sum;

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        tot = 0;
        sum = 0;
        int N;
        scanf("%d",&N);
        for (int i = 1 ; i <= N ; i++) {
            int x;
            scanf("%d",&x);
            if (x > 0) tot++;
            sum += abs(x);
        }
        if (tot == 0) printf("Case %d: inf\n",kase++);
        else {
            LL g = gcd(sum,tot);
            printf("Case %d: %lld/%lld\n",kase++,sum / g,tot / g);
        }
    }
    return 0;
}
View Code

LightOj 1030 Discovering Gold

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
LL gcd(LL a, LL b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
double dp[MAXN],val[MAXN];
int main() {
    int T,kase = 1;
    cin >> T;
    while (T--) {
        memset(dp,0,sizeof(dp));
        int N;
        cin >> N;
        for (int i = 1 ; i <= N ; i++) cin >> val[i];
        dp[N] = val[N];
        for (int i = N - 1  ; i >= 1 ; i--) {
            dp[i] = val[i];
            double cnt = min(6.0,1.0 * (N - i));
            for (int j = 1 ; j <= cnt ; j++)
                dp[i] += dp[i + j] * 1.0 / cnt;
        }
        printf("Case %d: %.8lf\n",kase++,dp[1]);
    }
    return 0;
}
View Code

LightOj 1038 Race to 1 Again

比较简单枚举因子就可以了

dp[x] = (dp[fac1] + 1) / cnt + (dp[fac2] +1）/ cnt + (dp[x] + 1) / cnt

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 100010;
vector<int>res[MAXN];
double dp[MAXN];

void init() {
    for (int i = 0 ; i < MAXN ; i++) res[i].clear();
    for (int i = 1 ; i < MAXN ; i++) {
        for (int j = i ; j < MAXN ; j += i)
            res[j].push_back(i);
    }
}

double calcu(int x) {
    if (x == 1) return 0.0;
    else if (dp[x] >= 0) return dp[x];
    int tot = res[x].size();
    double ans = 1.0 * tot;
    for (int i = 0 ; i < tot - 1; i++) {
        ans += calcu(res[x][i]);
    }
    return dp[x] = ans / (tot - 1.0);
}

int main() {
    init();
    memset(dp,-1,sizeof(dp));
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        int N;
        scanf("%d",&N);
        double ret = calcu(N); 
        printf("Case %d: %.8lf\n",kase++,ret);
    }
    return 0;
}
View Code

LightOj 1079 Just another Robbery

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
const double INF = 1e10;
int N,M;
double P;
struct node {
    double p;
    int val;
}src[MAXN];
double dp[MAXN][MAXN * MAXN];

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        scanf("%lf%d",&P,&N);
        for (int i = 1 ; i <= N ; i++) scanf("%d%lf",&src[i].val,&src[i].p);
        for (int i = 0 ; i < MAXN ; i++)
            for (int j = 0 ; j < MAXN * MAXN ; j++) dp[i][j] = INF;
        dp[0][0] = 0;
        for (int i = 1 ; i <= N ; i++) {
            for (int j = 0 ; j < MAXN * MAXN ; j++) {
                dp[i][j] = min(dp[i - 1][j],dp[i][j]);
                if (j >= src[i].val && dp[i - 1][j - src[i].val] < INF) {
                    dp[i][j] = min(dp[i][j],dp[i - 1][j - src[i].val] + (1 - dp[i - 1][j - src[i].val]) * src[i].p);
                    //printf("dp[%d][%d] = %lf\n",i,j,dp[i][j]);
                }
            }
        }
        int ret = 0;
        for (int i = MAXN * MAXN - 1 ; i >= 0 ; i--) {
            if (dp[N][i] <= P) {
                printf("Case %d: %d\n",kase++,i);
                break;
            }
        }
    }
    return 0;
}
View Code

LightOj 1104 Birthday Paradox

题意：

　　若一年有n天， 问至少需要多少个人才能满足其中两个人生日相同的概率大于等于0.5？

 

思路：

　　经典问题：生日悖论

　　换成其互斥事件：m个人， 每个人生日都不相同的概率 ≤ 0.5 时最小人数。

　　这就是邮票收集问题的变形：每个邮票至少出现一次的概率 小于等于 0.5

　　等价于：

　　　　　　找到最小的n， 使得：H[n] = (n / n * (n - 1) / n * (n - 2) / n * ... * (n - i) / n) <= 0.5

就是求所有人生日都不同的概率小于等于0.5(那么至少两个人同一天就是大于等于0,5);

加入一年365天.那么10个人全都不同天生日的概率就是

366/366 * 365/366 * 364/366 .... * 356/366;

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

int n;
int main() {
    int t;
    int cas = 1;
    scanf("%d",&t);
    while(t--) {
        scanf("%d",&n);
        double res = 1;
        int i;
        for(i = n - 1; i >= 0; i--) {
            double tmp = i;
            res *= (tmp / n);
            if(res <= 0.5)
                break;
        }
        printf("Case %d: %d\n",cas++, n - i);
    }
}
View Code

LightOj 1151 Snakes and Ladders

复制一波题解：

dp[i] 表示 在格子i时,结束游戏需要抛掷骰子的次数 
当i处有snake或者ladders时 
dp[i]=dp[go[i]] 
否则 
dp[i]=dp[a1]+dp[a2]+...+dp[an]+6cnt 
因为题目中的一句话,如果抛骰子然后出界的话,需要重新再抛掷,所以转移到的位置个数不是6个,但是代价一定是6个(除a1->an以外的点被忽略掉,但是骰子还是抛掷了,所以次数还是要加上去) 
发现方程中存在环,所以用高斯消元来解方程

必然存在环的。由于传送的特殊形式

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
const double eps = 1e-8;
int pos[MAXN];

struct Matrix {
    int equ,var;
    double mat[MAXN][MAXN];
    double x[MAXN];
    
    void build() {
        memset(mat,0,sizeof(mat));
        memset(x,0,sizeof(x));
        mat[100][100] = 1; x[100] = 0;
        for (int i = 1 ; i < 100 ; i++) {
             if (pos[i] == i) {
                 int cnt = 0;
                 for (int j = 1 ; j <= 6 ; j++) {
                     if (i + j <= 100) {
                         cnt++;
                         mat[i][i + j] = -1;
                     }
                 }
                 mat[i][i] = 1.0 * cnt;
                 x[i] = 6.0;
             }
             else {
                 x[i] = 0;
                 mat[i][i] = 1;
                 mat[i][pos[i]] = -1;
             }
        }
        equ = var = 100;
    }
    
    int gauss() {
        int i,j,k,col,max_r;
        for (k = 0 ,col = 0 ; k < equ && col < var ; k++,col++) {
            max_r = k;
            for (i = k + 1 ; i < equ ; i++)     if (fabs(mat[i][col]) > fabs(mat[max_r][col])) max_r = i;
            if (fabs(mat[max_r][col]) < eps) continue;
            if (k != max_r) {
                for (j = col ; j < var ; j++) swap(mat[k][j],mat[max_r][j]);
                swap(x[k],x[max_r]);
            }
            x[k] /= mat[k][col];
            for (j = col + 1 ; j < var ; j++) mat[k][j] /= mat[k][col];
            mat[k][col] = 1;
            for (int i = 0 ; i < equ ; i++) {
                if (i != k) {
                    x[i] -= x[k] * mat[i][k];
                    for (j = col + 1 ; j < var ; j++) mat[i][j] -= mat[k][j] * mat[i][col];
                    mat[i][col] = 0;
                }
            }
        }
        return 1;
    }
    
}slover;

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        for (int i = 1 ; i <= 100 ; i++) pos[i] = i;
        int N;
        scanf("%d",&N);
        for (int i = 1 ; i <= N ; i++) {
            int u,v;
            scanf("%d%d",&u,&v);
            pos[u] = v;
        }
        slover.build();
        slover.gauss();
        printf("Case %d: %.12lf\n",kase++,slover.x[1]);
    }
    return 0;
}
View Code

LightOj 1248 Dice (III)

思路：设dp[i]为已经扔出了i个不同面值，还要扔dp[i]次才能扔出n个不同面的期望次数，显然dp[n] = 0，要求dp[0]

            则dp[i] = 1+ i/n * dp[i] + (n-i)/n * dp[i+1]，本来要扔的一次加上各个状态转移的期望值

=>dp[i] = n / (n-i) + dp[i+1]

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 100010;
const double eps = 1e-8;
double dp[MAXN];
int main() {
    int kase = 1,T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        dp[0] = 0;
        for (int i = 0 ; i < n ; i++) 
            dp[i + 1] = dp[i] + 1.0 * n / (double)(n - i);
        printf("Case %d: %.8lf\n",kase++,dp[n]);
    }
    return 0;
}
View Code

LightOj 1265 Island of Survival

在孤岛生存， 孤岛上有t头老虎，d头鹿， 每天会出现随机出现两只生物（包括你自己）， 如果出现了一只老虎，那么你将被吃掉， 如果两只老虎， 则两只老虎会同归于尽，其他情况你都将生存下来。

　　当孤岛上没有老虎时， 就视为你生存成功。

　　问你生存成功的最大概率。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 1010;
double dp[MAXN][MAXN];
int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        int t,d;
        scanf("%d%d",&t,&d);
        for (int i = 0 ; i <= t ; i++) 
            for (int j = 0 ; j <= d ; j++) dp[i][j] = 0.0;
        for (int i = 0 ; i <= d ; i++) dp[0][i] = 1.0;
        for (int i = 1 ; i <= t ; i++) {
            for (int j = 0 ; j <= d ; j++) {
                double r1 = 0,r2 = 0;
                int tot = i + j + 1;
                if (i >= 2)  r1 += dp[i - 2][j] * (double)(i * i - i) / (double)(tot * tot - tot);
                if (j >= 1)  r1 += dp[i][j - 1] * (double)(2 * i * j) / (double)(tot * tot - tot);
                double p = 0.0;
                if (j >= 2) p = (double)(j * j - j) / (double)(tot * tot - tot);
                if (j >= 1) {
                    r2 = r1;
                    r2 += dp[i][j - 1] * (double)(j * 2) / (double)(tot * tot - tot);
                    r2 /= (1 - p);
                }
                r1 /= (1 - p - (double)(j * 2) / (double)(tot * tot - tot));
                dp[i][j] = max(r1,r2);
            }
        }
        printf("Case %d: %.12f\n", kase++, dp[t][d]);
    }
    return 0;
}
View Code

LightOj 1274 Beating the Dataset

给一个文档， 这个文档由yes 、no 组成， 共有s个byte， 共有n个yes、no。

　　　　假设yes的个数为yes_num, no的个数为no_num。

　　　　将这n个数进行排列， 对于每个排列， 将其右移一个结果， 并在最左端补上yes， 再将其与原排列进行对比， 看有多少个不同的。

　　　　计算所有排列中 不同结果的平均次数。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 5010;
int N,S;
double dp[2][MAXN][2];

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        scanf("%d%d",&N,&S);
        int right = S - 2 * N;
        int wa = 3 * N - S;
        memset(dp,0,sizeof(dp));
        int cur = 0;
        for (int i = 1 ; i <= N ; i++) {
            int nxt = cur ^ 1;
            for (int j = 0 ; j <= min(right,i) ; j++) {
                double p1 = (double)j / i;
                double p2 = 1.0 - p1;
                if (j >= 1) {
                    dp[nxt][j][1] = (dp[cur][j][0] + 1.0) * p2 + dp[cur][j - 1][1] * p1;
                    dp[nxt][j][0] = (dp[cur][j - 1][1] + 1.0) * p1 + dp[cur][j][0] * p2;
                }
                else {
                    dp[nxt][j][1] = (dp[cur][j][0] + 1 )* p2;
                    dp[nxt][j][0] = dp[cur][j][0] * p1;
                }
            }
            cur = nxt;
        }
        printf("Case %d: %.8lf\n",kase++,dp[cur][right][1]);
    }
    return 0;
}
View Code

　给一个X * Y * Z 的立方体， 每个单位立方体内都有一盏灯， 初始状态是灭的， 你每次操作如下：

　　1）选择一个点(x1, y1, z1)

　　     再选择一个点（x2, y2, z2）

　　     将这两个点所形成的立方体内所有的灯全部转换状态（灭的变亮的， 亮的变灭的）

　　问， K次操作后， 亮着的灯的期望数目。

三维坐标系， 每个维度都是相互独立的， 所以可以分开计算再相乘。

　　考虑x轴， 对于每个点， 被选中的概率是多少：假设这个点左边有a个点，右边有b个点，

　　那么这个点不被选中的概率是p = 1.0 - ((x - 1) * (x - 1) - (a * a + b * b)) / x * x。

　　则，这个点在K次操作后被点亮的期望为：E = sigma C(k, i) * p * (1 - p) ^ (k - i)，i为奇数， 因为i为偶数时灯是灭的。

　　这是二项展开式（p + (1 - p)） ^ k 的所有奇数项。

　　因此， E = ((p + (1 - p)) ^ k - (-p + (1 - p)) ^ k) / 2, 蓝色部分将所有的奇数项变成了负数， 偶数项不变， 相减后则成了两倍的奇数项之和。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
int X,Y,Z,K;
double calcu(int x,int n) {
    return 1.0 - ((x - 1) * (x - 1) * 1.0 + (n - x) * (n - x) * 1.0) * 1.0 / (n * n);
}

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        double ans = 0.0;
        scanf("%d%d%d%d",&X,&Y,&Z,&K);
        for (int i = 1 ; i <= X ; i++) {
            for (int j = 1 ; j <= Y ; j++) {
                for (int k = 1 ; k <= Z ; k++)  {
                    double p = calcu(i,X) * calcu(j,Y) * calcu(k,Z);
                    ans += (1.0 - pow(1 - 2.0 * p,K)) / 2.0;
                }
            }
        }
        printf("Case %d: %.8lf\n",kase++,ans);
    }
    return 0;
}
View Code

LightOj 1287 Where to Run

题意：

　　有n个街口和m条街道， 你后边跟着警察，你需要进行大逃亡（又是大爱的抢银行啊），在每个街口你都有≥1个选择， 

　　1）停留在原地5分钟。

　　2）如果这个街口可以到xi这个街口， 并且， 通过xi可以遍历完所有未走过的街口，那么就加入选择。

　　每个选择都是等概率的。

　　求警察抓住你所用时间的期望， 即你无路可走时的时间期望。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
int N,M;
const double INF = 1e14;
double G[30][30];
double dp[16][1 << 16];
bool vis[16][1 << 16];

bool calcu(int u,int sta) {
    if (sta == (1 << N) - 1) {
        dp[u][sta] = 0;
        return true;
    }
    if (vis[u][sta]) return dp[u][sta] > 0;
    vis[u][sta] = true;
    dp[u][sta] = 5;
    int tot = 0;
    for (int i = 1 ; i <= N ; i++) {
        if( ((sta & (1 << i)) == 0) && G[u][i] < INF && calcu(i,sta | (1 << i)) ) {
            int nxtsta =  sta | (1 << i);
            tot++;
            dp[u][sta] += G[u][i] + dp[i][sta | (1 << i)];
        }
    }
    if (tot == 0) {
        dp[u][sta] = 0;
        return false;
    }
    dp[u][sta] /= (double)tot;
    return true;
}

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        memset(dp,-1,sizeof(dp));
        memset(vis,false,sizeof(vis));
        for (int i = 0 ; i < 20 ; i++) for (int j = 0 ; j < 20 ; j++) G[i][j] = INF;
        scanf("%d%d",&N,&M);
        for (int i = 0 ; i < M ; i++) {
            int u,v; double w;
            scanf("%d%d%lf",&u,&v,&w);
            G[u][v] = G[v][u] = w;
        }
        calcu(0,1);
        printf("Case %d: %.8lf\n",kase++,dp[0][1]);
    }
    return 0;
}
View Code

LightOJ 1317 

　有N个人， M个篮框， 每个人投进球的概率是P。

　　问每个人投K次后， 进球数的期望。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
double ans,p;
int C[20][20];
int N,K;

double calcu(int num) {
    double ret = 1.0;
    for (int i = 1 ; i <= num ; i++) ret *= p;
    for (int i = 1 ; i <= N - num ; i++) ret *= (1 - p);
    return ret * num * C[N][num];
}

int main() {
    int T,kase = 1;
    C[0][0] = 1;
    C[1][0] = C[1][1] = 1;
    for (int i = 2 ; i < 20 ; i++) {
        C[i][0] = C[i][i] = 1;
        for (int j = 1 ; j < i ; j++)
            C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
    }
    //printf("%d\n",C[8][3]);
    scanf("%d",&T);
    while (T--) {
        scanf("%d%*d%d%lf",&N,&K,&p);
        double ret = 0.0;
        for (int i = 0 ; i <= N ; i++)
            ret += calcu(i);
        printf("Case %d: %.8lf\n",kase++,ret * K);
    }
    return 0;
}
View Code

LightOj 1321 Sending Packets

题意：

　　给一个数据大小为S的数据包， 每一次发送需要K秒（单向），现在要从节点0 发送到节点 n-1。

　　其中有n - 1条路径， 每条路径都有一个传输成功率。

　　问传输成功所需最小时间的期望。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
const int MAXN = 110;
double dp[MAXN][MAXN];
int N,M,S,K;

void calcu(int kase) {
   // memset(dp,0,sizeof(dp));
    for (int i = 0 ; i <= N ; i++) dp[i][i] = 1;
    for (int k = 0 ; k < N ; k++) {
        for (int i = 0 ; i < N ; i++) {
            for (int j = 0 ; j < N ; j++)
                dp[i][j] = max(dp[i][j],dp[i][k] * dp[k][j]);
        }
    }
    double ans = dp[0][N - 1];
    ans = 1.0 / ans * 2.0 * K * S;
    printf("Case %d: %.8lf\n",kase++,ans);
}

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        scanf("%d%d%d%d",&N,&M,&S,&K);
        memset(dp,0,sizeof(dp));
        for (int i = 0 ; i < M ; i++) {
            int u,v;
            double p;
            scanf("%d%d%lf",&u,&v,&p);
            dp[u][v] = dp[v][u] = max(dp[u][v],p / 100.0);
        }
        calcu(kase++);
    }
    return 0;
}
View Code

LightOj 1342 Aladdin and the Magical Sticks

题意：

　　地上有n种棍子， 其中有两种类型， 一种类型是可识别， 一种类型是不可识别， 每个棍子都有一个权值。

　　当你捡到可识别的， 那么你以后就不会再捡这个棍子， 如果是不可识别的， 那么你有可能还会捡。

　　问将所有棍子收集完的权值的期望。

我们现在面对的是一个n面的骰子， 骰子的每面都是随机出现的（相当于是不可识别的棍子）， 求问将所有面都被看完所期望的投掷次数（假设只看最上面那一面）

　　那么， 问题的解就是：

　　　　　　　　　　　　H[n] = (1 + 1/2 + 1/3 + 1/4 + ... + 1/n),  这就是调和级数的前n项。

　　　　　　　　　　　　这个值近似等于欧拉常数约为：0.57721566490153286060651209。（不过这是一个当n接近无穷时的近似值， 并不能代替具体的H[n]， 比如当 n = 1 || 2时）

　　而所求的是期望的权值， 根据期望的线性性质E(XY) = E(X)*E(Y) 

　　所以， 总的权值期望就等价于 每次的权值期望 * 次数的期望。

　　n个面， 每个面至少出现一次的期望次数是：E(x) = n * H[n]，那么， 某个指定的面至少出现一次的期望次数就是E(z) = E(x)/n = H[n]。

　　因此， 假设这n个棍子都是不可识别的时候所期望的权值为：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　Ea = E(w) * E(x)， E(w)为权值的期望 = 权值的平均值。

　　但是， 这n个棍子里还有一些是可以识别的， 因此还要减去多余的期望。

　　先来计算一下可识别的棍子所需要的期望的次数， 这个答案为1。

　　当有六个球在箱子里， 采用不放回抽样， 你将六个球抽出来所期望的次数是多少？这是一个固定的值， 为6。

　　因此， 每个棍子多出来的部分就是（H[n] - 1） * w[i]。w[i]为某个可识别的棍子的权值。

 

　　设， 所有棍子的权值平均值为Wn

　　假设有k个可识别的棍子， 其权值平均值为Wk

　　So , 答案为： Ea - Eb = Wn * n * H[n] - k * Wk * (H[n] - 1)

　　　　　化简： E = (Wn * n - k * Wk) * H[n] + k * Wk。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int n;
double h[MAXN];
void init()
{
    h[0] = 0;
    for(int i = 1; i < MAXN; i ++)
        h[i] = h[i - 1] + 1.0 / i;
}

int main()
{
    int T;
    int kcase = 0;
    init();
    scanf("%d", &T);
    while(T --)
    {
        scanf("%d", &n);
        int a, b;
        double ans = 0;
        for(int i = 0; i < n; i ++)
        {
            scanf("%d %d", &a, &b);
            ans += a * (b == 1? 1 : h[n]);
        }
        printf("Case %d: %.5lf\n", ++ kcase, ans);
    }
    return 0;
}
View Code

LightOJ 1364 

状压一下混子能充当的牌然后DP

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 17;
const int MAXM = 82;
double dp[MAXN][MAXN][MAXN][MAXN][MAXM];
int bit[10];
int C,D,H,S;

bool decode(int a,int b,int c,int d,int sta) {
    memset(bit,0,sizeof(bit));
   // printf("%d %d %d %d %d \n",a,b,c,d,sta);
    int len = 0;
    while (sta) {
        bit[len++] = sta % 3;
        sta /= 3;
    }
    a += bit[0];
    b += bit[1];
    c += bit[2];
    d += bit[3];
   // printf("%d %d %d %d\n",a,b,c,d); scanf("%*d");
    if (a >= C && b >= D && c >= H && d >= S) return true;
    return false;
}

double calcu(int a,int b,int c,int d,int sta) {
    double &ans = dp[a][b][c][d][sta];
    if (ans != -1.0) return ans;
    if (decode(a,b,c,d,sta) == true) return ans = 0.0;
    int tmp = sta;
    ans = 0;
    int len = 0,tot = 0;
    int bit[10];
    memset(bit,0,sizeof(bit));
    while (tmp) {
        bit[len++] = tmp % 3;
        tmp /= 3;
    }
    for (int i = 0 ; i < 4 ; i++) tot += bit[i];
    int all = 54 - a - b - c - d - tot;
    if (a < 13 && all > 0) {
        double p = (13 - a) * 1.0 / all;
        ans += (calcu(a + 1,b,c,d,sta) + 1) * p;
    }
    if (b < 13 && all > 0) {
        double p = (13 - b) * 1.0 / all;
        ans += (calcu(a,b + 1,c,d,sta)+ 1) * p;
    }
    if (c < 13 && all > 0) {
        double p = (13 - c) * 1.0 / all;
        ans += (calcu(a,b,c + 1,d,sta) + 1) * p;
    }
    if (d < 13 && all > 0) {
        double p = (13 - d) * 1.0 / all;
        ans += (calcu(a,b,c,d + 1,sta) + 1) * p;
    }
    int nxt;
    double val;
    if (tot < 2 && all > 0) {
        double p = (2 - tot) * 1.0 / all;
        nxt = (bit[0] + 1) + bit[1] * 3 + bit[2] * 9 + bit[3] * 27;
        val = calcu(a,b,c,d,nxt);
        nxt = bit[0] + (bit[1] + 1) * 3 + bit[2] * 9 + bit[3] * 27;
        val = min(val,calcu(a,b,c,d,nxt));
        nxt = bit[0] + bit[1] * 3 + (bit[2] + 1) * 9 + bit[3] * 27;
        val = min(val,calcu(a,b,c,d,nxt));
        nxt = bit[0] + bit[1] * 3 + bit[2] * 9 + (bit[3] + 1) * 27;
        val = min(val,calcu(a,b,c,d,nxt));
        ans += p * (val + 1);
    }
    return ans;
}

int main() {
    int T,kase = 1;
    scanf("%d",&T);
    while (T--) {
        scanf("%d%d%d%d",&C,&D,&H,&S);
        for (int i = 0 ; i < MAXN ; i++) for (int j = 0 ; j < MAXN ; j++) for (int k = 0 ; k < MAXN ; k++) for (int p = 0 ;  p < MAXN ; p++)
            for (int q = 0 ; q < MAXM ; q++) dp[i][j][k][p][q] = -1.0;
        int cnt = 0;
        if (C > 13) cnt += C - 13; if (D > 13) cnt += D - 13;
        if (H > 13) cnt += H - 13; if (S > 13) cnt += S - 13;
        if (cnt > 2) printf("Case %d: -1\n",kase++);
        else printf("Case %d: %.8lf\n",kase++,calcu(0,0,0,0,0));
    }
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/Commence/p/5316959.html

deko2014
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
kuangbin专题二十一概率&期望总结
qq_34921856的博客
05-30 709
做的时候觉得很难，很多题都是看题解做的，所以放了一段时间。这几天把kuangbin聚聚博客上的3篇论文仔细看了看，再看这些题就感觉思路很显然了。但仍然有几题不能想出来，故这里补一下总结，这也算kuangbin专题的最后一篇博客了。 首先将这几篇论文贴上来，论文真的真的很难懂。。认真看看但不要太深入即可。(高中生太强了。。 《信息学竞赛中概率问题求解初探》 《浅析竞赛中一类数学期望问题的解决方...
kuangbin专题 概率/期望DP总结
mzip的博客
05-26 400
题目链接: https://vjudge.net/contest/76505#overview A- A Dangerous Maze LightOJ - 1027 题意: 现在在你面前有N个门。每个门要么把你传送出迷宫，要么把你传送来的位置且你的记忆也会回到初始的时候。现在给出每个门传送的时间t，若t为正数，说明该门花费时间t可以将你传送出迷宫，若 t 为负数，说明该门花费时间 t 将你传送...
生日悖论
Jackie 的专栏
02-01 1026
生日悖论 1 假设某个班级共有23名学生。问:其中至少有两名学生的生日相同的概率是多少？ 假设学生人数为N，一年的天数为M。计算过程如下：1.任意两名学生的生日均不相同的情况共有 (M!/(M-N)!) 种可能。2.在无任何限制条件的情况下，学生的生日分布情况共有 (M^N) 种可能。3.于是，任意两名学生的生日均不相同的概率为：(M!/(M-N)!)/(M^N)。
HDU 5984(求木棒切割期望 数学)
b338865802883204的博客
10-03 1102
题意是给定一长为 L 的木棒，每次任意切去一部分直到剩余部分的长度不超过 D，求切割次数的期望。 若木棒初始长度不超过 D，则期望是 0.000000； 设切割长度为 X 的木棒切割次数的期望是 F(X). 则 F(X) = F(切割点位置为 0 ~ D) + F(切割点位置为 D ~ X ) + 1；（此处的 +1 是指首次切割产生的次数) 而 F(切割点位置为 0 ~ D )...
概率问题分析
ding7530的博客
06-12 163
　　1.考虑一个日常的问题，考英语时有很多道选择题(orz)，假设每个选择题共4个选项且只有1个正确答案，答对一题得5分，答错扣1分，不答没有分，由于本英语渣根本不会做，于是考虑不答还是随便答哪个更好，求随机选择的期望。 　　分析： 　　　　(1)不答题没有分，记期望为0； 　　　　(2)有以下两种情况，设答对的概率为A： $$ X_A=\left\{\begin{gathere...
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
kuangbin的ACM模板动态规划计算几何：线与线求交，线与面求交，求凸包，半平面求交等若干图论问题：最小生成树 最短路 强连通分量、桥和割点 等
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
kuangbin巨巨 ACM模板~ 有需要的朋友可以下载了~
从GAN到WGAN（02/2）
最新发布
gongdiwudu的专栏
06-14 1105
生成对抗网络 （GAN） 在许多生成任务中显示出巨大的效果，以复制现实世界的丰富内容，如图像、人类语言和音乐。它的灵感来自博弈论：两个模型，一个生成器和一个批评家，在相互竞争的同时使彼此更强大。然而，训练GAN模型是相当具有挑战性的，因为人们面临着训练不稳定或收敛失败等问题。在这里，我想解释一下生成对抗网络框架背后的数学原理，为什么很难训练，最后介绍一个旨在解决训练难点的GAN修改版本。
景芯SoC A72的时钟树分析
u011075954的专栏
06-13 689
innovus的ctslog中的Clock DAG信息可以报出来CTS主要运行步骤的关键信息，比如clustering，balancing做完后的clock tree的长度，clock tree上所用的buffer、inverter，icg cell数量，clock skew等信息。可以看到cell、sink的counts，也可以看到BUF、ICG的数量，接下来我们来看看景芯SoC A72 TOP的CLOCK ID和BUF个数的变化吧。先看下景芯SoC A72项目的cts latency变化过程。
yolov10主要特点
yzf060109的专栏
06-14 762
以下是YOLOv10与其他模型的快速对比：YOLOv10-S：46.3 AP，2.49毫秒延迟YOLOv10-M：51.1 AP，4.74毫秒延迟YOLOv10-L：53.2 AP，7.28毫秒延迟YOLOv10-X：54.4 AP，10.70毫秒延迟这些改进使YOLOv10成为实时目标检测任务的首选，从自动驾驶到智能监控。与YOLOv9-C相比，YOLOv10-B（一个平衡的变体）延迟减少了46%，参数量减少了25%，同时保持了相同的性能水平。一对多分配：在训练过程中使用，以提供丰富的监督信号。
YesPMP探索Python在生活中的应用，助力提升开发效率
YesPMP20的博客
06-13 897
Python是一种简单易学、高效强大的编程语言，正变成越来越多人选择的热门技能。学习Python不仅可以提供更多就业机会，还能让自己在职场更加有竞争力，那可以去哪里拓展自己的技能呢？
【讲解下目标追踪】
2301_81357485的博客
06-10 600
🏆近年来，随着深度学习的发展，基于深度学习的跟踪器已经取得了显著的性能提升，这些方法通常采用卷积神经网络（CNN）从大量带标签的数据中学习目标的特征表示，从而在各种复杂场景下都表现出强大的鲁棒性和准确性。🏆目标追踪是计算机视觉领域的一个重要问题，它旨在从视频序列中连续、自动地识别并跟踪一个或多个目标物体，目标追踪在许多实际应用中都有着广泛的应用，比如视频监控、运动分析、自动驾驶、人机互动和增强现实等。：随着时间的推移，目标的外观可能会发生变化，因此跟踪算法必须能够适应这些变化，可能需要定期更新目标的模型。
深度解读ChatGPT基本原理
Pika
06-12 1139
本文深入解读了ChatGPT的基本原理，介绍了其基于变换器架构的核心技术，详细描述了预训练和微调的训练过程，以及模型在实际应用中的工作机制。同时，探讨了ChatGPT在客户服务、内容创作等领域的应用场景和面临的挑战，展望了其未来发展方向。
Windows10下安装GPU环境Cuda和Pytorch教程图解
weixin_40547993的博客
06-12 1374
在深度学习和高性能计算领域，利用GPU进行计算已经成为提升效率的关键手段。CUDA是NVIDIA推出的并行计算平台和编程模型，它使得开发者能够利用NVIDIA GPU的强大计算能力。同时，PyTorch作为一个广泛使用的深度学习框架，以其易用性和灵活的动态计算图受到了研究人员和开发者的青睐。为了在Windows10系统上充分利用GPU进行深度学习训练，需要正确安装和配置CUDA和PyTorch。
集成算法实验(Bagging策略)
weixin_50917576的博客
06-12 1073
Bagging：训练多个分类器取平均fx1/M∑m1M​fm​x全称： bootstrap aggregation（说白了就是训练一堆分类器）最典型的代表就是随机森林，现在Bagging模型基本上也是随机森林。随机：数据采样随机，；数据有多个特征(属性)组成，。随机是为了使得每个分类器拥有明显差异性。森林：很多个决策树并行放在一起如何对所有树选择最终结果？分类的话可以采取少数服从多数，回归的话可以采用取平均值。
DeepSORT（目标跟踪算法）中的计算观测值与状态估计的马氏距离
flyfish
06-10 847
flyfish在目标跟踪中，使用马氏距离可以帮助判断某个观测值是否与当前的状态估计一致。gating_distance 是一个方法，用于计算状态分布和观测值之间的门限距离（gating distance）。门限距离通常用于数据关联和验证测量值是否合理。提示用户可以从 chi2inv95 中获取适当的距离阈值。如果only_position 为 False，则使用4自由度的卡方分布，否则使用2自由度的卡方分布。
并查集板子llkkyyy
08-19
- *1* *2* [「kuangbin带你飞」专题五并查集专题题解](https://blog.csdn.net/weixin_51216553/article/details/121643742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值