Given an integer N, representing the number of stairs, valued from 1 to N, and a starting position S, the task is to count the maximum number of unique stairs that can be reached by moving exactly A or B stairs steps forward or backward from any position, any number of times.
Examples:
Input: N = 10, S = 2, A = 5, B = 7
Output: 4
Explanation:
Starting Position S: Stair 2
From Stair 2, it is possible to reach the stairs 7, i.e. ( S + A ), and 9, i.e. (S + B).
From Stair 9, it is possible to reach stair 4, i.e. ( S – A ).
Therefore, the unique number of stairs that can be reached is 4 {2, 4, 7, 9}.Input: N = 10, S = 2, A = 3, B = 4
Output: 10
Approach: The given problem can be solved using BFS traversal technique. Follow the steps below to solve the problem:
- Initialize a queue and an array vis[] of size (N + 1) and initialize it as false.
- Mark the starting node S as visited i.e., vis[S] as 1. Push S into a queue Q.
- Now iterate until Q is not empty and perform the following steps:
- Pop the front element of the queue and store it in a variable, say currStair.
- Consider all 4 possible types of moves from currStair, i.e. {+A, -A, +B, -B}.
- For every new stair, check whether it is a valid and unvisited stair or not. If found to be true, then push it into Q. Mark the stair as visited. Otherwise, continue.
- Finally, count the number of visited stairs using the array vis[].
- After completing the above steps, print the count of visited stairs as the result.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to count the number // of unique stairs visited void countStairs( int n, int x, int a, int b)
{ // Checks whether the current
// stair is visited or not
int vis[n + 1] = { 0 };
// Store the possible moves
// from the current position
int moves[] = { +a, -a, +b, -b };
// Initialize a queue
queue< int > q;
/// Push the starting position
q.push(x);
// Mark the starting
// position S as visited
vis[x] = 1;
// Iterate until queue is not empty
while (!q.empty()) {
// Store the current stair number
int currentStair = q.front();
// Pop it from the queue
q.pop();
// Check for all possible moves
// from the current stair
for ( int j = 0; j < 4; j++) {
// Store the new stair number
int newStair = currentStair + moves[j];
// If it is valid and unvisited
if (newStair > 0 && newStair <= n
&& !vis[newStair]) {
// Push it into queue
q.push(newStair);
// Mark the stair as visited
vis[newStair] = 1;
}
}
}
// Store the result
int cnt = 0;
// Count the all visited stairs
for ( int i = 1; i <= n; i++)
if (vis[i] == 1)
cnt++;
// Print the result
cout << cnt;
} // Driver Code int main()
{ int N = 10, S = 2, A = 5, B = 7;
countStairs(N, S, A, B);
return 0;
} |
// Java program for the above approach import java.util.LinkedList;
import java.util.Queue;
class GFG{
// Function to count the number // of unique stairs visited static void countStairs( int n, int x, int a, int b)
{ // Checks whether the current
// stair is visited or not
int [] vis = new int [n + 1 ];
// Store the possible moves
// from the current position
int [] moves = { +a, -a, +b, -b };
// Initialize a queue
Queue<Integer> q = new LinkedList<Integer>();
/// Push the starting position
q.add(x);
// Mark the starting
// position S as visited
vis[x] = 1 ;
// Iterate until queue is not empty
while (!q.isEmpty())
{
// Store the current stair number
int currentStair = q.peek();
// Pop it from the queue
q.remove();
// Check for all possible moves
// from the current stair
for ( int j = 0 ; j < 4 ; j++)
{
// Store the new stair number
int newStair = currentStair + moves[j];
// If it is valid and unvisited
if (newStair > 0 && newStair <= n &&
vis[newStair] == 0 )
{
// Push it into queue
q.add(newStair);
// Mark the stair as visited
vis[newStair] = 1 ;
}
}
}
// Store the result
int cnt = 0 ;
// Count the all visited stairs
for ( int i = 1 ; i <= n; i++)
if (vis[i] == 1 )
cnt++;
// Print the result
System.out.print(cnt);
} // Driver Code public static void main(String args[])
{ int N = 10 , S = 2 , A = 5 , B = 7 ;
countStairs(N, S, A, B);
} } // This code is contributed by abhinavjain194 |
# Python3 program for the above approach from collections import deque
# Function to count the number # of unique stairs visited def countStairs(n, x, a, b):
# Checks whether the current
# stair is visited or not
vis = [ 0 ] * (n + 1 )
# Store the possible moves
# from the current position
moves = [ + a, - a, + b, - b]
# Initialize a queue
q = deque()
# Push the starting position
q.append(x)
# Mark the starting
# position S as visited
vis[x] = 1
# Iterate until queue is not empty
while ( len (q) > 0 ):
# Store the current stair number
currentStair = q.popleft()
# Pop it from the queue
# q.pop()
# Check for all possible moves
# from the current stair
for j in range ( 4 ):
# Store the new stair number
newStair = currentStair + moves[j]
# If it is valid and unvisited
if (newStair > 0 and newStair < = n and
( not vis[newStair])):
# Push it into queue
q.append(newStair)
# Mark the stair as visited
vis[newStair] = 1
# Store the result
cnt = 0
# Count the all visited stairs
for i in range ( 1 , n + 1 ):
if (vis[i] = = 1 ):
cnt + = 1
# Print the result
print (cnt)
# Driver Code if __name__ = = '__main__' :
N, S, A, B = 10 , 2 , 5 , 7
countStairs(N, S, A, B)
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to count the number // of unique stairs visited static void countStairs( int n, int x,
int a, int b)
{ // Checks whether the current
// stair is visited or not
int []vis = new int [n + 1];
Array.Clear(vis, 0, vis.Length);
// Store the possible moves
// from the current position
int []moves = { +a, -a, +b, -b };
// Initialize a queue
Queue< int > q = new Queue< int >();
/// Push the starting position
q.Enqueue(x);
// Mark the starting
// position S as visited
vis[x] = 1;
// Iterate until queue is not empty
while (q.Count > 0)
{
// Store the current stair number
int currentStair = q.Peek();
// Pop it from the queue
q.Dequeue();
// Check for all possible moves
// from the current stair
for ( int j = 0; j < 4; j++)
{
// Store the new stair number
int newStair = currentStair + moves[j];
// If it is valid and unvisited
if (newStair > 0 && newStair <= n &&
vis[newStair] == 0)
{
// Push it into queue
q.Enqueue(newStair);
// Mark the stair as visited
vis[newStair] = 1;
}
}
}
// Store the result
int cnt = 0;
// Count the all visited stairs
for ( int i = 1; i <= n; i++)
if (vis[i] == 1)
cnt++;
// Print the result
Console.WriteLine(cnt);
} // Driver Code public static void Main()
{ int N = 10, S = 2, A = 5, B = 7;
countStairs(N, S, A, B);
} } // This code is contributed by ipg2016107 |
<script> // Javascript program for the above approach // Function to count the number // of unique stairs visited function countStairs(n, x, a, b)
{ // Checks whether the current
// stair is visited or not
var vis = Array(n+1).fill(0);
// Store the possible moves
// from the current position
var moves = [ +a, -a, +b, -b ];
// Initialize a queue
var q = [];
/// Push the starting position
q.push(x);
// Mark the starting
// position S as visited
vis[x] = 1;
// Iterate until queue is not empty
while (q.length!=0) {
// Store the current stair number
var currentStair = q[0];
// Pop it from the queue
q.shift();
// Check for all possible moves
// from the current stair
for ( var j = 0; j < 4; j++) {
// Store the new stair number
var newStair = currentStair + moves[j];
// If it is valid and unvisited
if (newStair > 0 && newStair <= n
&& !vis[newStair]) {
// Push it into queue
q.push(newStair);
// Mark the stair as visited
vis[newStair] = 1;
}
}
}
// Store the result
var cnt = 0;
// Count the all visited stairs
for ( var i = 1; i <= n; i++)
if (vis[i] == 1)
cnt++;
// Print the result
document.write( cnt);
} // Driver Code var N = 10, S = 2, A = 5, B = 7;
countStairs(N, S, A, B); </script> |
4
Time Complexity: O(N)
Auxiliary Space: O(N)