Count number of ways to cover a distance

• Difficulty Level : Easy
• Last Updated : 21 Aug, 2021

Given a distance ‘dist’, count total number of ways to cover the distance with 1, 2 and 3 steps.

Examples:

Input: n = 3
Output: 4
Explanation:
Below are the four ways
1 step + 1 step + 1 step
1 step + 2 step
2 step + 1 step
3 step

Input: n = 4
Output: 7
Explanation:
Below are the four ways
1 step + 1 step + 1 step + 1 step
1 step + 2 step + 1 step
2 step + 1 step + 1 step
1 step + 1 step + 2 step
2 step + 2 step
3 step + 1 step
1 step + 3 step

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Recursive solution

• Approach: There are n stairs, and a person is allowed to next step, skip one position or skip two positions. So there are n positions. The idea is standing at the ith position the person can move by i+1, i+2, i+3 position. So a recursive function can be formed where at current index i the function is recursively called for i+1, i+2 and i+3 positions.
There is another way of forming the recursive function. To reach position i, a person has to jump either from i-1, i-2 or i-3 position where i is the starting position.

• Algorithm:
1. Create a recursive function (count(int n)) which takes only one parameter.
2. Check the base cases. If the value of n is less than 0 then return 0, and if value of n is equal to zero then return 1 as it is the starting position.
3. Call the function recursively with values n-1, n-2 and n-3 and sum up the values that are returned, i.e. sum = count(n-1) + count(n-2) + count(n-3).
4. Return the value of sum.
• Implementation:

C++

 // A naive recursive C++ program to count number of ways to cover// a distance with 1, 2 and 3 steps#includeusing namespace std; // Returns count of ways to cover 'dist'int printCountRec(int dist){    // Base cases    if (dist<0)      return 0;    if (dist==0)  return 1;     // Recur for all previous 3 and add the results    return printCountRec(dist-1) +           printCountRec(dist-2) +           printCountRec(dist-3);} // driver programint main(){    int dist = 4;    cout << printCountRec(dist);    return 0;}

Java

 // A naive recursive Java program to count number// of ways to cover a distance with 1, 2 and 3 stepsimport java.io.*; class GFG{    // Function returns count of ways to cover 'dist'    static int printCountRec(int dist)    {        // Base cases        if (dist<0)               return 0;        if (dist==0)               return 1;          // Recur for all previous 3 and add the results        return printCountRec(dist-1) +               printCountRec(dist-2) +               printCountRec(dist-3);    }         // driver program    public static void main (String[] args)    {        int dist = 4;        System.out.println(printCountRec(dist));    }} // This code is contributed by Pramod Kumar

Python3

 # A naive recursive Python3 program# to count number of ways to cover# a distance with 1, 2 and 3 steps # Returns count of ways to# cover 'dist'def printCountRec(dist):         # Base cases    if dist < 0:        return 0             if dist == 0:        return 1     # Recur for all previous 3 and         # add the results    return (printCountRec(dist-1) +            printCountRec(dist-2) +            printCountRec(dist-3)) # Driver codedist = 4print(printCountRec(dist))# This code is contributed by Anant Agarwal.

C#

 // A naive recursive C# program to// count number of ways to cover a// distance with 1, 2 and 3 stepsusing System; class GFG {         // Function returns count of    // ways to cover 'dist'    static int printCountRec(int dist)    {        // Base cases        if (dist < 0)            return 0;        if (dist == 0)            return 1;         // Recur for all previous 3        // and add the results        return printCountRec(dist - 1) +               printCountRec(dist - 2) +               printCountRec(dist - 3);    }         // Driver Code    public static void Main ()    {        int dist = 4;        Console.WriteLine(printCountRec(dist));    }} // This code is contributed by Sam007.



Javascript



Output:

7
• Complexity Analysis:
• Time Complexity: O(3n).
The time complexity of the above solution is exponential, a close upper bound is O(3n). From each state 3, a recursive function is called. So the upper bound for n states is O(3n).
• Space complexity: O(1).
No extra space is required.

Efficient solution

• Approach: The idea is similar, but it can be observed that there are n states but the recursive function is called 3 ^ n times. That means that some states are called repeatedly. So the idea is to store the value of states. This can be done in two ways.
• Algorithm:
1. Create an array of size n + 1 and initialize the first 3 variables with 1, 1, 2. The base cases.
2. Run a loop from 3 to n.
3. For each index i, compute value of ith position as dp[i] = dp[i-1] + dp[i-2] + dp[i-3].
4. Print the value of dp[n], as the Count of number of ways to cover a distance.
• Implementation:

C++

 // A Dynamic Programming based C++ program to count number of ways// to cover a distance with 1, 2 and 3 steps#includeusing namespace std; int printCountDP(int dist){    int count[dist+1];     // Initialize base values. There is one way to cover 0 and 1    // distances and two ways to cover 2 distance     count = 1;     if(dist >= 1)            count = 1;     if(dist >= 2)              count = 2;     // Fill the count array in bottom up manner    for (int i=3; i<=dist; i++)       count[i] = count[i-1] + count[i-2] + count[i-3];     return count[dist];} // driver programint main(){    int dist = 4;    cout << printCountDP(dist);    return 0;}

Java

 // A Dynamic Programming based Java program// to count number of ways to cover a distance// with 1, 2 and 3 stepsimport java.io.*; class GFG{    // Function returns count of ways to cover 'dist'    static int printCountDP(int dist)    {        int[] count = new int[dist+1];          // Initialize base values. There is one way to        // cover 0 and 1 distances and two ways to        // cover 2 distance        count = 1;          if(dist >= 1)            count = 1;        if(dist >= 2)              count = 2;          // Fill the count array in bottom up manner        for (int i=3; i<=dist; i++)            count[i] = count[i-1] + count[i-2] + count[i-3];          return count[dist];    }         // driver program    public static void main (String[] args)    {        int dist = 4;        System.out.println(printCountDP(dist));    }} // This code is contributed by Pramod Kumar

Python3

 # A Dynamic Programming based on Python3# program to count number of ways to# cover a distance with 1, 2 and 3 steps def printCountDP(dist):    count =  * (dist + 1)         # Initialize base values. There is    # one way to cover 0 and 1 distances    # and two ways to cover 2 distance    count = 1    if dist >= 1 :        count = 1    if dist >= 2 :        count = 2         # Fill the count array in bottom    # up manner    for i in range(3, dist + 1):        count[i] = (count[i-1] +                   count[i-2] + count[i-3])             return count[dist]; # driver programdist = 4;print( printCountDP(dist)) # This code is contributed by Sam007.

C#

 // A Dynamic Programming based C# program// to count number of ways to cover a distance// with 1, 2 and 3 stepsusing System; class GFG {         // Function returns count of ways    // to cover 'dist'    static int printCountDP(int dist)    {        int[] count = new int[dist + 1];         // Initialize base values. There is one        // way to cover 0 and 1 distances        // and two ways to cover 2 distance        count = 1;        count = 1;        count = 2;         // Fill the count array        // in bottom up manner        for (int i = 3; i <= dist; i++)            count[i] = count[i - 1] +                       count[i - 2] +                       count[i - 3];         return count[dist];    }         // Driver Code    public static void Main ()    {        int dist = 4;        Console.WriteLine(printCountDP(dist));    }} // This code is contributed by Sam007.



Javascript



Output :

7
• Complexity Analysis:
• Time Complexity: O(n).
Only one traversal of the array is needed. So Time Complexity is O(n)
• Space complexity: O(n).
To store the values in a DP O(n) extra space is needed.

More Optimal Solution

Approach: Instead of using array of size n+1 we can use array of size 3 because for calculating no of ways for a particular step we need only last     3 steps no of ways.

Algorithm:

1. Create an array of size 3 and initialize the values for step 0,1,2 as 1,1,2 (Base cases).
2. Run a loop from 3 to n(dist).
3. For each index compute the value as ways[i%3] = ways[(i-1)%3] + ways[(i-2)%3] + ways[(i-3)%3] and store its value at i%3 index of array ways. If we are computing value for index 3 then the computed value will go at index 0 because for larger indices(4 ,5,6…..) we don’t need the value of index 0.
4. Return the value of ways[n%3].

C++

 // A Dynamic Programming based C++ program to count number of ways#includeusing namespace std;  int printCountDP(int dist){        //Create the array of size 3.        int  ways , n = dist;                 //Initialize the bases cases        ways = 1;        ways = 1;        ways = 2;                 //Run a loop from 3 to n        //Bottom up approach to fill the array        for(int i=3 ;i<=n ;i++)            ways[i%3] = ways[(i-1)%3] + ways[(i-2)%3] + ways[(i-3)%3];                 return ways[n%3];}  // driver programint main(){    int dist = 4;    cout << printCountDP(dist);    return 0;}

Java

 // A Dynamic Programming based Java program to count number of waysimport java.util.*;  class GFG {  static int printCountDP(int dist){        // Create the array of size 3.        int []ways = new int;        int n = dist;                          // Initialize the bases cases        ways = 1;        ways = 1;        ways = 2;                 // Run a loop from 3 to n        // Bottom up approach to fill the array        for(int i=3 ;i<=n ;i++)            ways[i%3] = ways[(i-1)%3] + ways[(i-2)%3] + ways[(i-3)%3];                 return ways[n%3];}  // driver programpublic static void main(String arg[])    {    int dist = 4;    System.out.print(printCountDP(dist));    }} // this code is contributed by shivanisinghss2110

Python3

 # A Dynamic Programming based C++ program to count number of waysdef prCountDP( dist):         # Create the array of size 3.        ways = *3        n = dist                 # Initialize the bases cases        ways = 1        ways = 1        ways = 2                 # Run a loop from 3 to n        # Bottom up approach to fill the array        for i in range(3, n + 1):            ways[i % 3] = ways[(i - 1) % 3] + ways[(i - 2) % 3] + ways[(i - 3) % 3]                 return ways[n % 3]  # driver programdist = 4print(prCountDP(dist)) # This code is contributed by shivanisinghss2110

C#

 // A Dynamic Programming based C#// program to count number of waysusing System;  class GFG{  static int printCountDP(int dist){    // Create the array of size 3.    int []ways = new int;    int n = dist;         // Initialize the bases cases    ways = 1;    ways = 1;    ways = 2;         // Run a loop from 3 to n    // Bottom up approach to fill the array    for(int i = 3; i <= n; i++)        ways[i % 3] = ways[(i - 1) % 3] +                      ways[(i - 2) % 3] +                      ways[(i - 3) % 3];         return ways[n % 3];}  // Driver codepublic static void Main(String []arg){    int dist = 4;         Console.Write(printCountDP(dist));}} // This code is contributed by shivanisinghss2110

Javascript



Output :

7

Time Complexity : O(n)

Space Complexity : O(1)