Maximum Cost of Trip With K Highways - Practice Coding Problems

Maximum Cost of Trip With K Highways - Problem

A series of highways connect n cities numbered from 0 to n - 1. You are given a 2D integer array highways where highways[i] = [city1_i, city2_i, toll_i] indicates that there is a highway that connects city1_i and city2_i, allowing a car to go from city1_i to city2_i and vice versa for a cost of toll_i.

You are also given an integer k. You are going on a trip that crosses exactly k highways. You may start at any city, but you may only visit each city at most once during your trip.

Return the maximum cost of your trip. If there is no trip that meets the requirements, return -1.

Input & Output

Example 1 — Basic Case

$ Input: highways = [[0,1,15],[0,3,8],[1,2,10],[1,3,20],[2,3,5]], k = 2

› Output: 35

💡 Note: Start at city 0, take highway to city 1 (cost 15), then take highway to city 3 (cost 20). Total cost = 15 + 20 = 35, using exactly 2 highways.

Example 2 — No Valid Path

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

› Output: -1

💡 Note: Only 3 cities connected in a line, but we need exactly 3 highways. Maximum possible is 2 highways (0→1→2), so return -1.

Example 3 — Single Highway

$ Input: highways = [[0,1,100]], k = 1

› Output: 100

💡 Note: Only one highway available with cost 100. We need exactly 1 highway, so the answer is 100.

Constraints

1 ≤ highways.length ≤ 15
highways[i].length == 3
0 ≤ city1_i, city2_i ≤ n - 1
city1_i ≠ city2_i
0 ≤ toll_i ≤ 100
1 ≤ k ≤ 50
There are no duplicate highways.

Visualization

Tap to expand

Understanding the Visualization

Input Graph

Cities connected by highways with toll costs

Path Finding

Find paths using exactly k highways without revisiting cities

Maximum Cost

Return the highest total cost among all valid paths

Key Takeaway

🎯 Key Insight: Use bitmasks to efficiently represent visited city states and memoization to avoid redundant computations

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Meta 4

The key insight is to use DFS with bitmask memoization to efficiently track visited cities and avoid recomputing the same states. The optimal approach combines dynamic programming with graph traversal. Time: O(n × 2ⁿ × k), Space: O(n × 2ⁿ × k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS	O(n × k!)	O(k)	Try all possible paths of exactly k highways using recursive DFS
DFS with Bitmask Memoization	O(n × 2ⁿ × k)	O(n × 2ⁿ × k)	Use DFS with bitmask to track visited cities and memoization to avoid recomputation

Brute Force DFS — Algorithm Steps

Build adjacency list from highways
For each city, start DFS with k remaining highways
Recursively explore unvisited neighbors
Track maximum cost among all valid paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from highways

Try Each Start

Start DFS from each city

Explore Paths

Recursively visit unvisited neighbors

Track Maximum

Keep track of maximum cost found

Code -

solution.c — C

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

int maxCost = -1;
int graph[20][20];
int n = 0;

void dfs(int city, int* visited, int remaining, int currentCost) {
    if (remaining == 0) {
        if (currentCost > maxCost) {
            maxCost = currentCost;
        }
        return;
    }
    
    for (int neighbor = 0; neighbor < n; neighbor++) {
        if (graph[city][neighbor] > 0 && !visited[neighbor]) {
            visited[neighbor] = 1;
            dfs(neighbor, visited, remaining - 1, currentCost + graph[city][neighbor]);
            visited[neighbor] = 0;
        }
    }
}

int solution(int highways[][3], int highwaysSize, int k) {
    // Initialize graph
    memset(graph, 0, sizeof(graph));
    n = 0;
    
    // Build adjacency matrix
    for (int i = 0; i < highwaysSize; i++) {
        int u = highways[i][0], v = highways[i][1], toll = highways[i][2];
        graph[u][v] = toll;
        graph[v][u] = toll;
        if (u + 1 > n) n = u + 1;
        if (v + 1 > n) n = v + 1;
    }
    
    maxCost = -1;
    
    // Try starting from each city
    for (int start = 0; start < n; start++) {
        int visited[20] = {0};
        visited[start] = 1;
        dfs(start, visited, k, 0);
    }
    
    return maxCost;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small inputs
    int highways[50][3];
    int highwaysSize = 0;
    
    // Parse highways (simplified for demonstration)
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            highways[highwaysSize][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            highways[highwaysSize][1] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            highways[highwaysSize][2] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            highwaysSize++;
        }
        ptr++;
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(highways, highwaysSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k!)

For each starting city, we explore paths of length k with factorial branching

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth up to k levels plus visited array

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler