Skip to content
Related Articles

Related Articles

Improve Article
Count number of ways to cover a distance
  • Difficulty Level : Easy
  • Last Updated : 18 May, 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
Explantion:
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
Explantion:
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

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
#include<iostream>
using 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 program
int 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 steps
import 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 code
dist = 4
print(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 steps
using 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.
PHP



<?php
// A naive recursive PHP program to
// count number of ways to cover
// a distance with 1, 2 and 3 steps
 
// Returns count of ways to cover 'dist'
function 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 Code
    $dist = 4;
    echo printCountRec($dist);
 
// This code is contributed by anuj_67.
?>
Javascript



<script>
 
// A naive recursive javascript program to count number of ways to cover
// a distance with 1, 2 and 3 steps
 
// Returns count of ways to cover 'dist'
function 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 program
var dist = 4;
document.write(printCountRec(dist));
 
</script>
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
#include<iostream>
using 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[0] = 1;
     if(dist >= 1)
            count[1] = 1;
     if(dist >= 2)
              count[2] = 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
int 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 steps
import 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[0] = 1;
          if(dist >= 1)
            count[1] = 1;
        if(dist >= 2)
              count[2] = 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 = [0] * (dist + 1)
     
    # Initialize base values. There is
    # one way to cover 0 and 1 distances
    # and two ways to cover 2 distance
    count[0] = 1
    if dist >= 1 :
        count[1] = 1
    if dist >= 2 :
        count[2] = 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 program
dist = 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 steps
using 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[0] = 1;
        count[1] = 1;
        count[2] = 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.
PHP



<?php
// A Dynamic Programming based PHP program
// to count number of ways to cover a
// distance with 1, 2 and 3 steps
 
function printCountDP( $dist)
{
    $count = array();
 
    // Initialize base values. There is
    // one way to cover 0 and 1 distances
    // and two ways to cover 2 distance
    $count[0] = 1; $count[1] = 1;
    $count[2] = 2;
 
    // Fill the count array
    // in bottom up manner
    for ( $i = 3; $i <= $dist; $i++)
    $count[$i] = $count[$i - 1] +
                 $count[$i - 2] +
                 $count[$i - 3];
 
    return $count[$dist];
}
 
// Driver Code
$dist = 4;
echo printCountDP($dist);
 
// This code is contributed by anuj_67.
?>
Javascript



<script>
 
// A Dynamic Programming based Javascript program
// to count number of ways to cover a distance
// with 1, 2 and 3 steps
   
// Function returns count of ways
// to cover 'dist'
function printCountDP(dist)
{
    let count = new Array(dist + 1);
     
    // Initialize base values. There is one
    // way to cover 0 and 1 distances
    // and two ways to cover 2 distance
    count[0] = 1;
    if (dist >= 1)
        count[1] = 1;
    if (dist >= 2)
        count[2] = 2;
 
    // Fill the count array
    // in bottom up manner
    for(let i = 3; i <= dist; i++)
        count[i] = count[i - 1] +
                   count[i - 2] +
                   count[i - 3];
 
    return count[dist];
}
 
// Driver code
let dist = 4;
document.write(printCountDP(dist));
   
// This code is contributed by divyeshrabadiya07
 
</script>
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
#include<iostream>
using namespace std;
  
int printCountDP(int dist)
{
        //Create the array of size 3.
        int  ways[3] , n = dist;
         
        //Initialize the bases cases
        ways[0] = 1;
        ways[1] = 1;
        ways[2] = 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 program
int main()
{
    int dist = 4;
    cout << printCountDP(dist);
    return 0;
}
Javascript



<script>
// A Dynamic Programming based javascript program to count number of ways
   
function printCountDP( dist)
{
        //Create the array of size 3.
        var  ways= [] , n = dist;
        ways.length = 3 ;
          
        //Initialize the bases cases
        ways[0] = 1;
        ways[1] = 1;
        ways[2] = 2;
          
        //Run a loop from 3 to n
        //Bottom up approach to fill the array
        for(var 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 code
 
    var dist = 4;
    document.write(printCountDP(dist));
</script>
Output : 
7
Time Complexity : O(n)
Space Complexity : O(1)
This article is contributed by Vignesh Venkatesan. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live



My Personal Notes
arrow_drop_up
Previous
Counts paths from a point to reach Origin
Next

Find the longest path in a matrix with given constraints
Recommended Articles
Page :
Count number of ways to cover a distance | Set 2
22, Jan 20
Count minimum number of fountains to be activated to cover the entire garden
16, Oct 20
Vertex Cover Problem | Set 2 (Dynamic Programming Solution for Tree)
28, Feb 15
Print all possible ways to convert one string into another string | Edit-Distance
13, Jul 18
Count number of ways to reach a given score in a game
17, Feb 15
Count number of ways to partition a set into k subsets
09, Nov 15
Count number of ways to fill a "n x 4" grid using "1 x 4" tiles
09, Mar 16
Count number of ways to jump to reach end
20, May 17
Count number of ways to reach a given score in a Matrix
27, Mar 19
Count number of ways to get Odd Sum
19, Aug 19
Count the number of ways to divide N in k groups incrementally
07, Apr 20
Count the number of ways to give ranks for N students such that same ranks are possible
01, May 20
Count number of ways to convert string S to T by performing K cyclic shifts
24, Jun 20
Count number of unique ways to paint a N x 3 grid
04, Mar 21
Count the number of ways to construct the target string
06, Apr 20
Count number of ways to reach destination in a Maze
03, Jan 17
Count the number of ways to tile the floor of size n x m using 1 x m size tiles
10, Jun 17
Count the number of ways to traverse a Matrix
09, Oct 18
Count of ways to split a given number into prime segments
31, May 20
Count number of ways to arrange first N numbers
18, Oct 19
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Number of ways to represent a number as sum of k fibonacci numbers
20, Aug 18
Number of ways to get a given sum with n number of m-faced dices
13, Jun 19
Number of distinct ways to represent a number as sum of K unique primes
07, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox