Maximum Cost of Trip With K Highways - Practice Coding Problems

Maximum Cost of Trip With K Highways - Problem

Imagine you're planning the ultimate road trip adventure across a network of cities connected by toll highways! 🚗💰

You have n cities numbered from 0 to n-1, connected by a series of bidirectional highways. Each highway has a toll cost, and here's the twist: you want to maximize your spending to get the most luxurious trip possible!

Given a 2D array highways where highways[i] = [city1, city2, toll] represents a highway connecting two cities with a specific toll cost, your goal is to plan a trip that:

Uses exactly k highways
Visits each city at most once
Maximizes the total toll cost
Can start from any city

Return the maximum possible cost for such a trip, or -1 if no valid trip exists.

Input & Output

example_1.py — Basic Highway Network

$ Input: n = 4, highways = [[0,1,3],[2,1,5],[0,2,7]], k = 2

› Output: 10

💡 Note: The optimal trip is 0 → 2 → 1 using highways with costs 7 + 5 = 12. Wait, let me recalculate: 0 → 2 (cost 7) → 1 (cost 5) gives total cost 12, but we can also do 2 → 0 (cost 7) → 1 (cost 3) giving cost 10. Actually, the maximum is 0 → 2 → 1 with cost 7 + 5 = 12.

example_2.py — No Valid Path

$ Input: n = 4, highways = [[0,1,3],[1,2,5]], k = 3

› Output: -1

💡 Note: There are only 2 highways available, but we need exactly 3 highways for our trip. Since k = 3 > number of available highways, return -1.

example_3.py — Single Highway

$ Input: n = 3, highways = [[0,1,2],[1,2,3],[0,2,4]], k = 1

› Output: 4

💡 Note: We need exactly 1 highway. The maximum cost single highway is from city 0 to city 2 with cost 4.

Visualization

Tap to expand

Understanding the Visualization

Build Graph

Create adjacency list representation of the highway network

Initialize DP

Set starting states: dp[1<<i][i] = 0 for each city i

Explore States

For each state, try extending to unvisited neighboring cities

Find Maximum

Check all states with exactly k+1 cities visited (k highways used)

Key Takeaway

🎯 Key Insight: Bitmask DP efficiently tracks visited cities while building optimal paths, avoiding the exponential complexity of naive backtracking by storing intermediate results.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2 * k)

For each of 2^n possible masks, n cities, and k steps, we check n neighbors

⚠ Quadratic Growth

Space Complexity

O(2^n * n)

DP table stores max cost for each (mask, city) combination

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 15
0 ≤ highways.length ≤ 50
highways[i].length == 3
0 ≤ city1_i, city2_i ≤ n - 1
city1_i != city2_i
0 ≤ toll_i ≤ 100
1 ≤ k ≤ 50
Each pair of cities has at most one highway connecting them

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses bitmask dynamic programming to efficiently explore all possible paths. We represent visited cities as bits in an integer and use DP to track the maximum cost to reach each city with a given set of visited cities. The key insight is that dp[mask][city] represents the maximum cost to reach 'city' having visited the cities represented by 'mask'. This avoids redundant computations and handles the constraint of visiting each city at most once elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Bitmask Dynamic Programming (Optimal)	O(2^n * n^2 * k)	O(2^n * n)	Use bitmask to represent visited cities and DP to find optimal paths efficiently
DFS with Backtracking	O(n! * 2^n)	O(k)	Try all possible paths of length k using recursive depth-first search

Bitmask Dynamic Programming (Optimal) — Algorithm Steps

Build adjacency list representation of the graph
Initialize DP table: dp[mask][city] = max cost to reach city with visited cities in mask
For each number of highways used (1 to k), update DP states
For each current state, try extending to neighboring unvisited cities
Track maximum cost when exactly k highways are used

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Set dp[1<<i][i] = 0 for each starting city i

Build Mask States

For each mask, try extending to unvisited neighbors

Track Optimal Costs

Update dp[newMask][nextCity] with maximum cost

Find Answer

Check all states with exactly k+1 cities visited

Code -

solution.c — C

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

typedef struct {
    int city;
    int toll;
} Edge;

typedef struct {
    Edge* edges;
    int count;
    int capacity;
} AdjList;

int popcount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int maximumCost(int n, int** highways, int highwaysSize, int k) {
    if (k >= n) return -1;
    
    // Build adjacency list
    AdjList* graph = (AdjList*)calloc(n, sizeof(AdjList));
    
    for (int i = 0; i < highwaysSize; i++) {
        int city1 = highways[i][0];
        int city2 = highways[i][1];
        int toll = highways[i][2];
        
        // Add edge from city1 to city2
        if (graph[city1].count == graph[city1].capacity) {
            graph[city1].capacity = graph[city1].capacity == 0 ? 1 : graph[city1].capacity * 2;
            graph[city1].edges = realloc(graph[city1].edges, graph[city1].capacity * sizeof(Edge));
        }
        graph[city1].edges[graph[city1].count++] = (Edge){city2, toll};
        
        // Add edge from city2 to city1
        if (graph[city2].count == graph[city2].capacity) {
            graph[city2].capacity = graph[city2].capacity == 0 ? 1 : graph[city2].capacity * 2;
            graph[city2].edges = realloc(graph[city2].edges, graph[city2].capacity * sizeof(Edge));
        }
        graph[city2].edges[graph[city2].count++] = (Edge){city1, toll};
    }
    
    // dp[mask][city] = maximum cost to reach city with visited cities in mask
    int** dp = (int**)malloc((1 << n) * sizeof(int*));
    for (int i = 0; i < (1 << n); i++) {
        dp[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dp[i][j] = -1;
        }
    }
    
    // Initialize: start from each city
    for (int i = 0; i < n; i++) {
        dp[1 << i][i] = 0;
    }
    
    int maxCost = -1;
    
    // Try all possible states
    for (int mask = 0; mask < (1 << n); mask++) {
        int cityCount = popcount(mask);
        if (cityCount > k + 1) continue;
        
        for (int city = 0; city < n; city++) {
            if (dp[mask][city] == -1 || !(mask & (1 << city))) continue;
            
            // If we've used exactly k highways, update answer
            if (cityCount == k + 1) {
                if (dp[mask][city] > maxCost) {
                    maxCost = dp[mask][city];
                }
                continue;
            }
            
            // Try extending to neighbors
            for (int i = 0; i < graph[city].count; i++) {
                int nextCity = graph[city].edges[i].city;
                int toll = graph[city].edges[i].toll;
                
                if (!(mask & (1 << nextCity))) {
                    int newMask = mask | (1 << nextCity);
                    int newCost = dp[mask][city] + toll;
                    if (newCost > dp[newMask][nextCity]) {
                        dp[newMask][nextCity] = newCost;
                    }
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i].edges);
    }
    free(graph);
    
    for (int i = 0; i < (1 << n); i++) {
        free(dp[i]);
    }
    free(dp);
    
    return maxCost;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2 * k)

For each of 2^n possible masks, n cities, and k steps, we check n neighbors

⚠ Quadratic Growth

Space Complexity

O(2^n * n)

DP table stores max cost for each (mask, city) combination

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 15
0 ≤ highways.length ≤ 50
highways[i].length == 3
0 ≤ city1_i, city2_i ≤ n - 1
city1_i != city2_i
0 ≤ toll_i ≤ 100
1 ≤ k ≤ 50
Each pair of cities has at most one highway connecting them

22.2K Views

Medium Frequency

~25 min Avg. Time

847 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

Bitmask Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler