hdu 4089 概率dp

照旧记录啊TAT，一个看题解都看了好久才明白的题目

传送门

题意：仙剑五终于出了，tomato同学抑制不住内心的激动去激活游戏，但像tomato同学一样想玩仙剑五的人太多了，于是排起了队，对于排到的每个人都有如下四种情况：

1、激活失败：继续原地等着再激活一次，概率p1

2、连接失败：比较脸黑，回到队伍最后重新排，概率p2

3、激活成功：就成功地可以回家玩游戏了，概率p3

4、服务器崩溃：这是太太太脸黑了，自己黑就算了，带着后面所有排队的人都不能激活了，概率p4

（讲真这么小激活成功的几率，谁会排队啊！）

tomato同学想，如果自己排到小于等于第k个位置的时候，服务器崩溃了，那也太难过了，于是求一下位置小于等于k时服务器崩溃的概率，不过有一点比较好，就是排队的总人数只会少不会多，现在给出总共排队的人数n，tomato同学开始所在的队伍中的位置m，k，及p1、p2、p3、p4

思路：由于每个人所面临的情况都相同，所以每个状态的值都与上个状态密切相关，用概率dp，设dp[i][j]为总人数为i的队伍，主角开始在第j个位置时，位置小于等于k时服务器崩溃的概率，那么dp[n][m]就是我们需要的值，可以得到如下关系式：

（1）、当j=1时，（也就是已经排到了主角，在队伍的第一个位置，如果服务器崩溃是要计入的）：

dp[i][1]=p1*dp[i][1]+p2*dp[i][i]+p4

（2）、当2<=j<=k时，（也就是主角已经到了小于等于k的位置里，这时候每次服务器崩溃的概率都要计入了）：

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

（3）、当k<j<=i时，（主角还没到第k位置，服务器是否崩溃无所谓，只需要看后面的状态就可以了）

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

化简一下可得（化简纯粹为了看起来比较清楚）：

j=1：dp[i][1]=p*dp[i][i]+p41————————————（1）

2<=j<=k：dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1]+p41——（2）

k<j<=i：dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1] —————（3）

其中p=p2/(1-p1)、p31=p3/(1-p1)、p41=p4/(1-p1)

那么问题又来了，我们该怎么计算出我们所需要的dp[n][m]呢？

首先通过第一个式子，我们可以得到dp[1][1]，这是一个切入点，因为紧接着我们可以根据（2）、（3）可以求出来dp[2][2]，进而可以求得dp[2][1]，所以根据这个思想，我们要是把i从1-n循环一遍，dp[i-1][j-1]就相当于一个已知的值了，为了看的更清楚，我们再进行一下简化：

j=1：dp[i][1]=p*dp[i][i]+c[1]————————————（1'）

2<=j<=k：dp[i][j]=p*dp[i][j-1]+c[j]  —————————（2'）

k<j<=i：dp[i][j]=p*dp[i][j-1]+c[j]  ——————————（3'）

（其实后面的两个式子一样啊，只是c[j]表达的意思有一点不同）

通过（2'）、（3'）可以通过迭代得到dp[i][i]和dp[i][1]的一个关系式，然后（1'）本身也是一个dp[i][i]和dp[i][1]的关系式，两个式子一联立可以得到：

dp[i][i]=(p^(i-1)*c[1]+...+p*c[i-1]+c[i])/(1-p)，得到了dp[i][i]、dp[i][i-1]就可以再得到所有的dp[i][j]了，那么dp[n][m]就得到了

这个题需要有个特判，就是p4是0的时候，就不会出现系统崩溃的情况了，概率直接是0（这种的很不容易发现啊，毕竟如果样例全改成p4=0，输出也确实是0）

还有直接开2000*2000的二维数组mle了……看了discuss，需要改成滚动数组……由于这个题只需要用i-1的关系，所以改成滚动数组是完全可以实现的

完整代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long LL;
const int N=2000;
const double eps=1e-5;
double dp[2][N+5];
double c[N+5];
double Pow[N+5];
int main()
{
    int n,m,k;
    double p1,p2,p3,p4;
    while(scanf("%d%d%d%lf%lf%lf%lf",&n,&m,&k,&p1,&p2,&p3,&p4)!=-1)
    {
        if(p4<eps)
        {
            printf("0.00000\n");
            continue;
        }
        double p=p2/(1-p1);
        double p31=p3/(1-p1);
        double p41=p4/(1-p1);
        Pow[0]=1.0;///计算p的i次方
        for(int i=1;i<=n;i++)
            Pow[i]=Pow[i-1]*p;
        c[1]=p41;
        memset(dp,0,sizeof(dp));
        dp[1][1]=c[1]/(1-p);
        for(int i=2;i<=n;i++)
        {
            for(int j=2;j<=k;j++)
                c[j]=p31*dp[(i-1)%2][j-1]+p41;///利用滚动数组
            for(int j=k+1;j<=i;j++)
                c[j]=p31*dp[(i-1)%2][j-1];
            double tmp=0;
            for(int j=1;j<=i;j++) tmp=tmp+Pow[i-j]*c[j];
            dp[i%2][i]=tmp/(1-Pow[i]);
            dp[i%2][1]=p*dp[i%2][i]+c[1];
            for(int j=2;j<i;j++)
                dp[i%2][j]=p*dp[i%2][j-1]+c[j];
        }
        printf("%.5f\n",dp[n%2][m]);
    }
    return 0;
}