Maximum Path Quality of a Graph

Maximum Path Quality of a Graph - Problem

There is an undirected graph with n nodes numbered from 0 to n - 1 (inclusive). You are given a 0-indexed integer array values where values[i] is the value of the i^th node. You are also given a 0-indexed 2D integer array edges, where each edges[j] = [u_j, v_j, time_j] indicates that there is an undirected edge between the nodes u_j and v_j, and it takes time_j seconds to travel between the two nodes.

Finally, you are given an integer maxTime.

A valid path in the graph is any path that starts at node 0, ends at node 0, and takes at most maxTime seconds to complete. You may visit the same node multiple times. The quality of a valid path is the sum of the values of the unique nodes visited in the path (each node's value is added at most once to the sum).

Return the maximum quality of a valid path.

Note: There are at most four edges connected to each node.

Input & Output

Example 1 — Basic Round Trip

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

› Output: 53

💡 Note: Optimal path: 0 → 3 → 2 → 3 → 0. This visits unique nodes {0, 3, 2} with quality 0+43+10=53 in time 10+1+1+10=22 ≤ 25. Other paths like visiting both nodes 1 and 3 would require at least 40 time units (0→1→0→3→0 or 0→3→0→1→0), exceeding maxTime=25.

Example 2 — Just Stay at Start

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

› Output: 5

💡 Note: With only 5 time units, cannot visit any other node and return to 0 (each edge takes 10 time). Stay at node 0, quality = 5.

Example 3 — Quick Round Trip

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

› Output: 6

💡 Note: Can do 0 → 1 → 0 (quality = 1+2 = 3, time = 20) then 0 → 3 → 0 (adds +4, time +20 = 40 > 30). Or single trip 0 → 3 → 0 (quality = 1+4 = 5, time = 20). Or 0 → 1 → 0 → 3 → 0 would be time 40 > 30. Best single path: 0 → 1 → 0 = 3 (time 20), then can't do more. Wait, what about 0 → 1 → 2 → 1 → 0? Time = 10+10+10+10 = 40 > 30. Try 0 → 3 → 0 → 1 → 0? Time = 10+10+10+10 = 40 > 30. Actually, 0 → 1 → 0 → 3 → 0 impossible since we'd need 40 time but have 30. Best is either 0 → 1 → 0 (quality 3, time 20) or 0 → 3 → 0 (quality 5, time 20). Answer should be 5. But wait, we visit {0,3} so quality = values[0] + values[3] = 1 + 4 = 5. Hmm, let me reconsider the example. Maybe there's a better path I'm missing.

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.

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 a Amazon 8

The key insight is to use backtracking DFS to explore all possible round-trip paths while tracking unique visited nodes. The optimal approach uses path pruning to avoid impossible routes. Time: O(4^k), Space: O(n + maxTime) where k is the effective search depth after pruning.

Common Approaches

✓ Brute Force DFS

⏱️ Time: O(4^maxTime) Space: O(maxTime)

Use depth-first search to explore every possible path that starts at node 0, ends at node 0, and doesn't exceed maxTime. Track visited nodes to calculate quality correctly.

Optimized Backtracking

⏱️ Time: O(4^k) Space: O(n + maxTime)

Enhanced DFS that prunes paths early when they can't lead to better solutions or when time constraints make it impossible to return to start.

Brute Force DFS — Algorithm Steps

Build adjacency list from edges
DFS from node 0 tracking current time and visited nodes
When back at node 0, update maximum quality
Backtrack to try all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

DFS Search

Recursively explore all paths from node 0

Track Quality

Sum values of unique visited nodes

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_E 4001
#define INF   0x3f3f3f3f

typedef struct Edge { int to, t; struct Edge* next; } Edge;
static Edge  pool[MAX_E * 2];
static int   poolIdx;
static Edge* graph[MAX_N];

void addEdge(int u, int v, int t) {
    Edge* a = &pool[poolIdx++]; a->to=v; a->t=t; a->next=graph[u]; graph[u]=a;
    Edge* b = &pool[poolIdx++]; b->to=u; b->t=t; b->next=graph[v]; graph[v]=b;
}

static int dist[MAX_N];
static int n;

typedef struct { int d, node; } Item;
typedef struct { Item* data; int sz, cap; } Heap;

static void hpush(Heap* h, Item x) {
    if (h->sz == h->cap) { h->cap *= 2; h->data = realloc(h->data, h->cap * sizeof(Item)); }
    h->data[h->sz++] = x;
    int i = h->sz - 1;
    while (i > 0) {
        int p = (i-1)/2;
        if (h->data[p].d <= h->data[i].d) break;
        Item tmp = h->data[p]; h->data[p] = h->data[i]; h->data[i] = tmp; i = p;
    }
}

static Item hpop(Heap* h) {
    Item ret = h->data[0];
    h->data[0] = h->data[--h->sz];
    int i = 0;
    for (;;) {
        int l=2*i+1, r=2*i+2, m=i;
        if (l < h->sz && h->data[l].d < h->data[m].d) m = l;
        if (r < h->sz && h->data[r].d < h->data[m].d) m = r;
        if (m == i) break;
        Item tmp = h->data[i]; h->data[i] = h->data[m]; h->data[m] = tmp; i = m;
    }
    return ret;
}

static void dijkstra(void) {
    memset(dist, 0x3f, n * sizeof(int));
    dist[0] = 0;
    Heap h; h.cap = 64; h.sz = 0; h.data = malloc(h.cap * sizeof(Item));
    hpush(&h, (Item){0, 0});
    while (h.sz > 0) {
        Item cur = hpop(&h);
        if (cur.d > dist[cur.node]) continue;
        for (Edge* e = graph[cur.node]; e; e = e->next) {
            int nd = dist[cur.node] + e->t;
            if (nd < dist[e->to]) { dist[e->to] = nd; hpush(&h, (Item){nd, e->to}); }
        }
    }
    free(h.data);
}

static int    nodeVal[MAX_N];
static bool   visited[MAX_N];
static int    maxQ;

static void dfs(int node, int timeLeft, int quality) {
    if (node == 0 && quality > maxQ) maxQ = quality;
    for (Edge* e = graph[node]; e; e = e->next) {
        int v = e->to, t = e->t;
        if (t > timeLeft) continue;
        if (dist[v] > timeLeft - t) continue;
        int bonus = 0;
        if (!visited[v]) { visited[v] = true; bonus = nodeVal[v]; }
        dfs(v, timeLeft - t, quality + bonus);
        if (bonus) visited[v] = false;
    }
}

static int solve(int* vals, int valsSize, int edges[][3], int edgesSize, int maxTime) {
    n = valsSize;
    poolIdx = 0;
    memset(graph,   0, sizeof(graph));
    memset(visited, 0, n * sizeof(bool));
    for (int i = 0; i < n; i++) nodeVal[i] = vals[i];
    for (int i = 0; i < edgesSize; i++) addEdge(edges[i][0], edges[i][1], edges[i][2]);
    dijkstra();
    maxQ = vals[0];
    visited[0] = true;
    dfs(0, maxTime, vals[0]);
    return maxQ;
}

static int parseArr(const char* s, int* out) {
    int cnt = 0;
    while (*s && *s != '[') s++;
    if (*s) s++;
    while (*s) {
        while (*s == ' ' || *s == '\t') s++;
        if (*s == ']' || !*s) break;
        char* end;
        out[cnt++] = (int)strtol(s, &end, 10);
        s = end;
        while (*s == ',' || *s == ' ') s++;
    }
    return cnt;
}

static int parse2D(const char* s, int out[][3]) {
    int cnt = 0;
    while (*s && *s != '[') s++;
    if (*s) s++;
    while (*s) {
        while (*s == ' ' || *s == ',' || *s == '\t') s++;
        if (*s == ']' || !*s) break;
        if (*s == '[') {
            s++;
            for (int c = 0; c < 3; c++) {
                while (*s == ' ') s++;
                char* end;
                out[cnt][c] = (int)strtol(s, &end, 10);
                s = end;
                while (*s == ',' || *s == ' ') s++;
            }
            while (*s && *s != ']') s++;
            if (*s) s++;
            cnt++;
        }
    }
    return cnt;
}

int main(void) {
    static char line[1 << 16];
    static int  vals[MAX_N];
    static int  edges[MAX_E][3];
    int edgesSize = 0, valsSize = 0, maxTime = 0;

    while (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
        char* t = line;
        while (*t == ' ' || *t == '\t') t++;
        if (!*t) continue;

        if (strncmp(t, "[[", 2) == 0 || strcmp(t, "[]") == 0)
            edgesSize = parse2D(t, edges);
        else if (*t == '[')
            valsSize = parseArr(t, vals);
        else if (*t >= '0' && *t <= '9')
            maxTime = (int)strtol(t, NULL, 10);
    }

    printf("%d\n", solve(vals, valsSize, edges, edgesSize, maxTime));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^maxTime)

In worst case, we can make 4 choices at each step for maxTime steps

✓ Linear Growth

Space Complexity

O(maxTime)

Recursion depth limited by maxTime and visited set

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler