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

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

求概率从起点开始求解，因为起点发生的概率通常可以确定，为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]
> dp[ans]
)
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
[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;
}