概率dp入门[HDU5001][POJ2151][POJ3071][HDU3853][POJ2096]

最新推荐文章于 2022-09-03 14:04:18 发布
最新推荐文章于 2022-09-03 14:04:18 发布
阅读量389 收藏 1
点赞数
分类专栏： ACM_DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24833289/article/details/48445817
版权

概率分为求概率和求期望两种：

求概率从起点开始求解，因为起点发生的概率通常可以确定，为1、1/n或其他；

求期望从终点开始求解，因为通常记录从某个点到终点的期望，即先确定了终点到终点的期望。


例题

HDU 5001 概率 http://acm.hdu.edu.cn/showproblem.php?pid=5001

题意：有一个图，n个点，m条边，（起点随机）我在某个点随便找一条相邻边消耗1步走到另一个点，再随便找一条边继续走下去（会走重复的边），直到走了d步。问d步之后，对于每一个点，我没有走过它的概率。

思路：

dp[ i ][ j ][ k ] 记录走了 i 步之后，我没走过 j 这个点，现在停在 k 这个点的概率

但是 i 的范围很大，会MLE，dp[i] 只与dp[i - 1] 有关，所以要使用滚动数组 i % 2

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
#include <vector>
using namespace std;
typedef long long ll;
vector<int> G[55];
double dp[5][55][55];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t, n, m, d, a, b;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d%d", &n, &m, &d);
        for(int i = 0; i <= n; i++)
            G[i].clear();
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        memset(dp, 0, sizeof(dp));
        for(int cur = 1; cur <= n; cur++)
        {
            for(int i = 1; i <= n; i++)
            {
                if(i != cur)
                    dp[1 % 2][cur][i] = 1.0 / n; //初始化起点概率，走到起点也算了一步，答案为走了d+1步之后的值
            }
        }
        for(int step = 1; step <= d; step++)
        {
            for(int cur = 1; cur <= n; cur++)
            {
                for(int fa = 1; fa <= n; fa++)
                {
                    if(fa == cur) continue;
                    int nson = G[fa].size();
                    for(int i = 0; i < nson; i++)
                    {
                        int son = G[fa][i];
                        if(son == cur) continue;
                        dp[(step + 1) % 2][cur][son] += dp[step % 2][cur][fa] * (1.0 / nson);
                    }
                    dp[step % 2][cur][fa] = 0; //要注意滚动数组使用后清零
                }
            }
        }
        double ans;
        for(int cur = 1; cur <= n; cur++)
        {
            ans = 0;
            for(int i = 1; i <= n; i++)
            {
                ans += dp[(d + 1) % 2][cur][i];
            }
            printf("%.10f\n", ans);
        }
    }

    return 0;
}


POJ 2151 概率  http://poj.org/problem?id=2151

题意：

编程比赛设置了m道题，t个队伍参加，希望题目的难度适当，使得

1）每个队伍至少解出1题；

2）冠军队伍至少做出n道题。

给出各个队伍解出各题的概率，求题目难度适当的概率。

思路：

更像一个需要开三维数组的普通dp，dp[ i ][ j ][ k ] 为第 i 个队伍对于前面 j ，解出 k 题的概率。最后利用dp[ i ][ n ][ k ] 求解答案。
代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
double f[1005][35], dp[1005][35][35];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int m, t, n;
    while(scanf("%d%d%d", &m, &t, &n) != EOF)
    {
        if(!(m + t + n)) break;
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= t; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                scanf("%lf", &f[i][j]);
            }
            dp[i][0][0] = 1.0;
        }
        for(int i = 1; i <= t; i++)
        {
            //printf("i=%d\n", i);
            for(int j = 1; j <= m; j++)
            {
                for(int k = 0; k <= j; k++)
                {
                    dp[i][j][k] = dp[i][j - 1][k - 1] * f[i][j] //做出第j题
                        + dp[i][j - 1][k] * (1 - f[i][j]); //没做出第j题
                    //printf("dp[%d][%d][%d]=%.3f\n", i, j, k, dp[i][j][k]);
                }
            }
        }
        double ans = 1.0, mid = 1.0;
        for(int i = 1; i <= t; i++)
            ans *= (1 - dp[i][m][0]); //各个队做出题数大于等于1的概率
        for(int i = 1; i <= t; i++)
        {
            double cur = 0;
            for(int j = 1; j <= n - 1; j++)
            {
                cur += dp[i][m][j]; 
            }
            mid *= cur; //各个队做出题数在1-（n-1）之间的概率
        }
        ans -= mid;
        printf("%.3f\n", ans);
    }

    return 0;
}

POJ 3071 概率  http://poj.org/problem?id=3071
题意：按照足球比赛淘汰赛赛制，给出2^n个队伍两两之间比赛的胜率（p[ i ][ j ]为i打败j的概率），问最有可能夺冠的队伍。

思路：

dp[ i ][ j ] 为第 i 个队伍在第 j 层比赛中取胜的概率，2^n个队伍，冠军为在第n层取胜的队伍

开始时每个队伍在第 0 层取胜的概率为 1，从第1层算到第n层

dp[ i ][ j ] = dp[ i ][ j - 1 ] * ∑(dp[ x ][ j - 1 ] * p[ i ][ x ])   (x为在这一层可能遇到的对手，注意下求对手的方法）

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
double dp[1005][10], p[1005][1005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n;
    while(~scanf("%d", &n))
    {
        if(n == -1) break;
        for(int i = 1; i <= (1 << n); i++)
            for(int j = 1; j <= (1 << n); j++)
                scanf("%lf", &p[i][j]);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= 1 << n; i++)
            dp[i][0] = 1.0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= 1 << n; j++)
            {
                int a = (j - 1) / (1 << i), b = j % (1 << i);
                if(!b) b = (1 << i);
                //printf("j=%d a=%d b=%d %d\n", j, a, b, (1 << (i - 1)));
                int s, e; //分情况求对手s-e
                if(b <= (1 << (i - 1)))
                {
                    s = a * (1 << i) + (1 << (i - 1)) + 1;
                    e = (a + 1) * (1 << i);
                    //printf("1:s=%d e=%d\n", s, e);
                }
                else
                {
                    s = a * (1 << i) + 1;
                    e = a * (1 << i) + (1 << (i - 1));
                    //printf("2:s=%d e=%d\n", s, e);
                }

                for(int k = s; k <= e; k++)
                {
                    dp[j][i] += dp[k][i - 1] * p[j][k];
                }
                dp[j][i] *= dp[j][i - 1];
            }
        }
        int ans = 1;
        for(int i = 1; i <= (1 << n); i++)
            if(dp[i][n] > dp[ans][n])
                ans = i;
        printf("%d\n", ans);
    }

    return 0;
}

HDU 3853 期望  http://acm.hdu.edu.cn/showproblem.php?pid=3853

题意：给出r*c个格子，每格格子上都有一个传送门，它把你传回本格，传到右边的格，传到下面的格都有一定概率p1,p2,p3，和为1，没使用1次传送门消耗2点法力，问要从（1，1）到（r，c）需要消耗法力的期望。

思路：

dp[ i ][ j ] 为从（i，j）到（r，c）的期望。

dp[ i ][ j ] = dp[ i ][ j ] * p1 + dp[ i ][ j + 1 ] * p2 + dp[ i + 1 ][ j ] * p3 + 2

移项得

dp[ i ][ j ] = (dp[ i ][ j + 1 ] * p2 + dp[ i + 1 ][ j ] * p3 + 2) / (1 - p1)

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
double p[1005][1005][5], dp[1005][1005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int r, c;
    while(~scanf("%d%d", &r, &c))
    {
        memset(p, 0, sizeof(p));
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= r; i++)
        {
            for(int j = 1; j <= c; j++)
            {
                scanf("%lf%lf%lf", &p[i][j][1], &p[i][j][2], &p[i][j][3]);
            }
        }
        for(int i = r; i >= 1; i--)
        {
            for(int j = c; j >= 1; j--)
            {
                if(i == r && j == c) continue;
                if(p[i][j][1] == 1.0) continue;
                dp[i][j] = (p[i][j][2] * dp[i][j + 1] + p[i][j][3] * dp[i + 1][j] + 2) / (1 - p[i][j][1]);
            }
        }
        printf("%.3f\n", dp[1][1]);
    }
    return 0;

}

POJ 2096 期望  http://poj.org/problem?id=2096

题意：小男孩给程序找bug，程序分为s个子程序，找出的bug分为n种。每天小男孩可以找出1个bug，它只会属于1种bug，且只在1个子程序中，问小男孩找出了n种bug，且每个子程序中都找出了一个bug，需要的天数的期望。

思路：

dp[ i ][ j ] 为找出 i 种bug，它们出现在了 j 个子程序中的期望。

与上题相似，（ i , j ）可以到达

    状态                   概率

（i , j ）              （i / n）* (j / s)

 ( i , j + 1 )            (i / n) * (s  - j)  / s

 (i + 1, j )             (n - i) / n * (j / s)

 (i + 1,  j + 1)       (n - i) / n * (s - j) / s

每次传送消耗 1 天

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
double dp[1005][1005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, s;
    while(~scanf("%d%d", &n, &s))
    {
        memset(dp, 0, sizeof(dp));
        dp[n][s] = 1.0;
        for(int i = n; i >= 1; i--)
        {
            for(int j = s; j >= 1; j--)
            {
                if(i == n && j == s) continue;
                dp[i][j] = (dp[i][j + 1] * i * (s - j) / n / s
                            + dp[i + 1][j] * (n - i) * j / n / s
                            + dp[i + 1][j + 1] * (n - i) * (s - j) / n / s + 1)
                            / (1.0 - 1.0 * i * j / n / s);
            }
        }
        /*for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= s; j++)
                printf("%.4f ", dp[i][j]);
            printf("\n");
        }*/
        printf("%.4f\n", dp[1][1]);
    }

    return 0;
}


cookiesMonster
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj3071
weixinding的专栏
03-08 850
【题意】 给出2^n个球队之间互相的胜率，求哪个球队胜率最高。 比赛以淘汰赛形式进行。 【输入】 多组数据，第一行一个整数n，意义如上 接下来一个2^n*2^n的矩阵，表示球队之间的胜率 【输出】 对于每组数据，输出胜率最高的球队的编号，相同的时候输出编号小的 模拟一下，算出每轮每个球队的胜率即可 program poj3071; var n,i,j,
poj3071(概率DP)
xiefubao的专栏
05-21 877
题意：淘汰赛制，2^n(n 解法：ans[i][j]表示第i个队员第j轮胜出的概率。赢到最后需要进行n场比赛。算出每个人赢到最后的ans[i][n]。写出序号的二进制发现一个规律，两个队员i、j如果碰到，那么一定是在第get(i,j)场比赛碰到的。get(i,j)计算的是i和j二进制不同的最高位，这个规律也比较明显。 代码：/******************************
POJ 3071 Football （概率DP）
aozil_yang的博客
04-12 1986
Football Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 4344   Accepted: 2220 Description Consider a single-elimination football tournament involving 2n t
poj3071--Football（概率计算）
随风的专栏
08-04 1134
题目链接：点击打开链接 题目大意：给出2^n个队伍，采用淘汰制比赛，第1和第2比赛，第2和第三比赛，淘汰之后，仍然按顺序比赛，p[i][j]：第i支队伍赢第j支队伍的概率，问最终哪个队伍赢的概率最大。 一共会比n场比赛，计算出每一个队伍赢得概率，找出最大值。 第一场 1对2，3对4，，，， 第二场1、2对3、4，5、6对7、8，，，， 第三场1、2、3、4对5、6、7、8，， 这样对于
POJ 3071 概率DP
妍恐龙的博客....^~^眼熟我
08-01 229
Description Consider a single-elimination football tournament involving 2n teams, denoted 1, 2, …, 2n. In each round of the tournament, all teams still in the tournament are placed in a l
概率DP求期望入门，HDU 4405，POj 2096,HDU 3853
gg_gogoing的专栏
11-24 1497
这两个题目的状态一个是一维的，另一个是二维的。刚开始做的是POJ 2096，我将HDU状态定义为dp[i][j]  走i步到j位置。 HDU是个判定问题，是否走完。而那个是走到特定的两个状态下。 HDU 4405 裸概率题，dp[i]状态定义为从i走完的期望。对于飞行路线用个map，若有则直接等于了。。 #include #include #include #include #in
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
描述中提到的“动态规划DP题解”和“POJ HDU部分动态规划DP题解”，说明这个压缩包包含了针对HDU和POJ（Problemset Online Judge）平台上一些动态规划题目的解答。POJ是一个著名的在线编程竞赛平台，其中包含了大量...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
POJ+HDU题库使用指南
qq_46476515的博客
09-03 2280
POJ解题指南
POJ3071 Football 【概率dp】
BlueSky
04-08 448
题目链接：http://poj.org/problem?id=3071题意： 足球赛制是淘汰赛，每次是1和2打比赛，3和4……然后1和2的胜者和3和4的胜者打比赛，i打j的胜率是 Pij，问哪只队伍最有可能夺冠？（即获胜概率最高）。题解： 简单的概率dp题，只需要判断一下j和k能否碰上即可。代码：#include <cstdio> #include <cstring> #include <ios
POJ 3071 Football（简单 概率DP）
GLSilence的专栏
08-12 1120
Football 大意：2^n 个球队进行单场淘汰赛，每两只球队之间比赛会有胜负的概率，问最后谁夺冠的概率最大。 思路：简单的概率DP问题，主要是怎么处理哪两个球队比赛的问题。 DP方程为 dp[i][j] = ∑(dp[i-1][j]*dp[i-1][k]*p[j][k]); //dp[i][j]表示第 i 轮的时候，第 j 支队伍赢的概率。、 对
POJ 2063 Investment （完全背包）
cookiesMonster
02-05 631
题意：我有很多钱，要用来买债券，已知每种债券的价格和每一期可获得的利润（注意债券的价格只能为1000的倍数），而且我可以每一期把原来的债券卖掉，然后用原来的钱加上利润选择新的购买方案。已知我要一开始有多少钱和我将购买多少期债券，求出我最后有多少钱。 思路：完全背包。一开始看到债券价格为1000的倍数，我就用了 for(int j = value[i]; j …… str += a
树形dp入门[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]
cookiesMonster
08-15 568
[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]树形dp中，我们可以很容易利用题目给出的数据构建出一棵树，然后我们会用dp[i]记录，选择以 i 为根的子树中的点能得到的最优答案。而dp[i]的值可以根据，i节点的子节点u1,u2...un对应的dp[u1],dp[u2]...dp[un]，递推得到。树形dp通常用搜索的形式实现，由于是树的结构，所以不包含重复的搜索，复杂度为O（n）。
经典动态规划问题 背包问题 [POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631]
cookiesMonster
08-14 515
[POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631] 最长上升自序列问题（LIS） 给出n个整数a1,a2...an组成序列，求最长的上升子序列（若i 时间复杂度为O(n^2)的做法： dp[i]表示以ai为末尾的最长上升子序列长度，则有 当a[j] 时间复杂度O(nlogn)的做法： dp[i]表示长度为i的上升子序列末尾元素的最小值，则对于每个元素ai，二分查找数组dp，找到第一个dp[]值不小于ai的位置，将其值变为ai 例题
状态压缩dp入门[HDU1074][HDU1065][POJ3254][POJ1185][HDU4359][POJ3311][POJ2411]
cookiesMonster
08-14 506
[HDU1074][HDU1065][POJ3254][POJ1185][HDU4359][POJ3311][POJ2411] 我理解的状态压缩dp问题是这样的： 给出你n个物品，你要在这n个物品中选出一些物品（或一个都不选），那么对于每个物品你都有两种选择（选或者不选），这样，一共有2^n种情况。而n 如：总共有5个物品，则最多有32种取物品的情况，13 对应5位的二进制数01101，就表示取物品2，3，5。对于每个5位的二进制数我们都用5次位运算判断它的各个位是1还是0。本来每个状态要用5个空间存，现在
单调队列优化dp [HDU2191][HDU3401][POJ1821]
cookiesMonster
10-05 448
用单调队列优化形如 dp[i][j] = max(dp[i - 1][k] + (j - k) * a[i]) 的状态转移 上式可化为dp[i][j] = max(dp[i - 1][k] - k * a[i]) + j * a[i]， 在不用单调队列优化前，对于dp[i][j] 和dp[i][j + 1]枚举 k 时发现，有重复的部分，而且都是取dp[i - 1][...k...]...的最
博弈问题解析：HDU Online Judge与Poj1067的石子游戏策略
这篇资源主要涉及的是博弈问题的解决方法，特别是关于HDU Online Judge上的几道题目，包括HDU 2516, POJ 1067, HDU 1527, HDU 2177以及HDU 2176。这些题目都是关于石子游戏的，玩家需要在一定的规则下决定如何取石子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值