Check for Contradictions in Equations - Practice Coding Problems

Check for Contradictions in Equations - Problem

Check for Contradictions in Equations

You are given a 2D array of strings called equations and an array of real numbers called values. Each equation equations[i] = [Ai, Bi] represents a division relationship where Ai / Bi = values[i].

Your task is to determine if there exists a contradiction in the given equations. A contradiction occurs when the same division relationship can be derived in multiple ways that yield different results.

Example: If we have a/b = 2.0 and b/c = 3.0, we can derive that a/c = 6.0. If another equation directly states a/c = 5.0, this creates a contradiction.

Goal: Return true if there is a contradiction, false otherwise.

Note: When comparing floating-point numbers, two values are considered equal if their absolute difference is less than 10^-5.

Input & Output

example_1.py — Basic Contradiction

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

› Output: true

💡 Note: From a/b = 2.0 and b/c = 3.0, we can derive a/c = 6.0. But the direct equation states a/c = 5.0, which creates a contradiction since 6.0 ≠ 5.0.

example_2.py — No Contradiction

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

› Output: false

💡 Note: From a/b = 2.0 and b/c = 3.0, we derive a/c = 6.0. The direct equation a/c = 6.0 is consistent, so no contradiction exists.

example_3.py — Disconnected Components

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

› Output: false

💡 Note: The equations represent two separate relationships (a/b = 2.0 and c/d = 3.0) with no connection between them. No contradictions can arise from disconnected components.

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each variable becomes a node, each equation creates weighted edges

Union Components

Use weighted Union-Find to efficiently group related variables

Check Consistency

When connecting already-linked variables, verify ratio matches

Detect Contradiction

Return true immediately if any inconsistency is found

Key Takeaway

🎯 Key Insight: Contradictions occur when the same relationship can be computed through different paths with different results - this is efficiently detected using weighted Union-Find structure.

Time & Space Complexity

Time Complexity

⏱️

O(n·α(n))

Union-Find operations with inverse Ackermann function

✓ Linear Growth

Space Complexity

O(n)

Parent and weight arrays for Union-Find structure

⚡ Linearithmic Space

Constraints

1 ≤ equations.length ≤ 100
equations[i].length == 2
1 ≤ Ai.length, Bi.length ≤ 5
values.length == equations.length
0.0 < values[i] ≤ 20.0
Ai and Bi consist of lowercase English letters and digits
Floating point precision: Use 10^-5 as epsilon for comparison

Asked in

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

The optimal approach uses Weighted Union-Find data structure to efficiently detect contradictions in O(n·α(n)) time. Model equations as a weighted graph where variables are nodes and ratios are edge weights. When processing each equation, check if the variables are already connected - if so, verify the ratio consistency. This approach provides early termination and uses only O(n) space, making it significantly more efficient than the O(n³) Floyd-Warshall approach.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Weighted Edges	O(n·α(n))	O(n)	Use weighted Union-Find to detect contradictions efficiently

Union-Find with Weighted Edges — Algorithm Steps

Initialize Union-Find data structure with weight tracking
For each equation, check if variables are already connected
If connected, verify the ratio matches existing path
If not connected, union the components with proper weights
Return true if any contradiction is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each variable is its own component with weight 1.0

Add Equation

Union components with weighted edges representing ratios

Check Existing

If variables already connected, verify ratio consistency

Detect Contradiction

Return true if computed ratio doesn't match expected ratio

Code -

solution.c — C

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

#define MAX_VARS 50
#define MAX_LEN 10

typedef struct {
    char vars[MAX_VARS][MAX_LEN];
    int parent[MAX_VARS];
    double weight[MAX_VARS];
    int size;
} WeightedUnionFind;

int findVar(WeightedUnionFind* uf, char* var) {
    for (int i = 0; i < uf->size; i++) {
        if (strcmp(uf->vars[i], var) == 0) {
            return i;
        }
    }
    return -1;
}

int addVar(WeightedUnionFind* uf, char* var) {
    int idx = findVar(uf, var);
    if (idx == -1) {
        strcpy(uf->vars[uf->size], var);
        uf->parent[uf->size] = uf->size;
        uf->weight[uf->size] = 1.0;
        return uf->size++;
    }
    return idx;
}

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

bool unionVars(WeightedUnionFind* uf, char* x, char* y, double ratio) {
    int idxX = addVar(uf, x);
    int idxY = addVar(uf, y);
    
    int rootX = find(uf, idxX);
    int rootY = find(uf, idxY);
    
    if (rootX == rootY) {
        double expectedRatio = uf->weight[idxX] / uf->weight[idxY];
        return fabs(expectedRatio - ratio) <= 1e-5;
    }
    
    uf->parent[rootX] = rootY;
    uf->weight[rootX] = ratio * uf->weight[idxY] / uf->weight[idxX];
    return true;
}

bool checkContradictions(char equations[][2][MAX_LEN], double* values, int equationsSize) {
    WeightedUnionFind uf = {.size = 0};
    
    for (int i = 0; i < equationsSize; i++) {
        if (!unionVars(&uf, equations[i][0], equations[i][1], values[i])) {
            return true;
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n·α(n))

Union-Find operations with inverse Ackermann function

✓ Linear Growth

Space Complexity

O(n)

Parent and weight arrays for Union-Find structure

⚡ Linearithmic Space

Constraints

1 ≤ equations.length ≤ 100
equations[i].length == 2
1 ≤ Ai.length, Bi.length ≤ 5
values.length == equations.length
0.0 < values[i] ≤ 20.0
Ai and Bi consist of lowercase English letters and digits
Floating point precision: Use 10^-5 as epsilon for comparison

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Union-Find with Weighted Edges — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler