Satisfiability of Equality Equations - Practice Coding Problems

Satisfiability of Equality Equations - Problem

Imagine you're a mathematician trying to solve a system of equations involving variables. You're given a collection of equality and inequality constraints between single-letter variables, and you need to determine if there's a way to assign integer values to these variables that satisfies all the given constraints simultaneously.

You are provided with an array of strings equations where each equation is exactly 4 characters long and follows one of two formats:

"xi==yi" - Variable xi must equal variable yi
"xi!=yi" - Variable xi must NOT equal variable yi

Here, xi and yi are lowercase letters representing variable names (they can be the same letter).

Your task: Return true if it's possible to assign integer values to all variables such that every equation is satisfied, or false if such an assignment is impossible.

For example, if you have ["a==b", "b==c", "a!=c"], this is impossible because if a equals b and b equals c, then a must equal c, which contradicts the third equation.

Input & Output

example_1.py — Basic Equality Chain

$ Input: ["a==b","b==c","c==a"]

› Output: true

💡 Note: All variables must be equal: a = b = c. We can assign any value (e.g., 1) to all variables to satisfy all equations.

example_2.py — Contradiction Case

$ Input: ["a==b","b==c","a!=c"]

› Output: false

💡 Note: If a==b and b==c, then a must equal c (transitivity). But a!=c creates a contradiction, making the system unsatisfiable.

example_3.py — Independent Variables

$ Input: ["a==b","c==d","a!=c"]

› Output: true

💡 Note: We have two separate groups: {a,b} and {c,d}. We can assign value 1 to a,b and value 2 to c,d, satisfying all constraints.

Constraints

1 ≤ equations.length ≤ 500
equations[i].length == 4
equations[i][0] is a lowercase letter
equations[i][1] is either '=' or '!'
equations[i][2] is '='
equations[i][3] is a lowercase letter

Visualization

Tap to expand

Understanding the Visualization

Parse Constraints

Separate equality (==) and inequality (!=) constraints

Build Groups

Use Union-Find to merge variables connected by equality

Validate

Check that no inequality constraint exists within same group

Key Takeaway

🎯 Key Insight: Union-Find efficiently handles transitivity of equality while allowing quick component membership checks for inequality validation.

Asked in

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

The optimal solution uses Union-Find data structure to efficiently group variables that must be equal and then verify that inequality constraints don't contradict these groups. The key insight is to process equality constraints first to form connected components, then check if any inequality constraint exists within the same component.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n)	O(1)	Use Union-Find to group equal variables, then check inequality constraints

Union-Find (Optimal) — Algorithm Steps

Initialize Union-Find structure for all 26 possible variables
Process all equality constraints (==) by union operations
For each inequality constraint (!=), check if variables are in same component
If any inequality constraint violates component membership, return false
Otherwise, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each variable is its own parent

Union Equals

Merge variables connected by == constraints

Check Inequals

Verify != constraints don't violate groups

Code -

solution.c — C

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

int parent[26];

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void unionSets(int x, int y) {
    int px = find(x), py = find(y);
    if (px != py) {
        parent[px] = py;
    }
}

bool equationsPossible(char** equations, int equationsSize) {
    // Initialize parent array
    for (int i = 0; i < 26; i++) {
        parent[i] = i;
    }
    
    // Process equality constraints
    for (int i = 0; i < equationsSize; i++) {
        if (equations[i][1] == '=') {
            unionSets(equations[i][0] - 'a', equations[i][3] - 'a');
        }
    }
    
    // Check inequality constraints
    for (int i = 0; i < equationsSize; i++) {
        if (equations[i][1] == '!') {
            int x = equations[i][0] - 'a';
            int y = equations[i][3] - 'a';
            if (find(x) == find(y)) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    // Input parsing and solution call would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation (union/find) is nearly O(1) with path compression and union by rank

✓ Linear Growth

Space Complexity

O(1)

Fixed space for 26 possible variables (a-z)

✓ Linear Space

28.4K Views

Medium Frequency

~15 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

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler