Unit Conversion II - Practice Coding Problems

Unit Conversion II - Problem

Unit Conversion II is an advanced graph traversal problem that simulates a unit conversion system.

You're given n types of units (indexed 0 to n-1) and a 2D array conversions where conversions[i] = [sourceUnit, targetUnit, conversionFactor] means that 1 unit of sourceUnit = conversionFactor units of targetUnit.

For each query [unitA, unitB], you need to find how many units of unitB are equivalent to 1 unit of unitA. The answer should be expressed as a fraction p/q in lowest terms, then return p × q⁻¹ mod (10⁹ + 7) where q⁻¹ is the modular multiplicative inverse of q.

Key Challenge: Handle indirect conversions (A→C via A→B→C) and return mathematically correct fractions modulo 10⁹ + 7.

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Graph + DFS with Memoization (Optimal)	O(n + q)	O(n²)	Build graph and cache DFS results for optimal performance
Graph Building + DFS	O(n + q × n)	O(n²)	Build adjacency graph first, then DFS for each query
Brute Force (Path Enumeration)	O(q × n!)	O(n)	Try all possible conversion paths for each query

Graph + DFS with Memoization (Optimal) — Algorithm Steps

Build bidirectional adjacency list from conversions
For each query, check memoization cache first
If not cached, perform DFS with fraction arithmetic
Store computed results in cache for future queries
Apply GCD reduction and modular inverse for final answer

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_NODES 1000
#define MAX_CACHE 10000

struct Edge {
    int target;
    long long num, den;
    struct Edge* next;
};

struct CacheEntry {
    int src, dst;
    long long num, den;
};

struct Edge* graph[MAX_NODES];
int visited[MAX_NODES];
struct CacheEntry cache[MAX_CACHE];
int cacheSize = 0;

long long gcd(long long a, long long b) {
    while (b) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

long long modInverse(long long a, long long mod) {
    return modPow(a, mod - 2, mod);
}

void addEdge(int src, int dst, long long num, long long den) {
    struct Edge* edge = (struct Edge*)malloc(sizeof(struct Edge));
    edge->target = dst;
    edge->num = num;
    edge->den = den;
    edge->next = graph[src];
    graph[src] = edge;
}

struct CacheEntry* findCache(int src, int dst) {
    for (int i = 0; i < cacheSize; i++) {
        if (cache[i].src == src && cache[i].dst == dst) {
            return &cache[i];
        }
    }
    return NULL;
}

void addCache(int src, int dst, long long num, long long den) {
    if (cacheSize < MAX_CACHE) {
        cache[cacheSize].src = src;
        cache[cacheSize].dst = dst;
        cache[cacheSize].num = num;
        cache[cacheSize].den = den;
        cacheSize++;
    }
}

int dfs(int curr, int target, long long num, long long den) {
    if (curr == target) {
        long long g = gcd(num, den);
        long long reducedNum = num / g;
        long long reducedDen = den / g;
        return (reducedNum * modInverse(reducedDen, MOD)) % MOD;
    }
    
    struct CacheEntry* cached = findCache(curr, target);
    if (cached) {
        long long g = gcd(num * cached->num, den * cached->den);
        long long finalNum = (num * cached->num) / g;
        long long finalDen = (den * cached->den) / g;
        return (finalNum * modInverse(finalDen, MOD)) % MOD;
    }
    
    struct Edge* edge = graph[curr];
    while (edge) {
        if (!visited[edge->target]) {
            visited[edge->target] = 1;
            int result = dfs(edge->target, target, 
                           (num * edge->num) % (1LL * MOD * MOD), 
                           (den * edge->den) % (1LL * MOD * MOD));
            if (result != -1) {
                addCache(curr, target, edge->num, edge->den);
                visited[edge->target] = 0;
                return result;
            }
            visited[edge->target] = 0;
        }
        edge = edge->next;
    }
    return -1;
}

int* solution(int conversions[][3], int convSize, int queries[][2], int querySize) {
    // Initialize
    memset(graph, 0, sizeof(graph));
    cacheSize = 0;
    
    // Build graph
    for (int i = 0; i < convSize; i++) {
        addEdge(conversions[i][0], conversions[i][1], conversions[i][2], 1);
        addEdge(conversions[i][1], conversions[i][0], 1, conversions[i][2]);
    }
    
    int* result = (int*)malloc(querySize * sizeof(int));
    for (int i = 0; i < querySize; i++) {
        if (queries[i][0] == queries[i][1]) {
            result[i] = 1;
        } else {
            memset(visited, 0, sizeof(visited));
            visited[queries[i][0]] = 1;
            int ans = dfs(queries[i][0], queries[i][1], 1, 1);
            result[i] = ans != -1 ? ans : 0;
        }
    }
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + q)

O(n) to build graph, O(1) amortized per query with memoization

✓ Linear Growth

Space Complexity

O(n²)

Adjacency list O(n) + memoization cache O(n²) for all unit pairs

⚠ Quadratic 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