Maximum Vacation Days - Practice Coding Problems

Maximum Vacation Days - Problem

🌴 Maximum Vacation Days Planning

Imagine you're a lucky employee who gets to travel among n cities over k weeks, collecting algorithm problems while maximizing your vacation days! 🎯

The Challenge: You start in city 0 on Monday and can only fly between cities on Monday mornings. Each city offers different vacation opportunities each week, and your goal is to plan the optimal travel route to maximize total vacation days.

Travel Rules:

🛫 flights[i][j] = 1 means you can fly from city i to city j
📅 days[i][j] represents max vacation days in city i during week j
✈️ You can only travel on Monday mornings (once per week)
🏨 You can stay in the same city (no flight needed)

Goal: Return the maximum total vacation days you can achieve across all k weeks!

Input & Output

example_1.py — Basic Travel Planning

$ Input: flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[1,3,1],[6,0,3],[3,3,3]]

› Output: 12

💡 Note: Optimal path: Stay in city 0 for week 0 (1 vacation day), fly to city 1 for week 1 (0 vacation days), fly to city 2 for week 2 (3 vacation days). Total = 1 + 0 + 3 = 4. Actually, better path: Fly to city 1 in week 0 (6 days), stay in city 1 for week 1 (0 days), fly to city 2 for week 2 (3 days). Total = 6 + 0 + 3 = 9. Even better: City 0 week 0 (1), City 1 week 1 (0), City 2 week 2 (3), but we can also go City 1 week 0 (6), City 2 week 1 (3), City 2 week 2 (3) = 12.

example_2.py — No Flights Available

$ Input: flights = [[0,0,0],[0,0,0],[0,0,0]], days = [[1,1,1],[7,7,7],[7,7,7]]

› Output: 3

💡 Note: Since no flights are available (all flights[i][j] = 0), we must stay in city 0 for all weeks. Total vacation days = 1 + 1 + 1 = 3.

example_3.py — Single City

$ Input: flights = [[0]], days = [[5,2,8,3]]

› Output: 18

💡 Note: Only one city available. Stay in city 0 for all 4 weeks. Total vacation days = 5 + 2 + 8 + 3 = 18.

Visualization

Tap to expand

Understanding the Visualization

Setup Initial State

Start at city 0 with 0 vacation days accumulated

Week-by-Week Planning

For each week, consider staying in current city or flying to connected cities

Track Maximum Gains

Keep track of the maximum vacation days achievable at each city for current week

Build Optimal Solution

Use previous week's results to compute current week's optimal choices

Key Takeaway

🎯 Key Insight: Dynamic programming builds the optimal solution incrementally by considering all possible travel choices each week while remembering the best outcomes from previous weeks.

Time & Space Complexity

Time Complexity

⏱️

O(n²k)

For each of k weeks, we check n cities, and for each city we check n possible destinations

⚠ Quadratic Growth

Space Complexity

O(n)

We only need to store the DP state for current and next week, which requires O(n) space

⚡ Linearithmic Space

Constraints

n == flights.length
n == flights[i].length
n == days.length
k == days[i].length
1 ≤ n, k ≤ 100
flights[i][j] is either 0 or 1
0 ≤ days[i][j] ≤ 10³
flights[i][i] == 0 for all i

Asked in

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

The optimal solution uses bottom-up dynamic programming with O(n²k) time complexity. We maintain a DP array representing the maximum vacation days achievable ending at each city, updating it week by week. The key insight is that we only need to track the current week's state to compute the next week, making this an efficient iterative approach that avoids recursion overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS Exploration)	O(n^k)	O(k)	Try all possible travel paths using recursive DFS
Bottom-Up DP (Optimal)	O(n²k)	O(n)	Build solution iteratively from week 0 to week k using dynamic programming
Memoized DFS (Top-Down DP)	O(n²k)	O(nk)	Add memoization to brute force approach to avoid recomputing subproblems

Brute Force (DFS Exploration) — Algorithm Steps

Start from city 0 at week 0
For each week, try staying in current city or flying to any connected city
Recursively explore all paths and track maximum vacation days
Return the maximum among all possible paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at City 0

Begin the journey at city 0, week 0

Branch Out

For each city, explore staying or flying to connected cities

Recursive Exploration

Recursively explore all paths to find maximum vacation days

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int dfs(int** flights, int** days, int city, int week, int n, int k) {
    if (week == k) return 0;
    
    int maxDays = 0;
    // Try staying in current city
    maxDays = max(maxDays, days[city][week] + dfs(flights, days, city, week + 1, n, k));
    
    // Try flying to other cities
    for (int nextCity = 0; nextCity < n; nextCity++) {
        if (flights[city][nextCity] == 1) {
            maxDays = max(maxDays, days[nextCity][week] + dfs(flights, days, nextCity, week + 1, n, k));
        }
    }
    
    return maxDays;
}

int maxVacationDays(int** flights, int** days, int n, int k) {
    return dfs(flights, days, 0, 0, n, k);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each week, we have at most n cities to choose from, leading to n^k possible paths

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k weeks

✓ Linear Space

Constraints

n == flights.length
n == flights[i].length
n == days.length
k == days[i].length
1 ≤ n, k ≤ 100
flights[i][j] is either 0 or 1
0 ≤ days[i][j] ≤ 10³
flights[i][i] == 0 for all i

28.5K Views

Medium Frequency

~25 min Avg. Time

850 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

🌴 Maximum Vacation Days Planning

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler