 Open in App
Not now

# Probability of reaching a point with 2 or 3 steps at a time

• Difficulty Level : Easy
• Last Updated : 30 Mar, 2023

A person starts walking from position X = 0, find the probability to reach exactly on X = N if she can only take either 2 steps or 3 steps. Probability for step length 2 is given i.e. P, probability for step length 3 is 1 – P.
Examples :

```Input : N = 5, P = 0.20
Output : 0.32
Explanation :-
There are two ways to reach 5.
2+3 with probability = 0.2 * 0.8 = 0.16
3+2 with probability = 0.8 * 0.2 = 0.16
So, total probability = 0.32.```

It is a simple dynamic programming problem. It is simple extension of this problem :- count-ofdifferent-ways-express-n-sum-1-3-4
Below is the implementation of the above approach.

## C++

 `// CPP Program to find probability to``// reach N with P probability to take``// 2 steps (1-P) to take 3 steps``#include ``using` `namespace` `std;` `// Returns probability to reach N``float` `find_prob(``int` `N, ``float` `P)``{``    ``double` `dp[N + 1];``    ``dp = 1;``    ``dp = 0;``    ``dp = P;``    ``dp = 1 - P;``    ``for` `(``int` `i = 4; i <= N; ++i)``        ``dp[i] = (P)*dp[i - 2] + (1 - P) * dp[i - 3];` `    ``return` `dp[N];``}` `// Driver code``int` `main()``{``    ``int` `n = 5;``    ``float` `p = 0.2;``    ``cout << find_prob(n, p);``    ``return` `0;``}`

## Java

 `// Java Program to find probability to``// reach N with P probability to take``// 2 steps (1-P) to take 3 steps``import` `java.io.*;` `class` `GFG {``    ` `    ``// Returns probability to reach N``    ``static` `float` `find_prob(``int` `N, ``float` `P)``    ``{``        ``double` `dp[] = ``new` `double``[N + ``1``];``        ``dp[``0``] = ``1``;``        ``dp[``1``] = ``0``;``        ``dp[``2``] = P;``        ``dp[``3``] = ``1` `- P;``    ` `        ``for` `(``int` `i = ``4``; i <= N; ++i)``          ``dp[i] = (P) * dp[i - ``2``] +``                        ``(``1` `- P) * dp[i - ``3``];``    ` `        ``return` `((``float``)(dp[N]));``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``5``;``        ``float` `p = ``0``.2f;``        ``System.out.printf(``"%.2f"``,find_prob(n, p));``    ``}``}`  `/* This code is contributed by Nikita Tiwari.*/`

## Python3

 `# Python 3 Program to find``# probability to reach N with``# P probability to take 2``# steps (1-P) to take 3 steps` `# Returns probability to reach N``def` `find_prob(N, P) :``    ` `    ``dp ``=``[``0``] ``*` `(n ``+` `1``)``    ``dp[``0``] ``=` `1``    ``dp[``1``] ``=` `0``    ``dp[``2``] ``=` `P``    ``dp[``3``] ``=` `1` `-` `P``    ` `    ``for` `i ``in` `range``(``4``, N ``+` `1``) :``        ``dp[i] ``=` `(P) ``*` `dp[i ``-` `2``] ``+` `(``1` `-` `P) ``*` `dp[i ``-` `3``]` `    ``return` `dp[N]` `# Driver code``n ``=` `5``p ``=` `0.2``print``(``round``(find_prob(n, p), ``2``))` `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# Program to find probability to``// reach N with P probability to take``// 2 steps (1-P) to take 3 steps``using` `System;` `class` `GFG {``    ` `    ``// Returns probability to reach N``    ``static` `float` `find_prob(``int` `N, ``float` `P)``    ``{``        ``double` `[]dp = ``new` `double``[N + 1];``        ``dp = 1;``        ``dp = 0;``        ``dp = P;``        ``dp = 1 - P;``    ` `        ``for` `(``int` `i = 4; i <= N; ++i)``        ``dp[i] = (P) * dp[i - 2] +``                ``(1 - P) * dp[i - 3];``    ` `        ``return` `((``float``)(dp[N]));``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 5;``        ``float` `p = 0.2f;``        ``Console.WriteLine(find_prob(n, p));``    ``}``}`  `/* This code is contributed by vt_m.*/`

## PHP

 ``

## Javascript

 ``

Output :

`0.32`

Time Complexity: O(n)

Auxiliary Space: O(n)

Efficient approach : Space optimization O(1)

In previous approach the current value dp[i] is only depend on the previous 2 values of dp i.e. dp[i-2] and dp[i-3]. So to optimize the space complexity we can store previous 4 values of Dp in 4 variables  his way, the space complexity will be reduced from O(N) to O(1)

Implementation Steps:

• Initialize variables for dp, dp, dp, and dp as 1, 0, P, and 1-P respectively.
• Iterate from i = 4 to N and use the formula dp[i] = (P)*dp[i – 2] + (1 – P) * dp[i – 3] to compute the current value of dp.
• After each iteration, update the values of dp0, dp1, dp2, and dp3 to dp1, dp2, dp3, and curr respectively.
• Return the final value of curr.

Implementation:

## C++

 `// CPP Program to find probability to``// reach N with P probability to take``// 2 steps (1-P) to take 3 steps``#include ``using` `namespace` `std;` `// Returns probability to reach N``float` `find_prob(``int` `N, ``float` `P)``{   ``      ``// to store current value``    ``double` `curr;``    ` `      ``// store previous 4 values of DP``    ``double` `dp0 = 1, dp1=0, dp2=P, dp3= 1-P;``    ` `      ``// iterate over subproblems to get``      ``// current solution from previous computations``    ``for` `(``int` `i = 4; i <= N; ++i){``        ``curr = (P)*dp2 + (1 - P) * dp1;``      ` `          ``// assigning values to iterate further``        ``dp0=dp1;``        ``dp1=dp2;``        ``dp2=dp3;``        ``dp3=curr;``    ``}``    ` `      ``// return final answer``    ``return` `curr;``}` `// Driver code``int` `main()``{``    ``int` `n = 5;``    ``float` `p = 0.2;``    ``cout << find_prob(n, p);``    ``return` `0;``}`

Output

`0.32`

Time complexity: O(N)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up