HDU4089 Activation（概率DP+处理环迭代式子）

题意：有n个人排队等着在官网上激活游戏。Tomato排在第m个。
对于队列中的第一个人。有一下情况：
1、激活失败，留在队列中等待下一次激活（概率为p1)
2、失去连接，出队列，然后排在队列的最后（概率为p2）
3、激活成功，离开队列（概率为p3）
4、服务器瘫痪，服务器停止激活，所有人都无法激活了。
求服务器瘫痪时Tomato在队列中的位置<=k的概率
 
分析：

设dp[i][j]表示i个人排队,Tomato排在第j个位置，达到目标状态的概率(j<=i)
dp[n][m]就是所求
 
对于1，2，3的问题显然有表达式：
 
dp[i][j] = p1*dp[i][j] + p2*dp[i][j-1] + p3*dp[i-1][j-1];
对于4我们怎么考虑呢？
我们发现对于 j<=k 的时候怎么移动对于结果来说都是1，而j>k的时候对于结果来说是0
所以我们要分类讨论:
1<=j<=k

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

dp[i][j] = p1*dp[i][j] + p2*dp[i][j-1] + p3*dp[i-1][j-1];
 
我们在仔细观察，2号操作是“出队列，然后排在队列的最后” 那如果当前就是在1位置，那这个结果后应该是排到最后，而不是1-1;
所以有特判：
j==1;

dp[i][j] = p1*dp[i][j] + p2*dp[i][i] + p4;
故最终：

j==1:    dp[i][1]=p1*dp[i][1]+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;
k<j<=i:  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;
2<=j<=k: dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1]+p41;
k<j<=i:  dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1];
 
其中:
p=p2/(1-p1);
p31=p3/(1-p1)
p41=p4/(1-p1)

由上面的式子可以看出，求dp[i][j]的时候dp[i-1][j-1]是已经计算出来了的。我们不妨把后面的部分用c数组保存起来，得

当j=1时，dp[i][j] = p21*dp[i][i]+c[1]；

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

当k<j<=i时，dp[i][j] = p21*dp[i][j-1]+c[j]，其中c[j]=p31*dp[i-1][j-1];

显然，dp[i][1]与dp[i][i]有关，而dp[i][j]又与dp[i][j-1]有关，这样就形成了一个环。所以，我们先利用上面3个式子迭代求出dp[i][i]：

dp[i][i]=dp[i][i]*p21^i+c[1]*p21^i-1+c[2]*p21^i-2+......+c[i]；变个形即可求出dp[i][i]

得出dp[i][i]，那么dp[i][1]也可以得出，之后就递推就行了。

求dp[i][i]的公式在草稿纸上演算下即可：

例如：

a[3]=w*a[2]+c[3]..1

a[2]=w*a[1]+c[2]..2

a[1]=w*a[n]+c[1]..3

把3代入2在代入3,未知量只有一个a[3]；

必须特判下p4 接近 0的情况，不然计算代价奇高

超内存

#include<bits/stdc++.h>
using namespace std;
const int N=;
const double eps=1e-;
double c[N],pp[N],dp[N][N];
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))
    {
        if(p4<eps)
        {
            printf("0.00000\n");
            continue;
        }
        double p=p2/(-p1);
        double p41=p4/(-p1);
        double p31=p3/(-p1);
        pp[]=1.0;
        for(int i= ; i<=n ; i++)
        pp[i]=p*pp[i-];
        dp[][]=p41/(-p);
        c[]=p41;
        for(int i= ; i<=n ; i++)
        {
            for(int j= ; j<=k ; j++)
            c[j]=p31*dp[i-][j-]+p41;
            for(int j=k+ ; j<=i ; j++)
            c[j]=p31*dp[i-][j-];
            double tmp=c[]*pp[i-];
            for(int j= ; j<=i ; j++)
            tmp+=c[j]*pp[i-j];
            dp[i][i]=tmp/(-pp[i]);
            dp[i][]=p*dp[i][i]+c[];
            for(int j= ; j<i ; j++)
            dp[i][j]=p*dp[i][j-]+c[j];
        }
        printf("%.5lf\n",dp[n][m]);
    }
}

卡内存：不预处理PP

#include <iostream>
#include <cstdio>
#include <memory.h>
using namespace std;
const int maxn = ;
int n, m, k;
double p1, p2, p3, p4, p21, p31, p41;
double dp[maxn][maxn], c[maxn];
double eps = 1e-;
int main()
{
    while(~scanf("%d%d%d%lf%lf%lf%lf", &n, &m, &k, &p1, &p2, &p3, &p4)){
        if(p4<eps){
            printf("0.00000\n");continue;
        }
        p21 = p2/(-p1);
        p31 = p3/(-p1);
        p41 = p4/(-p1);
        dp[][]=p41/(-p21);
        for(int i=;i<=n;i++){
            for(int j=;j<=i;j++){
                if(j==)c[j]=p41;
                else if(j<=k)c[j]=p31*dp[i-][j-]+p41;
                else c[j]=p31*dp[i-][j-];
            }
            double tmp=, pp=;
            for(int j=i;j>=;j--){
                tmp+=c[j]*pp;
                pp*=p21;
            }
            dp[i][i]=tmp/(-pp);
            dp[i][]=p21*dp[i][i]+p41;
            for(int j=;j<i;j++){
                dp[i][j]=p21*dp[i][j-]+c[j];
            }
        }
        printf("%.5f\n", dp[n][m]);
    }
    return ;
}

滚动数组优化：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string.h>
using namespace std;
const int maxn=;
double dp[][maxn];
int n,m,k;
double p4,p1,p2,p3;
double p21,p31,p41;
double c[maxn];
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        scanf("%lf%lf%lf%lf",&p1,&p2,&p3,&p4);
        if(p4<1e-)
        {
            printf("0.00000\n");
            continue;
        }
        memset(dp,,sizeof dp);
        p21=p2/(-p1);
        p31=p3/(-p1);
        p41=p4/(-p1);
        dp[][]=p4/(-p1-p2);
        double ans,sum;
        int i,j;
        int now=;
        for(i=;i<=n;i++)
        {
            now=now^;
            for(j=i;j>=;j--)
            {
                c[j]=p31*dp[now^][j-];
                if(j<=k)c[j]+=p41;
            }
            c[]=p41;
            ans=;
            sum=;
            for(j=i;j>=;j--)
            {
                sum+=ans*c[j];
                ans*=p21;
            }
            dp[now][i]=sum/(-ans);
            dp[now][]=dp[now][i];
            for(j=;j<i;j++)
            {
                dp[now][j]=p21*dp[now][j-]+c[j];
            }
        }
        printf("%.5f\n",dp[now][m]);
    }
    return ;
}