Minimum Cost Walk in Weighted Graph - Practice Coding Problems

Minimum Cost Walk in Weighted Graph - Problem

Imagine you're exploring a network of cities connected by toll roads, where each road has a unique toll fee. Your goal is to find the cheapest possible journey between any two cities, but with a twist!

In this problem, you have an undirected weighted graph with n vertices (labeled 0 to n-1) and edges with weights. The cost of traveling isn't calculated by adding up toll fees - instead, it's calculated using the bitwise AND operation of all edge weights in your path.

Here's the key insight: you can revisit the same roads and cities multiple times in your journey! This means if taking a detour through previously visited places gives you a cheaper total cost (lower bitwise AND result), you should take it.

Input: An integer n (number of vertices), an array edges where edges[i] = [u_i, v_i, w_i] represents an edge between vertices u_i and v_i with weight w_i, and a 2D array query where query[i] = [s_i, t_i] represents queries for minimum cost walks.

Output: An array where each element is the minimum cost walk for the corresponding query, or -1 if no path exists.

Input & Output

example_1.py — Basic Connected Graph

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

› Output: [1, -1]

💡 Note: For query (0,3): vertices are connected, we can go 0→1→2→1→3. Since we can revisit edges, the minimum cost is the AND of all edges in the component: 7&7&1 = 1. For query (3,4): vertex 4 is not connected to the component containing 3, so return -1.

example_2.py — Multiple Components

$ Input: n = 3, edges = [[0,2,7],[0,1,15],[1,2,6]], query = [[1,2]]

› Output: [6]

💡 Note: All vertices are in the same component. The minimum cost path uses all edges: 15&7&6 = 6. Even though direct path 1→2 has cost 6, the global minimum considering all possible paths (including revisiting edges) is still 6.

example_3.py — Self Query Edge Case

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

› Output: [0, -1]

💡 Note: Query (0,0): asking for path from vertex to itself always returns 0. Query (0,1): no edges exist, so vertices are disconnected, return -1.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ 2 × 10⁵
edges[i].length == 3
0 ≤ u_i, v_i ≤ n - 1
u_i ≠ v_i
1 ≤ w_i ≤ 10⁶
1 ≤ query.length ≤ 2 × 10⁵
query[i].length == 2
0 ≤ s_i, t_i ≤ n - 1

Visualization

Tap to expand

Understanding the Visualization

Identify Components

Use Union-Find to group connected vertices

Calculate Security Level

For each component, AND all edge weights to find minimum required permissions

Process Queries

Return component security level or -1 for disconnected vertices

Key Takeaway

🎯 Key Insight: In connected components with revisitable edges, the minimum cost is simply the AND of all edge weights in that component!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses Union-Find data structure to identify connected components. The key insight is that within any connected component, you can traverse edges multiple times, so the minimum cost between any two vertices is the bitwise AND of ALL edge weights in that component. This reduces the problem from pathfinding to component analysis, achieving O(E × α(V) + Q) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Component Analysis (Optimal)	O(E × α(V) + Q)	O(V + E)	Use Union-Find to identify connected components, then find minimum AND within each component
Brute Force DFS Path Exploration	O(Q × 2^E)	O(V + E)	Use DFS to explore all possible paths and track minimum AND cost

Union-Find with Component Analysis (Optimal) — Algorithm Steps

Build Union-Find structure to identify connected components
For each connected component, calculate AND of all edge weights
For each query, check if vertices are in same component
If connected, return the precomputed component AND value
If not connected, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Union-Find

Create Union-Find structure and union connected vertices

Identify Components

Group vertices into connected components

Calculate Component Cost

For each component, AND all edge weights

Answer Queries

Return component cost or -1 for disconnected vertices

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int* rank;
    int size;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        int temp = px; px = py; py = temp;
    }
    
    uf->parent[py] = px;
    if (uf->rank[px] == uf->rank[py]) {
        uf->rank[px]++;
    }
}

int* minimumCost(int n, int** edges, int edgesSize, int* edgesColSize,
                int** query, int querySize, int* queryColSize, int* returnSize) {
    
    UnionFind* uf = createUnionFind(n);
    
    // Union connected vertices
    for (int i = 0; i < edgesSize; i++) {
        unionSets(uf, edges[i][0], edges[i][1]);
    }
    
    // Calculate component costs
    int* componentCost = (int*)malloc(n * sizeof(int));
    int* componentInit = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < edgesSize; i++) {
        int root = find(uf, edges[i][0]);
        int weight = edges[i][2];
        
        if (!componentInit[root]) {
            componentCost[root] = weight;
            componentInit[root] = 1;
        } else {
            componentCost[root] &= weight;
        }
    }
    
    // Process queries
    int* result = (int*)malloc(querySize * sizeof(int));
    *returnSize = querySize;
    
    for (int i = 0; i < querySize; i++) {
        int start = query[i][0], end = query[i][1];
        
        if (start == end) {
            result[i] = 0;
        } else if (find(uf, start) != find(uf, end)) {
            result[i] = -1;
        } else {
            int root = find(uf, start);
            result[i] = componentCost[root];
        }
    }
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    free(componentCost);
    free(componentInit);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × α(V) + Q)

E operations on Union-Find with inverse Ackermann function, plus Q queries in constant time

✓ Linear Growth

Space Complexity

O(V + E)

Space for Union-Find structure and component edge storage

✓ Linear Space

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

Union-Find with Component Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler