Maximum Path Quality of a Graph - Practice Coding Problems

Maximum Path Quality of a Graph - Problem

You're a treasure hunter exploring an undirected graph representing a network of caves. Each cave has a unique treasure value, and you must find the most valuable round trip starting and ending at cave 0.

The Challenge:

Start at cave 0 and return to cave 0 within maxTime seconds
You can visit the same cave multiple times, but each cave's treasure only counts once toward your total quality
Travel between caves takes time based on the edge weights
Each cave connects to at most 4 other caves

Input: An array values where values[i] is the treasure value of cave i, a 2D array edges where each edges[j] = [u, v, time] represents a bidirectional tunnel taking time seconds, and maxTime constraint.

Goal: Return the maximum quality (sum of unique cave values) achievable in a valid round trip.

Input & Output

example_1.py — Basic Path

$ Input: values = [0,32,10,43], edges = [[0,1,10],[1,2,15],[0,3,10]], maxTime = 49

› Output: 75

💡 Note: Optimal path: 0 -> 1 -> 2 -> 1 -> 0. Time: 10+15+15+10 = 50 > 49, so try 0 -> 3 -> 0 -> 1 -> 0. Time: 10+10+10+10 = 40. Quality: values[0]+values[3]+values[1] = 0+43+32 = 75

example_2.py — Time Constraint

$ Input: values = [5,10,15,20], edges = [[0,1,10],[1,2,10],[0,3,10]], maxTime = 30

› Output: 25

💡 Note: Can visit 0 -> 1 -> 0 -> 3 -> 0 in exactly 30 time units. Quality: values[0]+values[1]+values[3] = 5+10+20 = 35. But optimal is 0 -> 3 -> 0 with quality 25

example_3.py — Single Node

$ Input: values = [1,2,3,4], edges = [[0,1,40],[1,2,50],[1,3,30]], maxTime = 50

› Output: 3

💡 Note: Can only visit node 0 and return within time limit, so quality is values[0] = 1. Wait, we can go 0->1->0 in 80 time, exceeding limit. Only node 0 accessible, quality = 1. Actually 0->3->1->0 might work if there's edge 1-3

Constraints

n == values.length
1 ≤ n ≤ 1000
0 ≤ values[i] ≤ 10⁸
0 ≤ edges.length ≤ 2000
edges[j].length == 3
0 ≤ u_j, v_j ≤ n - 1
10 ≤ time_j, maxTime ≤ 100
There are at most four edges connected to each node
The graph may not be connected

Visualization

Tap to expand

Understanding the Visualization

Start Exploration

Begin at cave 0 with full time budget and empty treasure collection

Branch and Bound

Explore each tunnel, tracking time spent and treasures collected

Quality Calculation

When returning to cave 0, calculate total treasure value from unique caves visited

Optimal Path Found

Compare all valid round trips to find maximum treasure value

Key Takeaway

🎯 Key Insight: Use backtracking with time-based pruning to explore all valid round trips. The constraint of at most 4 edges per node keeps the search space manageable.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 18

The optimal approach uses backtracking with intelligent pruning. Since each node has at most 4 edges, the search space is manageable. We track visited nodes to calculate quality and use the time constraint to prune impossible paths. The key insight is that we only need to find paths that return to node 0, and we can revisit nodes but only count their value once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(4^n)	O(n)	Explore all possible paths recursively without optimization

Brute Force Backtracking — Algorithm Steps

Build adjacency list from edges
Start DFS from node 0 with time = 0
For each neighbor, recursively explore if we have enough time
Track visited nodes in a set for quality calculation
Return to node 0 and update maximum quality
Backtrack by removing current node from visited set

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Node 0

Begin exploration with node 0 in visited set and time = 0

Explore All Neighbors

For each neighbor, recursively explore if time constraint allows

Track Quality

When returning to node 0, calculate quality from visited unique nodes

Backtrack

Remove nodes from visited set when backtracking (except node 0)

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_EDGES 2000

typedef struct {
    int node, time;
} Edge;

Edge graph[MAX_NODES][5];
int graphSize[MAX_NODES];
int values[MAX_NODES];
int visited[MAX_NODES];
int maxTime;

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

int dfs(int node, int timeUsed, int n) {
    if (timeUsed > maxTime) return 0;
    
    int maxQuality = 0;
    
    // If we're back at node 0, calculate current quality
    if (node == 0) {
        int quality = 0;
        for (int i = 0; i < n; i++) {
            if (visited[i]) {
                quality += values[i];
            }
        }
        maxQuality = max(maxQuality, quality);
    }
    
    // Explore neighbors
    for (int i = 0; i < graphSize[node]; i++) {
        int nextNode = graph[node][i].node;
        int travelTime = graph[node][i].time;
        
        if (timeUsed + travelTime <= maxTime) {
            int wasVisited = visited[nextNode];
            visited[nextNode] = 1;
            int result = dfs(nextNode, timeUsed + travelTime, n);
            maxQuality = max(maxQuality, result);
            if (nextNode != 0 && !wasVisited) {
                visited[nextNode] = 0;
            }
        }
    }
    
    return maxQuality;
}

int maximalPathQuality(int* vals, int valsSize, int** edges, int edgesSize, int* edgesColSize, int maxT) {
    maxTime = maxT;
    memset(graphSize, 0, sizeof(graphSize));
    memset(visited, 0, sizeof(visited));
    
    // Copy values
    for (int i = 0; i < valsSize; i++) {
        values[i] = vals[i];
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], time = edges[i][2];
        graph[u][graphSize[u]++] = (Edge){v, time};
        graph[v][graphSize[v]++] = (Edge){u, time};
    }
    
    visited[0] = 1;
    return dfs(0, 0, valsSize);
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

In worst case, we explore 4 neighbors at each of n nodes, leading to exponential paths

✓ Linear Growth

Space Complexity

O(n)

Recursion depth and visited set can go up to n nodes

⚡ Linearithmic Space

42.8K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler