Minimum Cost For Tickets - Practice Coding Problems

Minimum Cost For Tickets - Problem

You're planning a year-long travel adventure! 🚂 You have a list of specific days when you'll be traveling, and you need to buy train tickets in the most cost-effective way possible.

The Challenge: Train tickets come in three types:

1-day pass - costs costs[0] dollars, valid for 1 day
7-day pass - costs costs[1] dollars, valid for 7 consecutive days
30-day pass - costs costs[2] dollars, valid for 30 consecutive days

Important: When you buy a multi-day pass, it covers consecutive calendar days starting from the purchase date, regardless of whether you actually travel on those days.

For example, if you buy a 7-day pass on day 2, it covers days 2, 3, 4, 5, 6, 7, and 8.

Goal: Find the minimum cost to cover all your planned travel days given in the array days.

Input & Output

example_1.py — Basic Case

$ Input: days = [1,4,6,7,8,20], costs = [2,7,15]

› Output: 11

💡 Note: Buy a 7-day pass on day 1 (covers days 1-7) for $7, then buy a 1-day pass on day 20 for $2. Total cost: $7 + $2 = $9. Wait, let me recalculate: 1-day passes for days 1,4,6,7,8,20 would cost $12. A 7-day pass on day 1 covers days 1,4,6,7,8 for $7, plus 1-day pass for day 20 costs $2. Total: $9. Actually, the optimal is $11 with different combination.

example_2.py — Monthly Pass Better

$ Input: days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]

› Output: 17

💡 Note: Buy a 30-day pass on day 1 for $15 (covers days 1-30), then buy a 1-day pass for day 31 for $2. Total cost: $15 + $2 = $17. This is better than buying multiple 7-day or 1-day passes.

example_3.py — All Single Days

$ Input: days = [1], costs = [2,7,15]

› Output: 2

💡 Note: Only traveling one day, so buying a 1-day pass for $2 is optimal. The 7-day ($7) and 30-day ($15) passes would be wasteful for just one day of travel.

Visualization

Tap to expand

Understanding the Visualization

Identify Travel Days

Mark all days you plan to travel: [1, 4, 6, 7, 8, 20]

Consider Pass Options

For each travel day, evaluate: 1-day ($2), 7-day ($7), 30-day ($15)

Make Optimal Choices

Choose the pass type that minimizes total cost

Build Solution

Use dynamic programming to find minimum cost combination

Key Takeaway

🎯 Key Insight: Use dynamic programming with memoization to efficiently explore all pass combinations and find the minimum cost solution in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each day index is calculated exactly once and stored in memo table

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores results for up to n day indices, plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ days.length ≤ 365
1 ≤ days[i] ≤ 365
days is in strictly increasing order
costs.length == 3
1 ≤ costs[i] ≤ 1000

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses dynamic programming with memoization to avoid recalculating subproblems. For each travel day, we consider three options: buy a 1-day pass, 7-day pass, or 30-day pass, and choose the minimum cost option. The key insight is that we only need to make decisions on actual travel days, and memoization reduces the time complexity from O(3^n) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive)	O(3^n)	O(n)	Try all possible combinations of ticket purchases recursively
Dynamic Programming with Memoization (Optimal)	O(n)	O(n)	Use memoization to avoid recalculating the same subproblems

Brute Force (Recursive) — Algorithm Steps

Start from the first travel day
For each day, try buying a 1-day pass and solve for remaining days
Try buying a 7-day pass and skip days covered by it
Try buying a 30-day pass and skip days covered by it
Return the minimum cost among all three options
Use recursion to solve subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at day 1

Consider all three ticket options

Branch for each option

Recursively solve remaining subproblems

Combine results

Take minimum cost from all branches

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int dfs(int* days, int daysSize, int* costs, int i) {
    if (i >= daysSize) {
        return 0;
    }
    
    // Option 1: Buy 1-day pass
    int cost1 = costs[0] + dfs(days, daysSize, costs, i + 1);
    
    // Option 2: Buy 7-day pass
    int j = i;
    while (j < daysSize && days[j] < days[i] + 7) {
        j++;
    }
    int cost7 = costs[1] + dfs(days, daysSize, costs, j);
    
    // Option 3: Buy 30-day pass
    int k = i;
    while (k < daysSize && days[k] < days[i] + 30) {
        k++;
    }
    int cost30 = costs[2] + dfs(days, daysSize, costs, k);
    
    return min(cost1, min(cost7, cost30));
}

int mincostTickets(int* days, int daysSize, int* costs, int costsSize) {
    return dfs(days, daysSize, costs, 0);
}

int main() {
    int days[] = {1, 4, 6, 7, 8, 20};
    int costs[] = {2, 7, 15};
    printf("%d\n", mincostTickets(days, 6, costs, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of n travel days, we have 3 choices, leading to 3^n possible combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n (number of travel days)

⚡ Linearithmic Space

Constraints

1 ≤ days.length ≤ 365
1 ≤ days[i] ≤ 365
days is in strictly increasing order
costs.length == 3
1 ≤ costs[i] ≤ 1000

85.0K Views

Medium Frequency

~25 min Avg. Time

3.2K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Recursive) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler