Given N number of coins, the task is to find probability of getting at least K number of heads after tossing all the N coins simultaneously.
Suppose we have 3 unbiased coins and we have to find the probability of getting at least 2 heads, so there are 23 = 8 ways to toss these coins, i.e., HHH, HHT, HTH, HTT, THH, THT, TTH, TTT Out of which there are 4 set which contain at least 2 Heads i.e., HHH, HHT, HH, THH So the probability is 4/8 or 0.5
The probability of exactly k success in n trials with probability p of success in any trial is given by:
So Probability ( getting at least 4 heads )=
Method 1 (Naive)
A Naive approach is to store the value of factorial in dp array and call it directly whenever it is required. But the problem of this approach is that we can only able to store it up to certain value, after that it will lead to overflow.
Below is the implementation of above approach
0.5 0.65625 0.118942
Time Complexity: O(n) where n < 20
Auxiliary space: O(n)
Method 2 (Dynamic Programming and Log)
Another way is to use Dynamic programming and logarithm. log() is indeed useful to store the factorial of any number without worrying about overflow. Let’s see how we use it:
At first let see how n! can be written. n! = n * (n-1) * (n-2) * (n-3) * ... * 3 * 2 * 1 Now take log on base 2 both the sides as: => log(n!) = log(n) + log(n-1) + log(n-2) + ... + log(3) + log(2) + log(1) Now whenever we need to find the factorial of any number, we can use this precomputed value. For example: Suppose if we want to find the value of nCi which can be written as: => nCi = n! / (i! * (n-i)! ) Taking log2() both sides as: => log2 (nCi) = log2 ( n! / (i! * (n-i)! ) ) => log2 (nCi) = log2 ( n! ) - log2(i!) - log2( (n-i)! ) ` Putting dp[num] = log2 (num!), we get: => log2 (nCi) = dp[n] - dp[i] - dp[n-i] But as we see in above relation there is an extra factor of 2n which tells the probability of getting i heads, so => log2 (2n) = n. We will subtract this n from above result to get the final answer: => Pi (log2 (nCi)) = dp[n] - dp[i] - dp[n-i] - n Now: Pi (nCi) = 2 dp[n] - dp[i] - dp[n-i] - n Tada! Now the questions boils down the summation of Pi for all i in [k, n] will yield the answer which can be calculated easily without overflow.
Below is C++ code to illustrate this:
0.5 0.65625 0.512613
Time Complexity: O(n)
Auxiliary space: O(n)
This approach is beneficial for large value of n ranging from 1 to 106
This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to firstname.lastname@example.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
- Coin game winner where every player has three choices
- Longest alternating subsequence
- Temple Offerings
- Modify array to maximize sum of adjacent differences
- Count of strings that can be formed using a, b and c under given constraints
- Highway Billboard Problem
- Adding two polynomials using Linked List
- Count binary strings with k times appearing adjacent two set bits
- Check if all people can vote on two machines
- Friends Pairing Problem
- Maximum points collected by two persons allowed to meet once
- Probability of Knight to remain in the chessboard
- Count all increasing subsequences
- Collect maximum coins before hitting a dead end
- Binomial Coefficient | DP-9