Railway Station | TCS CodeVita 2020
Last Updated :
27 Apr, 2023
Given an integer N, representing the number of stations lying between the source and the destination. There are three trains available from every station and their stoppage patterns are as follows:
- Train 1: Stops at every station
- Train 2: Stops at every alternate station
- Train 3: Stops at every third station
The task is to find the number of ways to reach the destination from the source using any possible combination of trains.
Examples:
Input: N = 2
Output: 4
Explanation:
Four possible ways exists to travel from source to destination with 2 stations in between:
Train 1 (from source) -> Train 1 (from station 1) -> Train 1(from station 2) -> Destination
Train 2 (from source) -> Train 1 (from station 2) -> Destination
Train 1 (from source) -> Train 2 (from station 1) -> Destination
Train 3 (from source) -> Destination
Input: N = 0
Output: 1
Explanation: No station is present in between the source and destination. Therefore, there is only one way to travel, i.e.
Train 1(from source) -> Destination
Approach: The main idea to solve the problem is to use Recursion with Memoization to solve this problem. The recurrence relation is as follows:
F(N) = F(N – 1) + F(N – 2) + F(N – 3),
where,
F(N – 1) counts ways to travel upto (N – 1)th station.
F(N – 2) counts ways to travel upto (N – 2)th station.
F(N – 3) counts ways to travel upto (N – 3)th station.
Follow the steps below to solve the problem:
- Initialize an array dp[] for memorization. Set all indices to -1 initially.
- Define a recursive function findWays() to calculate the number of ways to reach the Nth station.
- Following base cases are required to be considered:
- For x < 0 return 0.
- For x = 0, return 1.
- For x = 1, return 2.
- For x = 2, return 4.
- If the current state, say x, is already evaluated i.e. dp[x] is not equal to -1, simply return the evaluated value.
- Otherwise, calculate findWays(x – 1), findWays(x – 2) and findWays(x – 3) recursively and store their sum in dp[x].
- Return dp[x].
Below is the implementation of the above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
int dp[100000];
int findWays( int x)
{
if (x < 0)
return 0;
if (x == 0)
return 1;
if (x == 1)
return 2;
if (x == 2)
return 4;
if (dp[x] != -1)
return dp[x];
int count = findWays(x - 1);
count += findWays(x - 2);
count += findWays(x - 3);
dp[x] = count;
return dp[x];
}
int main()
{
int n = 4;
memset (dp, -1, sizeof (dp));
cout << findWays(n) << "\n" ;
}
|
Java
import java.util.*;
class GFG
{
static int dp[] = new int [ 100000 ];
static int findWays( int x)
{
if (x < 0 )
return 0 ;
if (x == 0 )
return 1 ;
if (x == 1 )
return 2 ;
if (x == 2 )
return 4 ;
if (dp[x] != - 1 )
return dp[x];
int count = findWays(x - 1 );
count += findWays(x - 2 );
count += findWays(x - 3 );
dp[x] = count;
return dp[x];
}
public static void main(String[] args)
{
int n = 4 ;
Arrays.fill(dp, - 1 );
System.out.print(findWays(n));
}
}
|
Python3
dp = [ - 1 for i in range ( 100000 )]
def findWays(x):
if (x < 0 ):
return 0
if (x = = 0 ):
return 1
if (x = = 1 ):
return 2
if (x = = 2 ):
return 4
if (dp[x] ! = - 1 ):
return dp[x]
count = findWays(x - 1 )
count + = findWays(x - 2 )
count + = findWays(x - 3 )
dp[x] = count
return dp[x]
if __name__ = = '__main__' :
n = 4
print (findWays(n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int [] dp = new int [100000];
static int findWays( int x)
{
if (x < 0)
return 0;
if (x == 0)
return 1;
if (x == 1)
return 2;
if (x == 2)
return 4;
if (dp[x] != -1)
return dp[x];
int count = findWays(x - 1);
count += findWays(x - 2);
count += findWays(x - 3);
dp[x] = count;
return dp[x];
}
public static void Main( string [] args){
int n = 4;
for ( int i = 0 ; i < dp.Length ; i++){
dp[i] = -1;
}
Console.Write(findWays(n) + "\n" );
}
}
|
Javascript
<script>
let dp = new Array(100000).fill(-1)
function findWays(x){
if (x < 0)
return 0
if (x == 0)
return 1
if (x == 1)
return 2
if (x == 2)
return 4
if (dp[x] != -1)
return dp[x]
let count = findWays(x - 1)
count += findWays(x - 2)
count += findWays(x - 3)
dp[x] = count
return dp[x]
}
let n = 4
document.write(findWays(n))
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Efficient approach : Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memorization(top-down) because memorization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Take the integer N as input.
- Initialize a DP table of size N+1 to store the number of ways to reach each station.
- Base cases: set the initial values of the DP table for the first three stations.
- Traverse the stations from 3 to N and for each station:
a. Calculate the number of ways to reach the current station by considering the number of ways to reach the two previous stations.
b. Update the DP table with the new number of ways to reach the current station.
- Return the number of ways to reach the N-th station from the DP table.
Implementation :
C++
#include <bits/stdc++.h>
using namespace std;
int findWays( int x)
{
vector< int > dp(x + 1, 0);
dp[0] = 1;
dp[1] = 2;
dp[2] = 4;
int count = dp[2];
for ( int i = 3; i <= x; i++) {
count += dp[i - 2];
count += dp[i - 3];
dp[i] = count;
}
return dp[x];
}
int main()
{
int n = 2;
cout << findWays(n) << "\n" ;
}
|
Java
import java.util.*;
public class Main
{
public static int findWays( int x)
{
int [] dp = new int [x + 1 ];
dp[ 0 ] = 1 ;
dp[ 1 ] = 2 ;
dp[ 2 ] = 4 ;
int count = dp[ 2 ];
for ( int i = 3 ; i <= x; i++)
{
count += dp[i - 2 ];
count += dp[i - 3 ];
dp[i] = count;
}
return dp[x];
}
public static void main(String[] args)
{
int n = 2 ;
System.out.println(findWays(n));
}
}
|
Python3
def findWays(x):
dp = [ 0 ] * (x + 1 )
dp[ 0 ] = 1
dp[ 1 ] = 2
dp[ 2 ] = 4
count = dp[ 2 ]
for i in range ( 3 , x + 1 ):
count + = dp[i - 2 ]
count + = dp[i - 3 ]
dp[i] = count
return dp[x]
if __name__ = = '__main__' :
n = 2
print (findWays(n))
|
C#
using System;
class Solution
{
public int findWays( int x)
{
int [] dp = new int [x + 1];
dp[0] = 1;
dp[1] = 2;
dp[2] = 4;
int count = dp[2];
for ( int i = 3; i <= x; i++)
{
count += dp[i - 2];
count += dp[i - 3];
dp[i] = count;
count = 0;
}
return dp[x];
}
}
public class Program {
static void Main( string [] args)
{
Solution obj = new Solution();
int n = 2;
Console.WriteLine(obj.findWays(n));
}
}
|
Javascript
function findWays(x) {
let dp = new Array(x + 1).fill(0);
dp[0] = 1;
dp[1] = 2;
dp[2] = 4;
let count = dp[2];
for (let i = 3; i <= x; i++)
{
count += dp[i - 2];
count += dp[i - 3];
dp[i] = count;
}
return dp[x];
}
let n = 2;
console.log(findWays(n));
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...