Evaluate Division

Evaluate Division - Problem

Array String Depth-First Search Breadth-First Search Union Find Graph Shortest Path Medium

Imagine you're building a currency exchange calculator or working with unit conversions. You're given a set of equations that represent division relationships between variables, and you need to evaluate new division queries based on these known relationships.

You have:

equations: Array of variable pairs like ["a", "b"]
values: Array of numbers where values[i] means equations[i][0] / equations[i][1] = values[i]
queries: Array of division questions you need to answer

Goal: For each query [x, y], find the value of x / y. If it can't be determined, return -1.0.

Example: If you know a/b = 2.0 and b/c = 3.0, then you can calculate a/c = 6.0 by following the chain: a/c = (a/b) × (b/c) = 2.0 × 3.0 = 6.0

Input & Output

example_1.py — Basic Division Chain

$ Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]

› Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]

💡 Note: Given: a/b = 2.0, b/c = 3.0. Query a/c: follow path a→b→c, multiply 2.0×3.0 = 6.0. Query b/a: inverse of a/b = 1/2.0 = 0.5. Query a/e: variable 'e' doesn't exist, return -1.0. Query a/a: same variable = 1.0. Query x/x: variable 'x' doesn't exist, return -1.0.

example_2.py — Single Equation

$ Input: equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]

› Output: [0.50000,2.00000,-1.00000,-1.00000]

💡 Note: Given: a/b = 0.5. Query a/b: direct relationship = 0.5. Query b/a: inverse = 1/0.5 = 2.0. Query a/c: variable 'c' not in any equation, return -1.0. Query x/y: variables 'x' and 'y' don't exist, return -1.0.

example_3.py — Complex Network

$ Input: equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]

› Output: [3.75000,0.40000,5.00000,0.20000]

💡 Note: Given: a/b = 1.5, b/c = 2.5, bc/cd = 5.0. Query a/c: path a→b→c gives 1.5×2.5 = 3.75. Query c/b: inverse of b/c = 1/2.5 = 0.4. Query bc/cd: direct = 5.0. Query cd/bc: inverse = 1/5.0 = 0.2.

Constraints

1 ≤ equations.length ≤ 20
equations[i].length == 2
1 ≤ A_i.length, B_i.length ≤ 5
values.length == equations.length
0.0 < values[i] ≤ 20.0
1 ≤ queries.length ≤ 20
queries[i].length == 2
1 ≤ C_j.length, D_j.length ≤ 5
A_i, B_i, C_j, D_j consist of lower case English letters and digits

Visualization

Tap to expand

Understanding the Visualization

Build Exchange Network

Create a graph where currencies are nodes and exchange rates are weighted edges

Add Bidirectional Rates

For each rate USD/EUR = 0.85, add USD→EUR (0.85) and EUR→USD (1.18)

Find Conversion Path

Use DFS to find path from source to destination currency

Calculate Final Rate

Multiply exchange rates along the path to get final conversion rate

Key Takeaway

🎯 Key Insight: Model as a weighted graph problem where DFS finds paths and edge weights represent conversion rates that multiply along the path

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 U Uber 22

The optimal solution uses a graph-based approach where variables are nodes and division relationships are weighted edges. Build an adjacency list with bidirectional edges (a/b=v creates edges a→b with weight v and b→a with weight 1/v), then use DFS to find paths between query variables and multiply edge weights along the path. This achieves O(N + Q×N) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Graph with DFS (Optimal)	O(N + Q × N)	O(N)	Build adjacency list graph once, then use DFS to find paths efficiently
Brute Force (Path Finding for Each Query)	O(Q × N × 2^N)	O(N)	For each query, search through all equations to find a connecting path

Graph with DFS (Optimal) — Algorithm Steps

Build adjacency list graph from equations
For each equation a/b = v, add edges: a→b with weight v, b→a with weight 1/v
For each query, use DFS to find path from source to destination
Multiply edge weights along the path to get result
Use visited set to avoid cycles during DFS

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list with bidirectional weighted edges

DFS Traversal

Use depth-first search to find path between query variables

Multiply Weights

Accumulate edge weights along the path

Return Result

Product of weights gives the division result

Code -

solution.c — C

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

#define MAX_VARS 20
#define MAX_LEN 10
#define MAX_NEIGHBORS 20

typedef struct {
    char node[MAX_LEN];
    double weight;
} Neighbor;

typedef struct {
    char var[MAX_LEN];
    Neighbor neighbors[MAX_NEIGHBORS];
    int neighborCount;
} GraphNode;

double dfs(GraphNode* graph, int graphSize, char* start, char* end, int* visited) {
    if (strcmp(start, end) == 0) return 1.0;
    
    int startIdx = -1;
    for (int i = 0; i < graphSize; i++) {
        if (strcmp(graph[i].var, start) == 0) {
            startIdx = i;
            break;
        }
    }
    
    if (startIdx == -1) return -1.0;
    visited[startIdx] = 1;
    
    for (int i = 0; i < graph[startIdx].neighborCount; i++) {
        Neighbor* neighbor = &graph[startIdx].neighbors[i];
        int neighborIdx = -1;
        
        for (int j = 0; j < graphSize; j++) {
            if (strcmp(graph[j].var, neighbor->node) == 0) {
                neighborIdx = j;
                break;
            }
        }
        
        if (neighborIdx != -1 && !visited[neighborIdx]) {
            double result = dfs(graph, graphSize, neighbor->node, end, visited);
            if (result != -1.0) {
                visited[startIdx] = 0;
                return result * neighbor->weight;
            }
        }
    }
    
    visited[startIdx] = 0;
    return -1.0;
}

double* calcEquation(char*** equations, int equationsSize, int* equationsColSize, double* values, int valuesSize, char*** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    double* result = (double*)malloc(queriesSize * sizeof(double));
    
    // Build graph
    GraphNode graph[MAX_VARS];
    int graphSize = 0;
    
    for (int i = 0; i < equationsSize; i++) {
        char* a = equations[i][0];
        char* b = equations[i][1];
        double value = values[i];
        
        // Find or create node for a
        int aIdx = -1;
        for (int j = 0; j < graphSize; j++) {
            if (strcmp(graph[j].var, a) == 0) {
                aIdx = j;
                break;
            }
        }
        if (aIdx == -1) {
            aIdx = graphSize++;
            strcpy(graph[aIdx].var, a);
            graph[aIdx].neighborCount = 0;
        }
        
        // Find or create node for b
        int bIdx = -1;
        for (int j = 0; j < graphSize; j++) {
            if (strcmp(graph[j].var, b) == 0) {
                bIdx = j;
                break;
            }
        }
        if (bIdx == -1) {
            bIdx = graphSize++;
            strcpy(graph[bIdx].var, b);
            graph[bIdx].neighborCount = 0;
        }
        
        // Add edges
        strcpy(graph[aIdx].neighbors[graph[aIdx].neighborCount].node, b);
        graph[aIdx].neighbors[graph[aIdx].neighborCount].weight = value;
        graph[aIdx].neighborCount++;
        
        strcpy(graph[bIdx].neighbors[graph[bIdx].neighborCount].node, a);
        graph[bIdx].neighbors[graph[bIdx].neighborCount].weight = 1.0 / value;
        graph[bIdx].neighborCount++;
    }
    
    // Process queries
    for (int i = 0; i < queriesSize; i++) {
        char* x = queries[i][0];
        char* y = queries[i][1];
        
        if (strcmp(x, y) == 0) {
            // Check if variable exists
            int exists = 0;
            for (int j = 0; j < graphSize; j++) {
                if (strcmp(graph[j].var, x) == 0) {
                    exists = 1;
                    break;
                }
            }
            result[i] = exists ? 1.0 : -1.0;
        } else {
            int visited[MAX_VARS] = {0};
            result[i] = dfs(graph, graphSize, x, y, visited);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + Q × N)

N to build graph, Q queries each taking O(N) DFS in worst case

✓ Linear Growth

Space Complexity

O(N)

Adjacency list storage and recursion stack

✓ Linear Space

89.2K Views

Medium-High Frequency

~18 min Avg. Time

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