Unit Conversion I - Practice Coding Problems

Unit Conversion I - Problem

Imagine you're building a universal unit converter for a scientific application! You have n different types of units (indexed from 0 to n-1), and you're given conversion relationships between them.

You receive a 2D array conversions where each element conversions[i] = [sourceUnit, targetUnit, conversionFactor] tells you that 1 unit of sourceUnit equals conversionFactor units of targetUnit.

Here's the challenge: Convert everything to a base unit system! You need to find how many units of each type are equivalent to 1 unit of type 0 (our base unit).

Since the conversion factors can get very large, return each result modulo 10⁹ + 7.

Example: If 1 meter = 100 cm, and 1 cm = 10 mm, then 1 meter = 1000 mm. We want to express everything in terms of meters (unit 0).

Input & Output

example_1.py — Basic Unit Conversion

$ Input: n = 3, conversions = [[0,1,10],[1,2,5]]

› Output: [1, 10, 50]

💡 Note: Unit 0 is base (factor 1). 1 unit of type 0 = 10 units of type 1, so factor for type 1 is 10. 1 unit of type 1 = 5 units of type 2, so 1 unit of type 0 = 10×5 = 50 units of type 2.

example_2.py — Disconnected Units

$ Input: n = 4, conversions = [[0,1,2],[2,3,3]]

› Output: [1, 2, 0, 0]

💡 Note: Units 2 and 3 are not connected to unit 0, so their conversion factors are 0. Only units 0 and 1 are in the same connected component.

example_3.py — Large Factors

$ Input: n = 2, conversions = [[0,1,1000000]]

› Output: [1, 1000000]

💡 Note: Direct conversion: 1 unit of type 0 equals 1,000,000 units of type 1. Since 1,000,000 < 10^9+7, no modulo needed.

Constraints

1 ≤ n ≤ 10³
conversions.length == n - 1 or fewer (tree or forest structure)
0 ≤ sourceUnit_i, targetUnit_i < n
1 ≤ conversionFactor_i ≤ 10⁹
All conversion factors are positive integers

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each unit is a node, conversions are weighted edges

Start from Base

Begin DFS/BFS from unit 0 with factor 1

Propagate Factors

Multiply factors along edges as we traverse the graph

Handle Disconnected

Units not reachable from base get factor 0

Key Takeaway

🎯 Key Insight: Model as weighted graph + single DFS traversal from base unit = O(n) optimal solution!

Asked in

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

The optimal solution models this as a weighted graph problem. Build an adjacency list from the conversions, then perform a single DFS/BFS traversal starting from unit 0. As we visit each unit, we multiply the current conversion factor by the edge weight to get the factor for the next unit. This gives us all conversion factors in O(n) time with just one graph traversal, much more efficient than running separate searches for each unit.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple DFS)	O(n²)	O(n)	Run separate DFS for each unit to find path back to base unit
Single DFS Traversal (Optimal)	O(n)	O(n)	Use single DFS/BFS from base unit to find all conversion factors at once

Brute Force (Multiple DFS) — Algorithm Steps

Build adjacency list from conversions array
For each unit i from 0 to n-1, run DFS to find path to unit 0
Track visited nodes and multiply conversion factors along the path
Store result for unit i in the answer array

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list with bidirectional edges

DFS for Unit 1

Run DFS from unit 0 to find path to unit 1

DFS for Unit 2

Run another DFS from unit 0 to find path to unit 2

Repeat

Continue for all remaining units - very inefficient!

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1000

typedef struct Edge {
    int to, factor;
    struct Edge* next;
} Edge;

Edge* graph[MAX_N];
bool visited[MAX_N];

void addEdge(int from, int to, int factor) {
    Edge* edge = (Edge*)malloc(sizeof(Edge));
    edge->to = to;
    edge->factor = factor;
    edge->next = graph[from];
    graph[from] = edge;
}

long long dfs(int current, int target) {
    if (current == target) return 1;
    
    visited[current] = true;
    Edge* edge = graph[current];
    while (edge) {
        if (!visited[edge->to]) {
            long long result = dfs(edge->to, target);
            if (result != -1) {
                visited[current] = false;
                return (result * edge->factor) % MOD;
            }
        }
        edge = edge->next;
    }
    visited[current] = false;
    return -1;
}

int* unitConversion(int n, int** conversions, int conversionsSize, int* returnSize) {
    *returnSize = n;
    int* result = (int*)malloc(n * sizeof(int));
    
    // Initialize graph
    memset(graph, 0, sizeof(graph));
    
    // Build graph
    for (int i = 0; i < conversionsSize; i++) {
        addEdge(conversions[i][0], conversions[i][1], conversions[i][2]);
        addEdge(conversions[i][1], conversions[i][0], 1);
    }
    
    // Find conversions
    for (int i = 0; i < n; i++) {
        if (i == 0) {
            result[i] = 1;
        } else {
            memset(visited, false, sizeof(visited));
            long long conversion = dfs(0, i);
            result[i] = conversion != -1 ? conversion : 0;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We perform DFS for each of n units, and each DFS can visit up to n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for adjacency list, recursion stack, and visited array

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~18 min Avg. Time

892 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 (Multiple DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler