Minimum Costs Using the Train Line - Practice Coding Problems

Minimum Costs Using the Train Line - Problem

🚆 Minimum Costs Using the Train Line

Imagine you're planning a journey through a city with two train routes: a regular route and an express route. Both routes connect the same n + 1 stops (labeled 0 to n), but they have different costs and speeds.

Your Journey: You start at stop 0 on the regular route and want to find the cheapest way to reach each subsequent stop.

Route Rules:

🚂 Regular Route: regular[i] = cost from stop i-1 to stop i
🚄 Express Route: express[i] = cost from stop i-1 to stop i
💰 Transfer Cost: Pay expressCost each time you switch from regular to express
🆓 Free Transfer: Switch from express back to regular anytime (no cost)

Goal: Return an array costs where costs[i] is the minimum cost to reach stop i from stop 0.

Example: If regular = [1, 3, 2], express = [4, 1, 1], and expressCost = 2, you might take the regular route to stop 1 (cost: 1), then transfer to express for stops 2-3 (total additional cost: 2 + 1 + 1 = 4).

Input & Output

example_1.py — Basic Route Selection

$ Input: regular = [1, 3, 2], express = [4, 1, 1], expressCost = 2

› Output: [1, 4, 5]

💡 Note: Stop 1: Take regular route (cost: 1). Stop 2: Stay on regular (cost: 1+3=4). Stop 3: Transfer to express at stop 1 is better: regular[0] + expressCost + express[1] + express[2] = 1 + 2 + 1 + 1 = 5, vs staying regular = 1+3+2 = 6.

example_2.py — Express Always Better

$ Input: regular = [10, 10, 10], express = [1, 1, 1], expressCost = 1

› Output: [2, 3, 4]

💡 Note: Express route is much cheaper despite transfer cost. Stop 1: Transfer immediately (cost: 1+1=2). Stop 2: Continue on express (cost: 2+1=3). Stop 3: Continue on express (cost: 3+1=4).

example_3.py — High Transfer Cost

$ Input: regular = [2, 2, 2], express = [1, 1, 1], expressCost = 10

› Output: [2, 4, 6]

💡 Note: Transfer cost is too high, so regular route is always better. Stop 1: Regular (cost: 2). Stop 2: Regular (cost: 4). Stop 3: Regular (cost: 6). Even though express is cheaper per segment, the 10-unit transfer cost makes it uneconomical.

Constraints

1 ≤ n ≤ 1000
1 ≤ regular[i], express[i] ≤ 1000
1 ≤ expressCost ≤ 1000
Important: You always start on the regular route at stop 0

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at stop 0 on the regular route with zero cost

Evaluate Options

At each stop, calculate the cheapest way to arrive via regular route and via express route

Make Decisions

Consider transfer costs and choose the route that minimizes total expense

Build Solution

The minimum cost to reach each stop is the cheaper of the two route options

Key Takeaway

🎯 Key Insight: This problem demonstrates the power of dynamic programming with optimal substructure. By tracking the minimum cost to reach each stop via both routes, we can make locally optimal decisions that lead to a globally optimal solution, avoiding the exponential complexity of trying all possible route combinations.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses dynamic programming to track the minimum cost to reach each stop via both the regular and express routes. At each stop, we calculate: (1) Regular cost = min(previous regular, previous express) + regular route cost (free transfer from express), (2) Express cost = min(previous regular + transfer cost, previous express) + express route cost. The answer for each stop is the minimum of these two costs. This approach runs in O(n) time and O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track minimum cost on both routes at each stop using optimal substructure
Brute Force (Try All Route Combinations)	O(2^n)	O(n)	Try every possible combination of route switches

Dynamic Programming (Optimal) — Algorithm Steps

Initialize costs: regular_cost[0] = 0, express_cost[0] = infinity
For each stop i from 1 to n:
Calculate new regular_cost[i] = min(regular_cost[i-1], express_cost[i-1]) + regular[i-1]
Calculate new express_cost[i] = min(regular_cost[i-1] + expressCost, express_cost[i-1]) + express[i-1]
Result[i-1] = min(regular_cost[i], express_cost[i])

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with regular_cost = 0, express_cost = ∞

Transition

At each stop, calculate new costs for both routes

Optimize

Choose the minimum cost path considering transfer fees

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int* minimumCosts(int* regular, int regularSize, int* express, int expressSize, int expressCost, int* returnSize) {
    int n = regularSize;
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    // Track minimum cost to reach current position on each route
    int regularCost = 0;  // Cost to reach current stop via regular route
    int expressCurrentCost = INT_MAX;  // Cost to reach current stop via express route
    
    for (int i = 0; i < n; i++) {
        // Calculate cost to reach next stop (i+1) via regular route
        int newRegularCost = regularCost + regular[i];
        if (expressCurrentCost != INT_MAX && expressCurrentCost < regularCost) {
            newRegularCost = expressCurrentCost + regular[i];
        }
        
        // Calculate cost to reach next stop (i+1) via express route
        int newExpressCost;
        if (expressCurrentCost == INT_MAX) {
            newExpressCost = regularCost + expressCost + express[i];
        } else {
            int option1 = regularCost + expressCost + express[i];
            int option2 = expressCurrentCost + express[i];
            newExpressCost = (option1 < option2) ? option1 : option2;
        }
        
        // Update costs for next iteration
        regularCost = newRegularCost;
        expressCurrentCost = newExpressCost;
        
        // Minimum cost to reach stop i+1
        int minCost = (regularCost < expressCurrentCost) ? regularCost : expressCurrentCost;
        result[i] = minCost;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all stops, constant time operations per stop

✓ Linear Growth

Space Complexity

O(1)

Only need to track costs for current step, plus result array

✓ Linear Space

43.7K Views

Medium Frequency

~25 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🚆 Minimum Costs Using the Train Line

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler