Related Articles
Railway Station | TCS CodeVita 2020
• Difficulty Level : Easy
• Last Updated : 16 Mar, 2021

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:

1. Initialize an array dp[] for memorization. Set all indices to -1 initially.
2. Define a recursive function findWays() to calculate the number of ways to reach the Nth station.
3. 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.
4. If the current state, say x, is already evaluated i.e. dp[x] is not equal to -1, simply return the evaluated value.
5. Otherwise, calculate findWays(x – 1), findWays(x – 2) and findWays(x – 3) recursively and store their sum in dp[x].
6. Return dp[x].

Below is the implementation of the above approach:

## C++14

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// Dp table for memoization``int` `dp[100000];` `// Function to count the number``// of ways to N-th station``int` `findWays(``int` `x)``{``    ``// Base Cases``    ``if` `(x < 0)``        ``return` `0;` `    ``if` `(x == 0)``        ``return` `1;` `    ``if` `(x == 1)``        ``return` `2;` `    ``if` `(x == 2)``        ``return` `4;` `    ``// If current state is``    ``// already evaluated``    ``if` `(dp[x] != -1)``        ``return` `dp[x];` `    ``// Recursive calls` `    ``// Count ways in which``    ``// train 1 can be chosen``    ``int` `count = findWays(x - 1);` `    ``// Count ways in which``    ``// train 2 can be chosen``    ``count += findWays(x - 2);` `    ``// Count ways in which``    ``// train 3 can be chosen``    ``count += findWays(x - 3);` `    ``// Store the current state``    ``dp[x] = count;` `    ``// Return the number of ways``    ``return` `dp[x];``}` `// Driver Code``int` `main()``{` `    ``// Given Input``    ``int` `n = 4;` `    ``// Initialize DP table with -1``    ``memset``(dp, -1, ``sizeof``(dp));` `    ``// Function call to count``    ``// the number of ways to``    ``// reach the n-th station``    ``cout << findWays(n) << ``"\n"``;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `  ``// Dp table for memoization``  ``static` `int` `dp[] = ``new` `int``[``100000``];` `  ``// Function to count the number``  ``// of ways to N-th station``  ``static` `int` `findWays(``int` `x)``  ``{` `    ``// Base Cases``    ``if` `(x < ``0``)``      ``return` `0``;` `    ``if` `(x == ``0``)``      ``return` `1``;` `    ``if` `(x == ``1``)``      ``return` `2``;` `    ``if` `(x == ``2``)``      ``return` `4``;` `    ``// If current state is``    ``// already evaluated``    ``if` `(dp[x] != -``1``)``      ``return` `dp[x];` `    ``// Recursive calls` `    ``// Count ways in which``    ``// train 1 can be chosen``    ``int` `count = findWays(x - ``1``);` `    ``// Count ways in which``    ``// train 2 can be chosen``    ``count += findWays(x - ``2``);` `    ``// Count ways in which``    ``// train 3 can be chosen``    ``count += findWays(x - ``3``);` `    ``// Store the current state``    ``dp[x] = count;` `    ``// Return the number of ways``    ``return` `dp[x];``  ``}` `  ``// Driven Code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Given Input``    ``int` `n = ``4``;` `    ``// Initialize DP table with -1``    ``Arrays.fill(dp, -``1``);` `    ``// Function call to count``    ``// the number of ways to``    ``// reach the n-th station``    ``System.out.print(findWays(n));``  ``}``}` `// This code is contributed by splevel62.`

## Python3

 `# Python3 program of the above approach` `# Dp table for memoization``dp ``=` `[``-``1` `for` `i ``in` `range``(``100000``)]` `# Function to count the number``# of ways to N-th station``def` `findWays(x):``    ` `    ``# Base Cases``    ``if` `(x < ``0``):``        ``return` `0` `    ``if` `(x ``=``=` `0``):``        ``return` `1` `    ``if` `(x ``=``=` `1``):``        ``return` `2` `    ``if` `(x ``=``=` `2``):``        ``return` `4` `    ``# If current state is``    ``# already evaluated``    ``if` `(dp[x] !``=` `-``1``):``        ``return` `dp[x]` `    ``# Recursive calls` `    ``# Count ways in which``    ``# train 1 can be chosen``    ``count ``=` `findWays(x ``-` `1``)` `    ``# Count ways in which``    ``# train 2 can be chosen``    ``count ``+``=` `findWays(x ``-` `2``)` `    ``# Count ways in which``    ``# train 3 can be chosen``    ``count ``+``=` `findWays(x ``-` `3``)` `    ``# Store the current state``    ``dp[x] ``=` `count` `    ``# Return the number of ways``    ``return` `dp[x]` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given Input``    ``n ``=` `4``    ` `    ``# Function call to count``    ``# the number of ways to``    ``# reach the n-th station``    ``print``(findWays(n))` `# This code is contributed by SURENDRA_GANGWAR`
Output:
`13`

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up