Minimum Edge Weight Equilibrium Queries in a Tree

Minimum Edge Weight Equilibrium Queries in a Tree - Problem

Imagine you're a network engineer tasked with optimizing data transmission paths in a tree-structured network. You have an undirected tree with n nodes labeled from 0 to n-1, where each edge has a specific weight representing transmission cost.

Given the tree structure through edges[i] = [ui, vi, wi] (indicating an edge between nodes ui and vi with weight wi), you need to answer multiple queries about path optimization.

For each query [ai, bi], you must find the minimum number of edge weight modifications needed to make all edges on the path from node ai to node bi have the same weight. You can change any edge's weight to any value in one operation.

Key Points:

Each query is independent - the tree resets after each query
The path between any two nodes in a tree is unique
You want to minimize operations, so keep the most frequent weight unchanged

Input & Output

example_1.py — Basic Tree Path

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

› Output: [0, 0]

💡 Note: For query [0,3]: path has edges with weights [1,1,1] - all same, so 0 operations. For query [3,6]: path has edges with weights [2,2,2] - all same, so 0 operations.

example_2.py — Mixed Weights

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

› Output: [1, 2, 3]

💡 Note: For [4,6]: path weights [6,4,6] - keep two 6's, change one 4. For [0,4]: path weights [8,4,6] - all different, keep any one. For [1,7]: path weights [4,6,2] - all different, change 2 operations.

example_3.py — Single Node Query

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

› Output: [0, 0]

💡 Note: When source equals destination, the path has no edges, so 0 operations needed.

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Create adjacency list representation of the tree with weighted edges

Preprocess for Fast Queries

Use binary lifting to enable O(log n) LCA queries with weight frequency tracking

Find Path Weights

For each query, find LCA and combine weight frequencies from both paths

Calculate Minimum Operations

Keep the most frequent weight unchanged, modify all others

Key Takeaway

🎯 Key Insight: Use binary lifting for O(log n) LCA queries and keep the most frequent edge weight unchanged to minimize modifications

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log n)

O(n log n) for preprocessing binary lifting, O(log n) per query for LCA

⚡ Linearithmic

Space Complexity

O(n log n)

Space for binary lifting table and weight frequency arrays at each level

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
edges.length == n - 1
edges[i].length == 3
0 ≤ ui, vi ≤ n - 1
1 ≤ wi ≤ 26
1 ≤ queries.length ≤ 2 * 10⁴
queries[i].length == 2
0 ≤ ai, bi ≤ n - 1

Asked in

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

The optimal approach uses Binary Lifting with LCA (Lowest Common Ancestor) to efficiently answer path queries in O(log n) time. After O(n log n) preprocessing, each query finds the LCA of two nodes and combines edge weight frequencies from both paths, then returns total_edges - max_frequency to minimize operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Path Finding	O(m * n)	O(n)	Use DFS to find path between nodes, then count edge weight frequencies
LCA with Binary Lifting (Optimal)	O(n log n + m log n)	O(n log n)	Use binary lifting for fast LCA queries and efficient path weight counting

Brute Force Path Finding — Algorithm Steps

Build adjacency list representation of the tree
For each query, use DFS to find path from source to destination
Count frequency of each edge weight on the path
Return path_length - max_frequency (minimum changes needed)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin depth-first search from source node

Explore Paths

Recursively explore each branch, backtracking when needed

Find Target

When target is found, the path is complete

Count Weights

Count frequency of each edge weight on the path

Code -

solution.c — C

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

#define MAX_N 10000
#define MAX_EDGES 50000

typedef struct {
    int node, weight;
} Edge;

Edge graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int pathWeights[MAX_N];
int pathLength;

int findPath(int start, int end, int parent) {
    if (start == end) return 1;
    
    for (int i = 0; i < graphSize[start]; i++) {
        if (graph[start][i].node != parent) {
            pathWeights[pathLength++] = graph[start][i].weight;
            if (findPath(graph[start][i].node, end, start)) {
                return 1;
            }
            pathLength--;
        }
    }
    return 0;
}

int* minimumOperationsQueries(int n, int** edges, int edgesSize, int* edgesColSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    memset(graphSize, 0, sizeof(graphSize));
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        graph[u][graphSize[u]++] = (Edge){v, w};
        graph[v][graphSize[v]++] = (Edge){u, w};
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        pathLength = 0;
        findPath(queries[i][0], queries[i][1], -1);
        
        int weightCount[27] = {0};
        for (int j = 0; j < pathLength; j++) {
            weightCount[pathWeights[j]]++;
        }
        
        int maxFreq = 0;
        for (int j = 1; j <= 26; j++) {
            if (weightCount[j] > maxFreq) {
                maxFreq = weightCount[j];
            }
        }
        
        result[i] = pathLength - maxFreq;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n)

m queries, each taking O(n) time for DFS path finding in worst case

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, recursion stack, and path storage

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁴
edges.length == n - 1
edges[i].length == 3
0 ≤ ui, vi ≤ n - 1
1 ≤ wi ≤ 26
1 ≤ queries.length ≤ 2 * 10⁴
queries[i].length == 2
0 ≤ ai, bi ≤ n - 1

47.2K Views

Medium-High Frequency

~25 min Avg. Time

1.7K 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 Path Finding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler