Given N stations and three trains A, B, and C such that train A stops at every station, train B stops at every second station, and train C stops at every third station, the task is to find the number of ways to reach the Nth station can be reached from station 1.
Examples:
Input: N = 4
Output: 3
Explanation:
Below are the ways of reaching station 4 from station 1 as follows:
- Take train A at station 1 and continue to station 4 using only train A as (A ? A ? A ? A).
- Take train B at station 1, stop at station 3 and take train A from station 3 to 4 as (B? . ? A).
- Take train C from station 1 and stop at station 4(C? .)
Therefore, the total number of ways to reach station 4 from station 1 is 3.
Input: N = 15
Output: 338
Approach: The given problem can be solved using the following observations:
- Train A can be used to reach station X only if train A reaches X – 1.
- Train B can be used to reach station X only if train B reaches X – 2.
- Train C can be used to reach station X only if train C reaches X – 3.
Therefore, from the above observations, the idea is to use the concept of Dynamic Programming. Follow the steps given below to solve the problem:
- Initialize a 2D array DP such that:
- DP[i][1] stores the number of ways to reach station i using train A.
- DP[i][2] stores the number of ways to reach station i using train B.
- DP[i][3] stores the number of ways to reach station i using train C.
- DP[i][4] stores the number of ways to reach station i using trains A, B, or C.
- There is only one way of reaching station 1. Therefore, update the value of DP[1][1], DP[1][2], DP[1][3], DP[1][4] as 1.
- Using the above observations, update the value of each state by iterating the loop as follows:
- DP[i][1] = DP[i-1][4]
- DP[i][2] = DP[i-2][4]
- DP[i][3] = DP[i-3][4]
- DP[i][4] = DP[i][1] + DP[i][2] + DP[i][3]
- After completing the above steps, print the value of DP[N][4] 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 find the number of ways // to reach Nth station int numberOfWays( int N)
{ // Declares the DP[] array
int DP[N + 1][5];
// Initialize dp[][] array
memset (DP, 0, sizeof (DP));
// Only 1 way to reach station 1
DP[1][1] = 1;
DP[1][2] = 1;
DP[1][3] = 1;
DP[1][4] = 1;
// Find the remaining states from
// the 2nd station
for ( int i = 2; i <= N; i++) {
// If the train A is present
// at station i - 1
if (i - 1 > 0 && DP[i - 1][1] > 0)
DP[i][1] = DP[i - 1][4];
// If the train B is present
// at station i-2
if (i - 2 > 0 && DP[i - 2][2] > 0)
DP[i][2] = DP[i - 2][4];
// If train C is present at
// station i-3
if (i - 3 > 0 && DP[i - 3][3] > 0)
DP[i][3] = DP[i - 3][4];
// The total number of ways to
// reach station i
DP[i][4] = (DP[i][1] + DP[i][2]
+ DP[i][3]);
}
// Return the total count of ways
return DP[N][4];
} // Driver Code int main()
{ int N = 15;
cout << numberOfWays(N);
return 0;
} |
// Java program for the above approach class GFG {
// Function to find the number of ways
// to reach Nth station
static int numberOfWays( int N)
{
// Declares the DP[] array
int [][] DP = new int [N + 1 ][ 5 ];
// Initialize dp[][] array
for ( int i = 0 ; i < N + 1 ; i++) {
for ( int j = 0 ; j < 5 ; j++) {
DP[i][j] = 0 ;
}
}
// Only 1 way to reach station 1
DP[ 1 ][ 1 ] = 1 ;
DP[ 1 ][ 2 ] = 1 ;
DP[ 1 ][ 3 ] = 1 ;
DP[ 1 ][ 4 ] = 1 ;
// Find the remaining states from
// the 2nd station
for ( int i = 2 ; i <= N; i++) {
// If the train A is present
// at station i - 1
if (i - 1 > 0 && DP[i - 1 ][ 1 ] > 0 )
DP[i][ 1 ] = DP[i - 1 ][ 4 ];
// If the train B is present
// at station i-2
if (i - 2 > 0 && DP[i - 2 ][ 2 ] > 0 )
DP[i][ 2 ] = DP[i - 2 ][ 4 ];
// If train C is present at
// station i-3
if (i - 3 > 0 && DP[i - 3 ][ 3 ] > 0 )
DP[i][ 3 ] = DP[i - 3 ][ 4 ];
// The total number of ways to
// reach station i
DP[i][ 4 ] = (DP[i][ 1 ] + DP[i][ 2 ] + DP[i][ 3 ]);
}
// Return the total count of ways
return DP[N][ 4 ];
}
// Driver Code
static public void main(String[] args)
{
int N = 15 ;
System.out.println(numberOfWays(N));
}
} // This code is contributed by ukasp. |
# Python3 program for the above approach # Function to find the number of ways # to reach Nth station def numberOfWays(N):
# Declares the DP[] array
DP = [[ 0 for i in range ( 5 )]
for i in range (N + 1 )]
# Initialize dp[][] array
# memset(DP, 0, sizeof(DP))
# Only 1 way to reach station 1
DP[ 1 ][ 1 ] = 1
DP[ 1 ][ 2 ] = 1
DP[ 1 ][ 3 ] = 1
DP[ 1 ][ 4 ] = 1
# Find the remaining states from
# the 2nd station
for i in range ( 2 , N + 1 ):
# If the train A is present
# at station i - 1
if (i - 1 > 0 and DP[i - 1 ][ 1 ] > 0 ):
DP[i][ 1 ] = DP[i - 1 ][ 4 ]
# If the train B is present
# at station i-2
if (i - 2 > 0 and DP[i - 2 ][ 2 ] > 0 ):
DP[i][ 2 ] = DP[i - 2 ][ 4 ]
# If train C is present at
# station i-3
if (i - 3 > 0 and DP[i - 3 ][ 3 ] > 0 ):
DP[i][ 3 ] = DP[i - 3 ][ 4 ]
# The total number of ways to
# reach station i
DP[i][ 4 ] = (DP[i][ 1 ] + DP[i][ 2 ] + DP[i][ 3 ])
# Return the total count of ways
return DP[N][ 4 ]
# Driver Code if __name__ = = '__main__' :
N = 15
print (numberOfWays(N))
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
class GFG{
// Function to find the number of ways // to reach Nth station static int numberOfWays( int N)
{ // Declares the DP[] array
int [,] DP = new int [N + 1, 5];
// Initialize dp[][] array
for ( int i = 0; i < N + 1; i++)
{
for ( int j = 0; j < 5; j++)
{
DP[i, j] = 0;
}
}
// Only 1 way to reach station 1
DP[1, 1] = 1;
DP[1, 2] = 1;
DP[1, 3] = 1;
DP[1, 4] = 1;
// Find the remaining states from
// the 2nd station
for ( int i = 2; i <= N; i++)
{
// If the train A is present
// at station i - 1
if (i - 1 > 0 && DP[i - 1, 1] > 0)
DP[i, 1] = DP[i - 1, 4];
// If the train B is present
// at station i-2
if (i - 2 > 0 && DP[i - 2, 2] > 0)
DP[i, 2] = DP[i - 2, 4];
// If train C is present at
// station i-3
if (i - 3 > 0 && DP[i - 3, 3] > 0)
DP[i, 3] = DP[i - 3, 4];
// The total number of ways to
// reach station i
DP[i, 4] = (DP[i, 1] + DP[i, 2] + DP[i, 3]);
}
// Return the total count of ways
return DP[N, 4];
} // Driver Code static public void Main()
{ int N = 15;
Console.WriteLine(numberOfWays(N));
} } // This code is contributed by Dharanendra L V. |
// Javascript program for the above approach import java.io.*; import java.lang.*; import java.util.*; class GFG{ // Function to find the number of ways // to reach Nth station static int numberOfWays(int N) { // Declares the DP[] array
int DP[][] = new int[N + 1][5];
// Initialize dp[][] array
for (int i = 0; i < N +1; i++) {
for (int j = 0; j < 5; j++) {
DP[i][j] = 0;
}
}
// Only 1 way to reach station 1
DP[1][1] = 1;
DP[1][2] = 1;
DP[1][3] = 1;
DP[1][4] = 1;
// Find the remaining states from
// the 2nd station
for (int i = 2; i <= N; i++) {
// If the train A is present
// at station i - 1
if (i - 1 > 0 && DP[i - 1][1] > 0)
DP[i][1] = DP[i - 1][4];
// If the train B is present
// at station i-2
if (i - 2 > 0 && DP[i - 2][2] > 0)
DP[i][2] = DP[i - 2][4];
// If train C is present at
// station i-3
if (i - 3 > 0 && DP[i - 3][3] > 0)
DP[i][3] = DP[i - 3][4];
// The total number of ways to
// reach station i
DP[i][4] = (DP[i][1] + DP[i][2]
+ DP[i][3]);
}
// Return the total count of ways
return DP[N][4];
} // Driver Code public static void main(String[] args) { int N = 15;
System.out.print(numberOfWays(N));
} } // This code is contributed by code_hunt. |
338
Time Complexity: O(N)
Auxiliary Space: O(N)