Count ways to reach Nth Stairs by taking 1 and 2 steps with exactly one 3 step

Given the number N which denotes the number of stairs, the task is to reach the N^th stair by taking 1, 2 steps any number of times and taking a step of 3 exactly once. 

Examples:

Input: N = 4 
Output: 2 
Explanation:
Since a step of 3 has to be taken compulsorily and only once, 
There are only two possible ways: (1, 3) or (3, 1)

Input: N = 5 
Output: 5 
Explanation:
Since a step of 3 has to be taken compulsorily and only once, 
There are only 5 possible ways: 
(1, 1, 3), (1, 3, 1), (3, 1, 1), (2, 3), (3, 2)

Approach: This problem can be solved using Dynamic Programming. To Reach N^th stair the person should be on (N – 1)^th, (N – 2)^th or (N – 3)^th. So, To reach N^th stair from the base Reach (N – 1)^th stair which includes exact only one step of 3, Reach (N – 2)^th step with the steps which includes exactly one step of 3 and Reach the (N – 3)^th step without taking any step of 3. 
So, The Recurrence Relation for this problem will be – 

includes_3[i] = includes_3[i-1] + includes_3[i-2] + not_includes[i-3] 

whereas, the Recurrence relation when the 3 number of steps at a time is not allowed is 

not_includes[i] = not_includes[i – 1] + not_includes[i – 2] 

Below is the implementation of the above approach:

C++

// C++ implementation to find the number
// the number of ways to reach Nth stair
// by taking 1, 2 step at a time and
// 3 Steps at a time exactly once.

#include <iostream>
using namespace std;

// Function to find the number
// the number of ways to reach Nth stair
int number_of_ways(int n)
{
    // Array including number
    // of ways that includes 3
    int includes_3[n + 1] = {};

    // Array including number of
    // ways that doesn't includes 3
    int not_includes_3[n + 1] = {};

    // Initially to reach 3 stairs by
    // taking 3 steps can be
    // reached by 1 way
    includes_3[3] = 1;

    not_includes_3[1] = 1;
    not_includes_3[2] = 2;
    not_includes_3[3] = 3;

    // Loop to find the number
    // the number of ways to reach Nth stair
    for (int i = 4; i <= n; i++) {
        includes_3[i]
            = includes_3[i - 1] + includes_3[i - 2] + not_includes_3[i - 3];
        not_includes_3[i]
            = not_includes_3[i - 1] + not_includes_3[i - 2];
    }
    return includes_3[n];
}

// Driver Code
int main()
{
    int n = 7;

    cout << number_of_ways(n);

    return 0;
}

Java

// Java implementation to find the number
// the number of ways to reach Nth stair
// by taking 1, 2 step at a time and
// 3 Steps at a time exactly once.
class GFG
{

// Function to find the number
// the number of ways to reach Nth stair
static int number_of_ways(int n)
{
    // Array including number
    // of ways that includes 3
    int []includes_3 = new int[n + 1];

    // Array including number of
    // ways that doesn't includes 3
    int []not_includes_3 = new int[n + 1];

    // Initially to reach 3 stairs by
    // taking 3 steps can be
    // reached by 1 way
    includes_3[3] = 1;

    not_includes_3[1] = 1;
    not_includes_3[2] = 2;
    not_includes_3[3] = 3;

    // Loop to find the number
    // the number of ways to reach Nth stair
    for (int i = 4; i <= n; i++)
    {
        includes_3[i]
            = includes_3[i - 1] + includes_3[i - 2] +
               not_includes_3[i - 3];
        not_includes_3[i]
            = not_includes_3[i - 1] + not_includes_3[i - 2];
    }
    return includes_3[n];
}

// Driver Code
public static void main(String[] args)
{
    int n = 7;

    System.out.print(number_of_ways(n));
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 implementation to find the number
# the number of ways to reach Nth stair
# by taking 1, 2 step at a time and
# 3 Steps at a time exactly once.

# Function to find the number
# the number of ways to reach Nth stair
def number_of_ways(n):

    # Array including number
    # of ways that includes 3
    includes_3 = [0]*(n + 1)

    # Array including number of
    # ways that doesn't includes 3
    not_includes_3 = [0] * (n + 1)

    # Initially to reach 3 stairs by
    # taking 3 steps can be
    # reached by 1 way
    includes_3[3] = 1

    not_includes_3[1] = 1
    not_includes_3[2] = 2
    not_includes_3[3] = 3

    # Loop to find the number
    # the number of ways to reach Nth stair
    for i in range(4, n + 1):
        includes_3[i] = includes_3[i - 1] + \
                        includes_3[i - 2] + \
                        not_includes_3[i - 3]
        not_includes_3[i] = not_includes_3[i - 1] + \
                           not_includes_3[i - 2]
    return includes_3[n]

# Driver Code
n = 7

print(number_of_ways(n))

# This code is contributed by mohit kumar 29

C#

// C# implementation to find the number
// the number of ways to reach Nth stair
// by taking 1, 2 step at a time and
// 3 Steps at a time exactly once.
using System;

class GFG
{

// Function to find the number
// the number of ways to reach Nth stair
static int number_of_ways(int n)
{
    // Array including number
    // of ways that includes 3
    int []includes_3 = new int[n + 1];

    // Array including number of
    // ways that doesn't includes 3
    int []not_includes_3 = new int[n + 1];

    // Initially to reach 3 stairs by
    // taking 3 steps can be
    // reached by 1 way
    includes_3[3] = 1;

    not_includes_3[1] = 1;
    not_includes_3[2] = 2;
    not_includes_3[3] = 3;

    // Loop to find the number
    // the number of ways to reach Nth stair
    for (int i = 4; i <= n; i++)
    {
        includes_3[i]
            = includes_3[i - 1] + includes_3[i - 2] +
            not_includes_3[i - 3];
        not_includes_3[i]
            = not_includes_3[i - 1] + not_includes_3[i - 2];
    }
    return includes_3[n];
}

// Driver Code
public static void Main(String[] args)
{
    int n = 7;

    Console.Write(number_of_ways(n));
}
}

// This code is contributed by PrinciRaj1992

Javascript

<script>

// JavaScript implementation to find the number
// the number of ways to reach Nth stair
// by taking 1, 2 step at a time and
// 3 Steps at a time exactly once.

// Function to find the number
// the number of ways to reach Nth stair
function number_of_ways(n)
{
    // Array including number
    // of ways that includes 3
    let includes_3 = new Uint8Array(n + 1);

    // Array including number of
    // ways that doesn't includes 3
    let not_includes_3 = new Uint8Array(n + 1);

    // Initially to reach 3 stairs by
    // taking 3 steps can be
    // reached by 1 way
    includes_3[3] = 1;

    not_includes_3[1] = 1;
    not_includes_3[2] = 2;
    not_includes_3[3] = 3;

    // Loop to find the number
    // the number of ways to reach Nth stair
    for (let i = 4; i <= n; i++) {
        includes_3[i]
            = includes_3[i - 1] + includes_3[i - 2] + not_includes_3[i - 3];
        not_includes_3[i]
            = not_includes_3[i - 1] + not_includes_3[i - 2];
    }
    return includes_3[n];
}

// Driver Code

    let n = 7;

    document.write(number_of_ways(n));



// This code is contributed by Surbhi Tyagi.

</script>

Output

20

Time complexity: O(n) where N is given the number of stairs
Auxiliary space: O(n)

Efficient approach: Space Optimization O(1)

The above approach includes_3 and not_includes_3, each of size n + 1. However, we can observe that at any given point in the loop, we only need the values of the arrays for the current iteration and the previous two iterations. So to optimize the space complexity, we can replace the arrays with three variables that store the necessary values. 

Implementation Steps:

• Initialize variables: in1, in2, in3, incurr, not_in1, not_in2, not_in3, not_incurr.
• Set the initial value of in3 to 1.
• Iterate from i = 4 to n.
• Calculate the current value of incurr by summing the previous values of in3, in2, and not_in1.
• Calculate the current value of not_incurr by summing the previous values of not_in3 and not_in2.
• Update variables for the next iteration by shifting the values.
• Return the final value of incurr.

Implementation:

C++

#include <iostream>
using namespace std;

// Function to find the number
// the number of ways to reach Nth stair
int number_of_ways(int n)
{
    int in1, in2 = 0, in3, incurr;
    int not_in1 = 1, not_in2 = 2, not_in3 = 3, not_incurr;

    in3 = 1;  // Set the initial value for in3

    for (int i = 4; i <= n; i++) {
        // Calculate the current value for incurr by summing the previous values
        incurr = in3 + in2 + not_in1;

        // Calculate the current value for not_incurr by summing the previous values
        not_incurr = not_in3 + not_in2;

        // Update the variables for the next iteration
        in1 = in2;
        in2 = in3;
        in3 = incurr;

        not_in1 = not_in2;
        not_in2 = not_in3;
        not_in3 = not_incurr;
    }

    return incurr;  // Return the final result
}

// Driver Code
int main()
{
    int n = 7;
    cout << number_of_ways(n);  // Print the result

    return 0;
}

Python3

# Function to find the number
# of ways to reach Nth stair
def number_of_ways(n):
    in1, in2 = 0, 0
    in3, incurr = 1, 0
    not_in1, not_in2, not_in3, not_incurr = 1, 2, 3, 0

    in3 = 1  # Set the initial value for in3

    for i in range(4, n + 1):
        # Calculate the current value for incurr by summing the previous values
        incurr = in3 + in2 + not_in1

        # Calculate the current value for not_incurr by summing the previous values
        not_incurr = not_in3 + not_in2

        # Update the variables for the next iteration
        in1, in2, in3 = in2, in3, incurr

        not_in1, not_in2, not_in3 = not_in2, not_in3, not_incurr

    return incurr  # Return the final result

# Driver Code
def main():
    n = 7
    print(number_of_ways(n))  # Print the result

main()

C#

using System;

class Program {
    // Function to find the number of ways to reach the Nth
    // stair
    static int NumberOfWays(int n)
    {
        int in2 = 0, in3 = 1, incurr;
        int not_in1 = 1, not_in2 = 2, not_in3 = 3,
            not_incurr;

        incurr = 0; // Initialize incurr
        not_incurr = 0; // Initialize not_incurr

        for (int i = 4; i <= n; i++) {
            // Calculate the current value for incurr by
            // summing the previous values
            incurr = in3 + in2 + not_in1;

            // Calculate the current value for not_incurr by
            // summing the previous values
            not_incurr = not_in3 + not_in2;

            // Update the variables for the next iteration
            in2 = in3;
            in3 = incurr;

            not_in1 = not_in2;
            not_in2 = not_in3;
            not_in3 = not_incurr;
        }

        return incurr; // Return the final result
    }

    // Driver Code
    static void Main()
    {
        int n = 7;
        Console.WriteLine(
            NumberOfWays(n)); // Print the result
    }
}

Javascript

// Function to find the number
// the number of way to reach Nth stair
function numberOfWays(n) {
    let in1, in2 = 0, in3, inCurr;
    let not_in1 = 1, not_in2 = 2, not_in3 = 3, not_inCurr;

    in3 = 1; // Set the initial value for in3

    for (let i = 4; i <= n; i++) {
        // Calculate the current value for inCurr by summing the previous values
        inCurr = in3 + in2 + not_in1;
        // Calculate the current value for not_inCurr by summing the previous values
        not_inCurr = not_in3 + not_in2;
        // Update the variables for the next iteration
        in1 = in2;
        in2 = in3;
        in3 = inCurr;
        not_in1 = not_in2;
        not_in2 = not_in3;
        not_in3 = not_inCurr;
    }
    return inCurr; // Return the final result
}
// Driver Code
function main() {
    const n = 7;
    console.log(numberOfWays(n)); // Print the result
}
main();

Output: 

20

Time complexity: O(n) where N is given the number of stairs
Auxiliary space: O(1)

Similar Article: Count ways to reach Nth Stair using 1, 2 or 3 steps at a time