Check If Two Expression Trees are Equivalent

Check If Two Expression Trees are Equivalent - Problem

A binary expression tree is a kind of binary tree used to represent arithmetic expressions. Each node of a binary expression tree has either zero or two children. Leaf nodes (nodes with 0 children) correspond to operands (variables), and internal nodes (nodes with two children) correspond to the operators.

In this problem, we only consider the '+' operator (i.e. addition).

You are given the roots of two binary expression trees, root1 and root2. Return true if the two binary expression trees are equivalent. Otherwise, return false.

Two binary expression trees are equivalent if they evaluate to the same value regardless of what the variables are set to.

Input & Output

Example 1 — Different Structure, Same Expression

$ Input: root1 = ["+","x","y"], root2 = ["+","y","x"]

› Output: true

💡 Note: Both trees represent x + y and y + x. Since addition is commutative, these expressions are equivalent regardless of variable values.

Example 2 — Different Variables

$ Input: root1 = ["+","x","x"], root2 = ["+","y","y"]

› Output: false

💡 Note: First tree represents x + x (or 2x) while second represents y + y (or 2y). These are not equivalent since they depend on different variables.

Example 3 — Complex Nested Expression

$ Input: root1 = ["+",["+","x","y"],"z"], root2 = ["+","z",["+","y","x"]]

› Output: true

💡 Note: Tree 1: (x + y) + z, Tree 2: z + (y + x). Both evaluate to x + y + z due to associativity and commutativity of addition.

Constraints

The number of nodes in both trees are in the range [1, 4000]
Node.val.length <= 5
Node.val consists of digits and lowercase English letters
It's guaranteed that if a node has 2 children, then it is an operator
It's guaranteed that if a node has 0 children, then it is an operand

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 12 M Microsoft 8

The key insight is that two addition expression trees are equivalent if they contain the same variables with identical frequencies. Since addition is both commutative (a+b = b+a) and associative ((a+b)+c = a+(b+c)), the structure doesn't matter—only the variable counts. Best approach uses frequency counting with DFS traversal. Time: O(n), Space: O(v + h).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force Expression Evaluation

⏱️ Time: O(2^k × n) Space: O(k + h)

For each possible assignment of values to variables, evaluate both expression trees and check if they produce the same result. This approach tests equivalence by trying all combinations.

Frequency Count Approach

⏱️ Time: O(n + m) Space: O(v + h)

Since addition is commutative and associative, two expression trees are equivalent if they contain the same variables with the same frequencies. We traverse each tree and count how many times each variable appears.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Position;

int parseGrid(char* input, int*** grid) {
    // Find the grid array in the JSON
    char* gridStart = strstr(input, "[");
    if (!gridStart) return 0;
    
    // Count rows by counting opening brackets
    int n = 0;
    char* temp = gridStart + 1;
    while (*temp) {
        if (*temp == '[') n++;
        temp++;
    }
    
    if (n == 0) return 0;
    
    // Allocate grid
    *grid = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        (*grid)[i] = malloc(n * sizeof(int));
    }
    
    // Parse the grid
    temp = gridStart;
    int row = 0, col = 0;
    
    while (*temp && row < n) {
        if (isdigit(*temp) || (*temp == '-' && isdigit(*(temp + 1)))) {
            (*grid)[row][col] = atoi(temp);
            col++;
            if (col == n) {
                col = 0;
                row++;
            }
            // Skip the number
            if (*temp == '-') temp++;
            while (isdigit(*temp)) temp++;
        } else {
            temp++;
        }
    }
    
    return n;
}

bool solution(int** grid, int n) {
    // Handle single cell case
    if (n == 1) {
        return grid[0][0] == 0;
    }
    
    // Knight moves: 8 possible directions
    int knightMoves[8][2] = {{-2,-1}, {-2,1}, {-1,-2}, {-1,2}, {1,-2}, {1,2}, {2,-1}, {2,1}};
    
    // Build position map using array (since moves are 0 to n*n-1)
    Position* positionMap = malloc(n * n * sizeof(Position));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            positionMap[grid[i][j]].row = i;
            positionMap[grid[i][j]].col = j;
        }
    }
    
    // Check if move 0 starts at (0,0)
    if (positionMap[0].row != 0 || positionMap[0].col != 0) {
        free(positionMap);
        return false;
    }
    
    // Validate each consecutive move
    for (int move = 0; move < n * n - 1; move++) {
        Position currPos = positionMap[move];
        Position nextPos = positionMap[move + 1];
        
        // Check if it's a valid knight move
        bool validMove = false;
        for (int k = 0; k < 8; k++) {
            if (currPos.row + knightMoves[k][0] == nextPos.row && 
                currPos.col + knightMoves[k][1] == nextPos.col) {
                validMove = true;
                break;
            }
        }
        
        if (!validMove) {
            free(positionMap);
            return false;
        }
    }
    
    free(positionMap);
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid;
    int n = parseGrid(line, &grid);
    
    if (n == 0) {
        printf("false\n");
        return 0;
    }
    
    bool result = solution(grid, n);
    printf(result ? "true\n" : "false\n");
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

327 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