Number of Good Paths - Practice Coding Problems

Number of Good Paths - Problem

Array Hash Table Tree Union Find Graph Sorting Hard

Imagine exploring a magical tree network where each node has a special value! You're given a tree (a connected graph with no cycles) consisting of n nodes numbered from 0 to n-1, along with their values and connections.

Your mission is to find all the "good paths" in this tree. A good path is a journey between two nodes that follows these magical rules:

🎯 Same endpoints: The starting and ending nodes must have the same value
📈 Non-increasing journey: All nodes along the path must have values ≤ the endpoint values

For example, if you have a path A → B → C where A and C have value 3, then B must have value ≤ 3 for this to be a good path.

Note: Each single node counts as a good path by itself, and paths are undirected (A→B is the same as B→A).

Input & Output

example_1.py — Simple Tree

$ Input: vals = [1,3,2,1,3], edges = [[0,1],[0,2],[2,3],[2,4]]

› Output: 6

💡 Note: Tree structure: 1-3-2-1, with 2 connected to 3. Good paths are: (0)→(0), (1)→(1), (2)→(2), (3)→(3), (4)→(4), (0)→(3) [both have value 1]. Total = 6 paths.

example_2.py — Linear Chain

$ Input: vals = [1,1,2,2,3], edges = [[0,1],[1,2],[2,3],[3,4]]

› Output: 7

💡 Note: Linear chain: 1-1-2-2-3. Good paths: 5 single nodes + (0)→(1) [value 1] + (2)→(3) [value 2] = 7 total paths.

example_3.py — Single Node

$ Input: vals = [1], edges = []

› Output: 1

💡 Note: Only one node exists, so there's exactly 1 good path: the single node (0)→(0).

Visualization

Tap to expand

Understanding the Visualization

Map Elevations

Sort all checkpoints by elevation: [1,1,3,3,3] for nodes [0,3,1,2,4]

Process Lowest First

Start with elevation 1: connect nodes 0 and 3 through valid trails

Add Higher Elevations

Process elevation 3: connect nodes 1,2,4 and merge with existing network

Count Trail Networks

Count good paths in each connected component: C(2,2)+2=3 for elevation 1, C(3,2)+3=6 for elevation 3

Key Takeaway

🎯 Key Insight: By processing elevations from lowest to highest, we guarantee that when we connect trails at elevation V, all previously connected trails are at elevation ≤ V, ensuring valid good paths!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to check times O(n) DFS for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and grouping nodes by values

⚡ Linearithmic Space

Constraints

n == vals.length
1 ≤ n ≤ 3 × 10⁴
0 ≤ vals[i] ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
The input represents a valid tree

Asked in

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

The optimal approach uses Union-Find with sorting to achieve O(n log n) time complexity. By processing nodes in ascending order of values, we ensure that when connecting nodes with value V, all previously processed neighbors have values ≤ V, maintaining the good path property. For each connected component, we count nodes with the same value and add C(count,2) + count good paths.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS for Each Pair)	O(n³)	O(n)	Check every pair of nodes with same values using DFS to validate path constraints
Union-Find with Sorting (Optimal)	O(n log n)	O(n)	Sort nodes by value and use Union-Find to efficiently count connected components

Brute Force (DFS for Each Pair) — Algorithm Steps

Group all nodes by their values
For each value, consider all pairs of nodes with that value
For each pair, use DFS to find if a valid path exists
During DFS, ensure no node exceeds the target value
Count all valid paths plus single-node paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Values

Group all nodes by their values: {1: [0,3], 3: [1,2,4]}

Check Pairs

For each value, check all pairs: (0,3) for value 1, (1,2), (1,4), (2,4) for value 3

DFS Validation

Use DFS to verify if path exists without exceeding the target value

Count Results

Add valid paths to count plus n single-node paths

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} Vector;

Vector* createVector() {
    Vector* v = malloc(sizeof(Vector));
    v->data = malloc(10 * sizeof(int));
    v->size = 0;
    v->capacity = 10;
    return v;
}

void pushVector(Vector* v, int val) {
    if (v->size >= v->capacity) {
        v->capacity *= 2;
        v->data = realloc(v->data, v->capacity * sizeof(int));
    }
    v->data[v->size++] = val;
}

bool dfs(int start, int end, int targetVal, bool* visited, Vector** graph, int* vals) {
    if (start == end) return true;
    
    visited[start] = true;
    
    for (int i = 0; i < graph[start]->size; i++) {
        int neighbor = graph[start]->data[i];
        if (!visited[neighbor] && vals[neighbor] <= targetVal) {
            if (dfs(neighbor, end, targetVal, visited, graph, vals)) {
                return true;
            }
        }
    }
    
    return false;
}

int numberOfGoodPaths(int* vals, int valsSize, int** edges, int edgesSize, int* edgesColSize) {
    int n = valsSize;
    Vector** graph = malloc(n * sizeof(Vector*));
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graph[i] = createVector();
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        pushVector(graph[edges[i][0]], edges[i][1]);
        pushVector(graph[edges[i][1]], edges[i][0]);
    }
    
    int count = n; // Single node paths
    
    // Check pairs with same values
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (vals[i] == vals[j]) {
                bool* visited = calloc(n, sizeof(bool));
                if (dfs(i, j, vals[i], visited, graph, vals)) {
                    count++;
                }
                free(visited);
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]->data);
        free(graph[i]);
    }
    free(graph);
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs to check times O(n) DFS for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and grouping nodes by values

⚡ Linearithmic Space

Constraints

n == vals.length
1 ≤ n ≤ 3 × 10⁴
0 ≤ vals[i] ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ a_i, b_i < n
The input represents a valid tree

48.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (DFS for Each Pair) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler