Activation
Time Limit: 20000/10000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1842 Accepted Submission(s): 689
Problem Description
After 4 years‘ waiting, the game "Chinese Paladin 5" finally comes out. Tomato is a crazy fan, and luckily he got the first release. Now he is at home, ready to begin his journey.
But before starting the game, he must first activate the product on the official site. There are too many passionate fans that the activation server cannot deal with all the requests at the same time, so all the players must wait in queue. Each time, the server
deals with the request of the first player in the queue, and the result may be one of the following, each has a probability:
1. Activation failed: This happens with the probability of p1. The queue remains unchanged and the server will try to deal with the same request the next time.
2. Connection failed: This happens with the probability of p2. Something just happened and the first player in queue lost his connection with the server. The server will then remove his request from the queue. After that, the player will immediately connect
to the server again and starts queuing at the tail of the queue.
3. Activation succeeded: This happens with the probability of p3. Congratulations, the player will leave the queue and enjoy the game himself.
4. Service unavailable: This happens with the probability of p4. Something just happened and the server is down. The website must shutdown the server at once. All the requests that are still in the queue will never be dealt.
Tomato thinks it sucks if the server is down while he is still waiting in the queue and there are no more than K-1 guys before him. And he wants to know the probability that this ugly thing happens.
To make it clear, we say three things may happen to Tomato: he succeeded activating the game; the server is down while he is in the queue and there are no more than K-1 guys before him; the server is down while he is in the queue and there are at least K guys
before him.
Now you are to calculate the probability of the second thing.
Input
There are no more than 40 test cases. Each case in one line, contains three integers and four real numbers: N, M (1 <= M <= N <= 2000), K (K >= 1), p1, p2, p3, p4 (0 <= p1, p2, p3, p4 <= 1, p1 + p2 + p3
+ p4 = 1), indicating there are N guys in the queue (the positions are numbered from 1 to N), and at the beginning Tomato is at the Mth position, with the probability p1, p2, p3, p4 mentioned above.
Output
A real number in one line for each case, the probability that the ugly thing happens.
The answer should be rounded to 5 digits after the decimal point.
Sample Input
2 2 1 0.1 0.2 0.3 0.4 3 2 1 0.4 0.3 0.2 0.1 4 2 3 0.16 0.16 0.16 0.52
Sample Output
0.30427 0.23280 0.90343
Source
2011 Asia Beijing Regional Contest
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4089
题目大意：n个人排队激活一个东西，初始时目标排在第m个
有以下4种情况：
1.注册失败，但是不影响队列顺序 ，概率为p1
2.连接失败，队首的人排到队尾， 概率为p2
3.注册成功，队首离开队列， 概率为p3
4.服务器崩溃，激活停止， 概率为p4
求目标排在k位以内，且服务器可能崩溃的概率
题目分析：这题的状态和转移方程并不是很难想，难就难在化简和递推上，下面给出详细分析：
dp[i][j]表示队伍里有i个人，目标排在第j个时时间可能发生的概率
dp[i][1] = dp[i][1]*p1+dp[i][i]*p2+p4 (当目标排在第一个且队里有i个人时可能目标注册失败还在第一个，可能链接失败跑到队尾，也可能服务器崩溃)
dp[i][j] = dp[i][j]*p1+dp[i][j-1]*p2+dp[i-1][j-1]*p3+p4 (j<=k) (当目标排在第j个，且在k之前时，1.第一个人可能注册失败还在第一个且目标位置不变，2.第一个人可能连接失败到队尾，这时目标位置向前移动，3.第一个人可能注册成功并离队，这时目标位置向前移动，且队伍少一人，4.服务器可能崩溃)
dp[i][j] = dp[i][j]*p1+dp[i][j-1]*p2+dp[i-1][j-1]*p3 (j>k) (该情况和 j<=k唯一的不同点就是没有p4了，很好理解，因为当目标排名在k之后时不能让服务器崩溃，否则事件就不可能发生了，我们就是在递推事件可能发生的概率)
说的这里状态和转移方程的问题解决了，接下来要解决如何递推，首先我们将状态转移方程化简得到：
令:
p21 = p2/(1-p2)
p31 = p3/(1-p1)
p41 = p4/(1-p1);
则：
dp[i][1] = dp[i][i]*p21+p41
dp[i][j] = dp[i][j-1]*p21+dp[i-1][j-1]*p31+p41; (j<=k)
dp[i][j] = dp[i][j-1]*p21+dp[i-1][j-1]*p31; (j>k)
从递推式我们可以知道当要递推dp[i][j]时dp[i-1][j-1]已经被算出来了，我们不妨用c[j]代表dp[i][j]的常数项
即dp[i][j] = dp[i][j-1]*p21 + c[j]，则c[j] = dp[i-1][j-1]*p31 + p41 ，c[1] = p41
因此我们先用递推式把c数组得到，然后要求dp[i][i]
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] = p21*(dp[i][i-1]) + c[i] = p21*(p21*dp[i][i-2] + c[i-1]) + c[i] = ... = p21*(p21*...dp[i][1] + c[2]) +... 再dp[i][1]=p21*dp[i][i] + c[1]带到上式得dp[i][i] =(p21)^i*dp[i][i] + (p21)^(i-1)c[1] + (p21)^(i-2)c[2] + ...(p21)^0c[i]再移向化简得dp[i][i]
= ∏(p21)^(i-j)c[j] / (1 - (p21)^i)由此可见，我们可以先预处理出(p21)^i，到这里这题就快搞定了，算出了dp[i][i]我们就可以得到dp[i][1]了
dp[i][1]=dp[i][i]*p21+p41，这样供递推的值都得到了，直接根据dp[i][j] =
dp[i][j-1]*p21 + c[j]递推就可以了
初始值dp[1][1]=dp[1][1]*p21+p41 即 dp[1][1]=p4 / (1-p1-p2)，还要注意的一点就是精度问题，当p4小于1e-5时，当其为不可能事件，因为题目要求的精度就是小数点后5位
很有趣的一题～
#include <cstdio>
int const MAX = 2005;
double const EPS = 1e-5;
double dp[MAX][MAX], c[MAX], p[MAX];
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) != EOF)
{
if(p4 < EPS)
{
printf("0.00000\n");
continue;
}
double p21 = p2 / (1 - p1);
double p31 = p3 / (1 - p1);
double p41 = p4 / (1 - p1);
double tmp;
p[0] = 1;
for(int i = 1; i <= n; i++)
p[i] = p[i - 1] * p21;
dp[1][1] = p4 / (1 - p1 - p2);
for(int i = 2; i <= n; i++)
{
for(int j = 1; j <= i; j++)
{
if(j <= k)
c[j] = dp[i - 1][j - 1] * p31 + p41;
else
c[j] = dp[i - 1][j - 1] * p31;
}
tmp = 0;
for(int j = 1; j <= i; j++)
tmp += p[i - j] * c[j];
dp[i][i] = tmp / (1 - p[i]);
dp[i][1] = p21 * dp[i][i] + p41;
for(int j = 2; j < i; j++)
dp[i][j] = p21 * dp[i][j - 1] + c[j];
}
printf("%.5f\n", dp[n][m]);
}
}