bzoj 1419 Red is good（概率与期望）

Description

桌面上有R张红牌和B张黑牌，随机打乱顺序后放在桌面上，开始一张一张地翻牌，翻到红牌得到1美元，黑牌则付出1美元。可以随时停止翻牌，在最优策略下平均能得到多少钱。

Input

一行输入两个数R,B,其值在0到5000之间

Output

在最优策略下平均能得到多少钱。

Sample Input

5 1

Sample Output

4.166666

HINT

输出答案时,小数点后第六位后的全部去掉,不要四舍五入.

Source

[ Submit][ Status][ Discuss]

分析：
一开始我设计的状态是：
f[i][j]表示现在抽了i张牌，其中j张是R的概率
f[i+1][j+1]=f[i][j]*((double)(R-j)/(R+B-i))
f[i+1][j]=f[i][j]*((double)(B-i+j)/(R+B-i))
所以最后的期望就是 Σf[i][j]*(j-(i-j))

但是这样写出来是不对的，而且时间复杂度也不科学
所以我们要改变状态：

f[i][j]表示有i张红牌，j张黑牌的最优决策的期望。

f[i][j]=max ( 0 , ( f[i-1][j]+1 ) * ( i/(i+j) ) + ( f[i][j-1]-1) * ( j /(i+j) ) )

( f[i-1][j]+1 ) * ( i/(i+j) )表示下一张是R
( f[i][j-1]-1) * ( j /(i+j) ) )表示下一张是B

tip

注意一下输出的处理
注意初始化：f[1][0]=1; f[0][1]=0;

于是就写出来了：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>

using namespace std;

const int N=5003;
double f[N][N],ans;
int R,B,n;

void solve(double ans)
{
    double x=floor(ans*1000000);
    x/=1000000;
    printf("%0.6lf",x);
}

int main()
{
    scanf("%d%d",&R,&B);
    f[1][0]=1;
    f[0][1]=0;
    for (int i=1;i<=R;i++)
    {
        f[i][0]=i;               //边界情况一定要维护
        for (int j=1;j<=B;j++)
        {
            double r=0;
            r+=((f[i-1][j]+1)*(double)((double)i/(j+i)));
            r+=((f[i][j-1]-1)*(double)((double)j/(j+i)));
            f[i][j]=max(0.0,r);
        }
    }
    solve(f[R][B]);
    return 0;
}

但是这样是A不了的，因为这道题的空间限制是64MB
所以我们需要用滚动数组优化

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>

using namespace std;

const int N=5003;
double f[2][N],ans;
int R,B,n;

void solve(double ans)
{
    double x=floor(ans*1000000);
    x/=1000000;
    printf("%0.6lf",x);
}

int main()
{
    scanf("%d%d",&R,&B);
    f[0][0]=1;
    int now=0,pre;
    for (int i=0;i<=R;i++)         //这里的循环需要从0开始，因为滚动数组的第一维从0开始 
    { 
        pre=now; now^=1;
        f[now][0]=i;               ///边界情况一定要维护 
        for (int j=1;j<=B;j++)
        {
            double r=0;
            r+=((f[pre][j]+1)*(double)((double)i/(j+i)));
            r+=((f[now][j-1]-1)*(double)((double)j/(j+i)));
            f[now][j]=max(0.0,r);
        }
    }
    solve(f[n&1][B]);
    return 0;
}