Check for Contradictions in Equations

Check for Contradictions in Equations - Problem

You are given a 2D array of strings equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] means that Ai / Bi = values[i].

Determine if there exists a contradiction in the equations. Return true if there is a contradiction, or false otherwise.

Note: When checking if two numbers are equal, check that their absolute difference is less than 10^-5. The testcases are generated such that there are no cases targeting precision, i.e. using double is enough to solve the problem.

Input & Output

Example 1 — No Contradiction

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

› Output: false

💡 Note: We have a/b = 2.0 and b/c = 3.0, which gives a/c = 6.0. No contradictory equations exist.

Example 2 — Direct Contradiction

$ Input: equations = [["a","b"],["a","b"]], values = [2.0,3.0]

› Output: true

💡 Note: Same equation a/b appears twice with different values (2.0 and 3.0), which is a contradiction.

Example 3 — Indirect Contradiction

$ Input: equations = [["a","b"],["b","c"],["a","c"]], values = [2.0,3.0,5.0]

› Output: true

💡 Note: We have a/b = 2.0 and b/c = 3.0, so a/c should be 6.0, but the direct equation gives a/c = 5.0.

Constraints

1 ≤ equations.length ≤ 500
equations[i].length == 2
1 ≤ equations[i][j].length ≤ 5
values[i] > 0.0
1 ≤ values.length ≤ 500

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to model equations as a weighted graph where variables are nodes and ratios are edge weights. Build the graph and use DFS to detect contradictory paths between variables. Best approach is DFS Graph Traversal with Time: O(V²), Space: O(V + E)

Common Approaches

✓ Brute Force Path Checking

⏱️ Time: O(n³) Space: O(n²)

For each pair of equations, try to find a path connecting them and verify if the calculated ratio matches any direct equation. This involves checking all possible transitive relationships.

DFS Graph Traversal

⏱️ Time: O(V²) Space: O(V + E)

Create a graph where variables are nodes and equations are weighted edges. Use DFS to explore paths between variables and detect when different paths give contradictory ratios.

Brute Force Path Checking — Algorithm Steps

Build all direct ratios from equations
For each variable pair, calculate ratio through all possible paths
Check if any path gives contradictory results

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency map with division ratios

Check Paths

Compare direct vs indirect paths between all variable pairs

Detect Contradiction

Return true if any path gives inconsistent ratios

Code -

solution.c — C

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

#define MAX_VARS 100
#define MAX_NAME_LEN 10
#define EPS 1e-5

static char variables[MAX_VARS][MAX_NAME_LEN];
static double graph[MAX_VARS][MAX_VARS];
static int var_count = 0;

int findOrAddVariable(const char* name) {
    for (int i = 0; i < var_count; i++) {
        if (strcmp(variables[i], name) == 0) {
            return i;
        }
    }
    strcpy(variables[var_count], name);
    return var_count++;
}

bool solution(char equations[][2][MAX_NAME_LEN], double* values, int eq_count) {
    // Initialize graph
    for (int i = 0; i < MAX_VARS; i++) {
        for (int j = 0; j < MAX_VARS; j++) {
            graph[i][j] = -1.0; // -1 means no edge
        }
        graph[i][i] = 1.0; // self ratio is 1
    }
    
    var_count = 0;
    
    // Build graph with ratios
    for (int i = 0; i < eq_count; i++) {
        int a = findOrAddVariable(equations[i][0]);
        int b = findOrAddVariable(equations[i][1]);
        double ratio = values[i];
        
        // Check for direct contradiction with same equation
        if (graph[a][b] > 0 && fabs(graph[a][b] - ratio) > EPS) {
            return true;
        }
        if (graph[b][a] > 0 && fabs(graph[b][a] - 1.0/ratio) > EPS) {
            return true;
        }
        
        graph[a][b] = ratio;
        graph[b][a] = 1.0 / ratio;
    }
    
    // Check for indirect contradictions using 2-hop paths
    for (int start = 0; start < var_count; start++) {
        for (int end = 0; end < var_count; end++) {
            if (start != end && graph[start][end] > 0) {
                double directRatio = graph[start][end];
                
                // Check all possible intermediate variables for 2-hop paths
                for (int intermediate = 0; intermediate < var_count; intermediate++) {
                    if (intermediate != start && intermediate != end &&
                        graph[start][intermediate] > 0 && graph[intermediate][end] > 0) {
                        
                        double indirectRatio = graph[start][intermediate] * graph[intermediate][end];
                        
                        if (fabs(directRatio - indirectRatio) > EPS) {
                            return true;
                        }
                    }
                }
            }
        }
    }
    
    return false;
}

int main() {
    char line[1000];
    
    // Read equations line
    if (!fgets(line, sizeof(line), stdin)) {
        printf("false\n");
        return 1;
    }
    
    char equations[500][2][MAX_NAME_LEN];
    int eq_count = 0;
    
    // Parse equations
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']' && eq_count < 500) {
        while (*ptr == ' ' || *ptr == ',' || *ptr == '[') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        
        // Read first variable
        if (*ptr == '"') ptr++;
        int i = 0;
        while (*ptr && *ptr != '"' && *ptr != ',' && i < MAX_NAME_LEN - 1) {
            equations[eq_count][0][i++] = *ptr++;
        }
        equations[eq_count][0][i] = '\0';
        
        while (*ptr && (*ptr == '"' || *ptr == ',' || *ptr == ' ')) ptr++;
        
        // Read second variable
        if (*ptr == '"') ptr++;
        i = 0;
        while (*ptr && *ptr != '"' && *ptr != ']' && i < MAX_NAME_LEN - 1) {
            equations[eq_count][1][i++] = *ptr++;
        }
        equations[eq_count][1][i] = '\0';
        
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        eq_count++;
    }
    
    // Read values line
    if (!fgets(line, sizeof(line), stdin)) {
        printf("false\n");
        return 1;
    }
    
    double values[500];
    int val_count = 0;
    
    ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']' && val_count < 500) {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        values[val_count++] = strtod(ptr, &ptr);
    }
    
    bool result = solution(equations, values, eq_count);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each pair of variables, we may need to check all possible paths

✓ Linear Growth

Space Complexity

O(n²)

Store all variable relationships in a map

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

456 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 Path Checking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler