Shortest Path in a Weighted Tree - Practice Coding Problems

Shortest Path in a Weighted Tree - Problem

Dynamic Tree Path Queries

You're managing a weighted tree network with n nodes numbered from 1 to n, rooted at node 1. The network is represented by an array edges where each edges[i] = [u_i, v_i, w_i] represents a bidirectional connection between nodes u_i and v_i with weight w_i.

You need to handle two types of dynamic queries:
• Type 1: [1, u, v, w'] - Update the weight of edge between nodes u and v to w'
• Type 2: [2, x] - Find the shortest path distance from root node 1 to node x

Goal: Return an array containing the shortest distances for all Type 2 queries, processed in order.

Since it's a tree, there's exactly one path between any two nodes, making each shortest path query deterministic but requiring efficient updates.

Input & Output

example_1.py — Basic Tree Operations

$ Input: n = 4, edges = [[1,2,5], [2,3,2], [2,4,3]], queries = [[2,3], [1,2,3,6], [2,3], [2,4]]

› Output: [7, 8, 9]

💡 Note: Initial tree: 1--(5)--2--(2)--3, 2--(3)--4. Query path 1→3: 5+2=7. Update edge (2,3) to weight 6. Query path 1→3: 5+6=11. Query path 1→4: 5+3=8.

example_2.py — Multiple Updates

$ Input: n = 3, edges = [[1,2,1], [2,3,2]], queries = [[2,3], [1,1,2,5], [2,3], [1,2,3,1], [2,3]]

› Output: [3, 7, 6]

💡 Note: Path 1→3 initially costs 1+2=3. After updating (1,2) to 5: cost becomes 5+2=7. After updating (2,3) to 1: cost becomes 5+1=6.

example_3.py — Single Node Query

$ Input: n = 2, edges = [[1,2,10]], queries = [[2,1], [1,1,2,20], [2,1]]

› Output: [0, 0]

💡 Note: Querying distance from root (node 1) to itself always returns 0, regardless of edge weight updates.

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Naive Tree Traversal	O(q × n)	O(n)	For each query, traverse the tree to find the path and calculate distance
Precomputed Distances with Updates	O(n + q × k)	O(n)	Precompute all distances from root, then update affected paths when edges change
Heavy-Light Decomposition (Optimal)	O((n + q) log²n)	O(n log n)	Advanced tree decomposition technique for efficient path queries and updates

Naive Tree Traversal — Algorithm Steps

Build adjacency list representation of the tree
For update queries: find and modify the edge weight
For distance queries: DFS/BFS from root to target node
Sum weights along the path and return the total distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin DFS traversal from node 1 (root)

Explore Branches

Recursively explore each child, tracking path weight

Find Target

When target is found, return accumulated distance

Backtrack

Sum up edge weights along the path back to root

Code -

solution.c — C

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

#define MAX_N 1005
#define MAX_QUERIES 10005

struct Edge {
    int to, weight, next;
};

struct Edge graph[MAX_N * 2];
int head[MAX_N];
int edgeCount = 0;
int edgeWeights[MAX_N][MAX_N];

void addEdge(int u, int v, int w) {
    graph[edgeCount].to = v;
    graph[edgeCount].weight = w;
    graph[edgeCount].next = head[u];
    head[u] = edgeCount++;
    
    edgeWeights[u][v] = w;
    edgeWeights[v][u] = w;
}

int dfsDistance(int start, int target, int parent) {
    if (start == target) return 0;
    
    for (int i = head[start]; i != -1; i = graph[i].next) {
        int neighbor = graph[i].to;
        if (neighbor != parent) {
            int dist = dfsDistance(neighbor, target, start);
            if (dist != -1) {
                return dist + edgeWeights[start][neighbor];
            }
        }
    }
    return -1;
}

int* solution(int n, int edges[][3], int edgesSize, int queries[][4], int queriesSize, int* returnSize) {
    memset(head, -1, sizeof(head));
    edgeCount = 0;
    
    // Build graph
    for (int i = 0; i < edgesSize; i++) {
        addEdge(edges[i][0], edges[i][1], edges[i][2]);
        addEdge(edges[i][1], edges[i][0], edges[i][2]);
    }
    
    int* results = (int*)malloc(queriesSize * sizeof(int));
    int resultCount = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) {
            int u = queries[i][1], v = queries[i][2], w = queries[i][3];
            edgeWeights[u][v] = w;
            edgeWeights[v][u] = w;
        } else {
            int x = queries[i][1];
            int distance = dfsDistance(1, x, -1);
            results[resultCount++] = distance;
        }
    }
    
    *returnSize = resultCount;
    return results;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

Each of q queries requires O(n) tree traversal in worst case

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list representation and recursion stack

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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