Kickstart Practice Round 2017 Google

Problem B. Vote

A and B are the only two candidates competing in a certain election. We know from polls that exactly N voters support A, and exactly M voters support B. We also know that N is greater than M, so A will win.

Voters will show up at the polling place one at a time, in an order chosen uniformly at random from all possible (N + M)! orders. After each voter casts their vote, the polling place worker will update the results and note which candidate (if any) is winning so far. (If the votes are tied, neither candidate is considered to be winning.)

What is the probability that A stays in the lead the entire time -- that is, that A will always be winning after every vote?

Input

The input starts with one line containing one integer T, which is the number of test cases. Each test case consists of one line with two integers N and M: the numbers of voters supporting A and B, respectively.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the probability that A will always be winning after every vote.

y will be considered correct if y is within an absolute or relative error of 10^-6 of the correct answer. See the FAQ for an explanation of what that means, and what formats of real numbers we accept.

Limits

1 ≤ T ≤ 100.

Small dataset

0 ≤ M < N ≤ 10.

Large dataset

0 ≤ M < N ≤ 2000.

Sample

Input 

2

2  1

1 0
Output 

Case #1: 0.33333333

Case #2: 1.00000000

In sample case #1, there are 3 voters. Two of them support A -- we will call them A1 and A2 -- and one of them supports B. They can come to vote in six possible orders: A1 A2 B, A2 A1 B, A1 B A2, A2 B A1, B A1 A2, B A2 A1. Only the first two of those orders guarantee that Candidate A is winning after every vote. (For example, if the order is A1 B A2, then Candidate A is winning after the first vote but tied after the second vote.) So the answer is 2/6 = 0.333333...

In sample case #2, there is only 1 voter, and that voter supports A. There is only one possible order of arrival, and A will be winning after the one and only vote.

思路：

dp[i][j]:i個A與j個B的未結束（票數領先）的情況數，則dp[i][j]=dp[i-1][j]+dp[i][j-1] 表示由i-1個A，j個B或者i個A，j-1個B轉化而來。dp[0][0]=1表示開始時未結束。

之后得到dp[n][m]為n個A，m個B的情況數，之后乘上n！*m！為總的排列數。

難點：

1.large dataset里n最大為2000，最后的排列數和dp可能大於2000!(3*10^5735)，所以需要用對數運算。

2.乘除轉化為對數加減，加法可轉化為：c=log(e^a+e^b)->c=log(e^a(1+e^(b-a)))=a+log(1+e^(b-a))  這樣就不會溢出了  :)

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define pi acos(-1.0)
#define mj
#define inf 0x3f3f3f
#define  db double
typedef  long long  ll;
using namespace std;
const int N=1e5+5;
db  dp[2002][2002];
void init()
{
    for(int i=0;i<2002;i++){
        for(int j=0;j<2002;j++)
            dp[i][j]=-1;
    }
    dp[0][0]=log(1.0);
    for(int i=0;i<2002;i++){
        for(int j=0;j<2002;j++){
            if(i>j){
                    if(dp[i-1][j]!=-1&&dp[i][j-1]!=-1) dp[i][j]=dp[i-1][j]+log(1+exp(dp[i][j-1]-dp[i-1][j]));
                    else if(dp[i-1][j]==-1&&dp[i][j-1]!=-1) dp[i][j]=dp[i][j-1];
                    else if(dp[i-1][j]!=-1&&dp[i][j-1]==-1) dp[i][j]=dp[i-1][j];
                }
        }
    }
}
int main()
{
    #ifdef mj
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif // mj
    int t,n,m;
    scanf("%d",&t);
    init();
    for(int k=1;k<=t;k++){
        scanf("%d%d",&n,&m);
        db ans=0;
        for(int i=1;i<=m;i++){
            ans+=(db)log(i)-(db)log(n+i);
        }
        ans+=(db)dp[n][m];
        ans=exp(ans);
        printf("Case #%d: %.8f\n",k,ans);
    }
    return 0;
}