Satisfiability of Equality Equations

Satisfiability of Equality Equations - Problem

You are given an array of strings equations that represent relationships between variables where each string equations[i] is of length 4 and takes one of two different forms: "xi==yi" or "xi!=yi".

Here, xi and yi are lowercase letters (not necessarily different) that represent one-letter variable names.

Return true if it is possible to assign integers to variable names so as to satisfy all the given equations, or false otherwise.

Input & Output

Example 1 — Basic Valid Case

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

› Output: true

💡 Note: Variables a and b must be equal, and b must not equal c. We can assign a=b=0 and c=1, satisfying both equations.

Example 2 — Contradiction

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

› Output: false

💡 Note: If a==b and b==c, then a==c by transitivity. But we also have a!=c, which creates a contradiction.

Example 3 — Self Reference

$ Input: equations = ["a!=a"]

› Output: false

💡 Note: A variable cannot be not equal to itself, so this equation is impossible to satisfy.

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

Asked in

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

The key insight is to recognize this as a graph connectivity problem. Use Union-Find to group variables that must be equal, then verify inequalities don't create contradictions. Best approach is Union-Find with Time: O(n × α(n)), Space: O(1).

Common Approaches

✓ Brute Force - Try All Assignments

⏱️ Time: O(k^n × m) Space: O(n)

For each variable, try assigning different integer values and check if all equations are satisfied. This approach tests every possible combination of variable assignments.

Union-Find (Disjoint Set)

⏱️ Time: O(n × α(n)) Space: O(1)

Process equality equations first to form connected components of variables that must be equal. Then verify that inequality equations don't contradict these groups.

Brute Force - Try All Assignments — Algorithm Steps

Generate all possible variable assignments
For each assignment, check if all equations are satisfied
Return true if any valid assignment exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Variables

Extract unique variables from equations

Try Assignments

Test all possible value combinations

Check Validity

Verify if assignment satisfies all equations

Code -

solution.c — C

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

char variables[26];
int varCount = 0;

bool tryAssignments(char equations[][5], int eqCount, int assignment[], int index) {
    if (index == varCount) {
        int varMap[26];
        for (int i = 0; i < varCount; i++) {
            varMap[variables[i] - 'a'] = assignment[i];
        }
        
        for (int i = 0; i < eqCount; i++) {
            char x = equations[i][0];
            char op1 = equations[i][1];
            char op2 = equations[i][2];
            char y = equations[i][3];
            
            if (op1 == '=' && op2 == '=') {
                if (varMap[x - 'a'] != varMap[y - 'a']) {
                    return false;
                }
            } else {
                if (varMap[x - 'a'] == varMap[y - 'a']) {
                    return false;
                }
            }
        }
        return true;
    }
    
    for (int i = 0; i < 3; i++) {
        assignment[index] = i;
        if (tryAssignments(equations, eqCount, assignment, index + 1)) {
            return true;
        }
    }
    return false;
}

bool solution(char equations[][5], int eqCount) {
    bool seen[26] = {false};
    varCount = 0;
    
    for (int i = 0; i < eqCount; i++) {
        if (!seen[equations[i][0] - 'a']) {
            variables[varCount++] = equations[i][0];
            seen[equations[i][0] - 'a'] = true;
        }
        if (!seen[equations[i][3] - 'a']) {
            variables[varCount++] = equations[i][3];
            seen[equations[i][3] - 'a'] = true;
        }
    }
    
    int assignment[26];
    return tryAssignments(equations, eqCount, assignment, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char equations[100][5];
    int eqCount = 0;
    
    char *ptr = line;
    while (*ptr) {
        // Find opening quote
        char *start = strchr(ptr, '"');
        if (!start) break;
        start++; // Move past the quote
        
        // Find closing quote
        char *end = strchr(start, '"');
        if (!end) break;
        
        // Extract equation (should be 4 characters: a==b or a!=c)
        int len = end - start;
        if (len == 4) {
            strncpy(equations[eqCount], start, 4);
            equations[eqCount][4] = '\0';
            eqCount++;
        }
        
        ptr = end + 1;
    }
    
    bool result = solution(equations, eqCount);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n × m)

k possible values for each of n variables, checking m equations per assignment

✓ Linear Growth

Space Complexity

O(n)

Storage for variable assignments

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

845 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 - Try All Assignments — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler