hdu 4089 Activation

题目大意：有n个人都是仙剑5的粉丝，现要在官网上激活游戏，（其中主角Tomato最初排名为m），对于队列中的第一个人，在激活的时候有以下五种情况：
1.激活失败：留在队列中继续等待下一次激活（概率为p1）
2.失去连接：激活失败，并且出队列然后排到队列的尾部（概率为p2）
3.激活成功：出队列（概率为p3）
4.服务器瘫：服务器停止服务了，所有人都无法激活了（概率为p4）
求服务器瘫痪并且此时Tomato的排名<=k的概率 Q。

解题思路：用dp[ i ] [ j ] 表示现队列中共有i个人， Tomato排名为j 时的Q，dp[n][m]即为所求

则可列出下式：

当 j == 1 时，dp[ i ][ j ]  =  p1 * dp[ i ][ j ]  +  p2 * dp[ i ][ i ]   +  p4; 

当 2 =< j <= k 时，dp[ i ][ j ]  =  p1 * dp[ i ][ j ]  +  p2 * dp[ i ][ j-1]   + p3 * dp[ i-1 ][ j -1 ] + p4;

当 j  > k 时，dp[ i ][ j ]  =  p1 * dp[ i ][ j ] + p2 * dp[ i ][ j-1] + p3 *dp[ i-1 ][ j-1] ;

化简得：

当 j == 1 时，dp[ i ][ j ]  =  p21 * dp[ i ][ i ]   +  p41; 

当 2 =< j <= k 时，dp[ i ][ j ]  =  p21 * dp[ i ][ j-1]   + p31* dp[ i-1 ][ j -1 ] + p41;

当 j  > k 时，dp[ i ][ j ]  =  p21 * dp[ i ][ j-1]  + p31 *dp[ i-1 ][ j-1] ;

其中:

p21 = p2 / (1 - p1);

p31 = p3 / (1 - p1);

p41 = p4 / (1 - p1);

易得： dp[1][1] = p41 / (1 - p21);

现在可以循环 i = 1 -> n 递推求解dp[i]，所以在求dp[i]时，dp[i-1]就相当于常数了， 故设 c[j] 为计算dp[i][j]时的常数项，

则：

dp[i][1] = p21 * dp[i][i] +c[1];

dp[i][2] = p21 * dp[i][1] + c[2];

dp[i][3] = p21 * dp[i][2] + c[3];

………………………………

dp[i][i] = p21 * dp[i][i-1] + c[i];

则 dp[i][i] = ( p^(i-1) * c[1] + p^(i-2) * c[2] + …… + p^2 * c[i-2] + p * c[i-1] + c[i] ) / ( 1 - p^i) (其中 p = p21) ；

之后即可求出dp[i][1] ……dp[i][i-1] ；

最后需要注意的一点是： dp[1][1] = p41 / (1 - p21) = p4 / (1 - p1 -p2); 分母 1- p1 - p2可能逼近0 ，需要特判一下。

代码实现：

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 2005
double dp[N][N];
double c[N];

int main()
{
    int n, m, k;
    double  p1, p2, p3, p4;
    while(~scanf("%d %d %d", &n, &m, &k))
    {
            scanf("%lf %lf %lf %lf", &p1, &p2, &p3, &p4);
            if(fabs(1 -  p1 - p2) < 1e-9)
            {
                  printf("0.00000\n");
                  continue;
            }
            memset(dp, 0, sizeof(dp));
            double p21 = p2 / (1 - p1);
            double p31 = p3 / (1 - p1);
            double p41 = p4 / (1 - p1);
            double  pp[N];
            pp[0] = 1.0;
            for(int i = 1; i <= n; i ++)
            {
                    pp[i] = pp[i-1] * p21;
                   // printf("%.4lf \n", pp[i]);
            }
            dp[1][1] = p41 / (1 - p21);
            c[1] = p41;

            for(int i = 2; i <= n; i ++)
            {
                   // dp[i][1] = p21 * dp[i][i] + p41;
                    int j;

                    for(j = 2; j <= k; j ++)
                            c[j] = p31 * dp[i-1][j-1] + p41;
                    for(j = k + 1; j <= i; j ++)
                            c[j] = p31 * dp[i-1][j-1];
                    double sum = 0.0;
                    for(int z = 1; z <= i; z ++)
                    {
                            sum += pp[i - z] * c[z];
                    }
                    dp[i][i] = sum / (1 - pp[i]);
                    dp[i][1] = p21 * dp[i][i] + p41;
                    for(int z = 2; z < i; z ++)
                            dp[i][z] = p21 * dp[i][z-1] + c[z];

            }
            printf("%.5lf\n", dp[n][m]);

    }
    return 0;
}