Logical OR of Two Binary Grids Represented as Quad-Trees

Logical OR of Two Binary Grids Represented as Quad-Trees - Problem

You are given two Quad-Trees representing binary grids of size n × n. Your mission is to perform a logical OR operation between these two grids and return the result as a new Quad-Tree.

What is a Quad-Tree?
A Quad-Tree is a tree data structure where each internal node has exactly four children representing quadrants: topLeft, topRight, bottomLeft, and bottomRight. Each node has two properties:

val: True if the region contains all 1's, False if all 0's
isLeaf: True if this node represents a uniform region (all same values)

The Challenge:
Given quadTree1 and quadTree2, return a Quad-Tree representing the bitwise OR of the two binary matrices. The OR operation follows these rules:

0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1

Think of it as overlaying two transparent sheets - wherever there's a 1 in either sheet, the result shows a 1!

Input & Output

example_1.py — Basic OR Operation

$ Input: quadTree1 = [[0,1],[1,1],[1,1],[1,0],[1,1]], quadTree2 = [[0,1],[1,1],[1,0],[1,1],[1,1]]

› Output: [[0,1],[1,1],[1,1],[1,1],[1,1]]

💡 Note: Tree1 represents [[1,1],[1,0]] and Tree2 represents [[1,1],[0,1]]. The OR operation results in [[1,1],[1,1]], which is represented as a single leaf node with value True.

example_2.py — Complex Structure

$ Input: quadTree1 = [[0,1],[1,0],[1,0],[1,1],[1,1]], quadTree2 = [[0,1],[1,0],[0,1],[1,1],[1,0]]

› Output: [[0,1],[1,0],[0,1],[1,1],[1,1]]

💡 Note: Both trees have internal nodes with mixed values. The OR operation preserves the structure where needed and creates leaf nodes where the result is uniform.

example_3.py — All Zeros vs All Ones

$ Input: quadTree1 = [[1,0]], quadTree2 = [[1,1]]

› Output: [[1,1]]

💡 Note: Tree1 is all zeros (single leaf False) and Tree2 is all ones (single leaf True). OR result is all ones since True OR False = True.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of nodes in the larger tree, as we visit each node at most once

✓ Linear Growth

Space Complexity

O(log n)

Recursion stack depth is at most log₄(grid_size) for balanced quad-trees

⚡ Linearithmic Space

Constraints

The number of nodes in both trees is in the range [1, 4^h] where h is the height of the tree
quadTree1 and quadTree2 represent n × n grids
n == 2^x where 0 ≤ x ≤ 9
The input trees are valid quad-trees

Asked in

The optimal approach uses direct recursive tree merging with OR logic. Key insight: if either node is a leaf with value True, the result is True (since True OR anything = True). For leaf False nodes, return the other tree. When both have children, recursively merge all quadrants and optimize by merging identical leaf children. This maintains the space efficiency of quad-trees with O(n) time and O(log n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Recursive Merge (Optimal)	O(n)	O(log n)	Recursively merge quad-trees by comparing nodes and applying OR logic

Direct Recursive Merge (Optimal) — Algorithm Steps

If either node is a leaf with value True, return True leaf (OR property)
If both nodes are leaves with value False, return False leaf
If one node is leaf False and other has children, return the non-leaf node
If both have children, recursively merge all four quadrants
Check if all four children are identical leaves and merge if possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Leaf Cases

If either node is a leaf with value True, return True. If leaf with False, return the other tree.

Recursive Merge

Both nodes have children - recursively merge corresponding quadrants

Optimize Result

If all four children are identical leaves, merge them into a single leaf

Code -

solution.c — C

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

struct Node {
    bool val;
    bool isLeaf;
    struct Node* topLeft;
    struct Node* topRight;
    struct Node* bottomLeft;
    struct Node* bottomRight;
};

struct Node* createNode(bool val, bool isLeaf) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->isLeaf = isLeaf;
    node->topLeft = NULL;
    node->topRight = NULL;
    node->bottomLeft = NULL;
    node->bottomRight = NULL;
    return node;
}

struct Node* intersect(struct Node* quadTree1, struct Node* quadTree2) {
    // If either node represents all 1s, the OR result is all 1s
    if (quadTree1->isLeaf && quadTree1->val) {
        return quadTree1;
    }
    if (quadTree2->isLeaf && quadTree2->val) {
        return quadTree2;
    }
    
    // If either node represents all 0s, the OR result is the other tree
    if (quadTree1->isLeaf && !quadTree1->val) {
        return quadTree2;
    }
    if (quadTree2->isLeaf && !quadTree2->val) {
        return quadTree1;
    }
    
    // Both nodes have children, recursively merge all quadrants
    struct Node* topLeft = intersect(quadTree1->topLeft, quadTree2->topLeft);
    struct Node* topRight = intersect(quadTree1->topRight, quadTree2->topRight);
    struct Node* bottomLeft = intersect(quadTree1->bottomLeft, quadTree2->bottomLeft);
    struct Node* bottomRight = intersect(quadTree1->bottomRight, quadTree2->bottomRight);
    
    // Check if all four children are identical leaves - if so, merge them
    if (topLeft->isLeaf && topRight->isLeaf && 
        bottomLeft->isLeaf && bottomRight->isLeaf &&
        topLeft->val == topRight->val && 
        topLeft->val == bottomLeft->val && 
        topLeft->val == bottomRight->val) {
        return createNode(topLeft->val, true);
    }
    
    // Otherwise, return internal node with the four children
    struct Node* result = createNode(true, false);
    result->topLeft = topLeft;
    result->topRight = topRight;
    result->bottomLeft = bottomLeft;
    result->bottomRight = bottomRight;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the number of nodes in the larger tree, as we visit each node at most once

✓ Linear Growth

Space Complexity

O(log n)

Recursion stack depth is at most log₄(grid_size) for balanced quad-trees

⚡ Linearithmic Space

Constraints

The number of nodes in both trees is in the range [1, 4^h] where h is the height of the tree
quadTree1 and quadTree2 represent n × n grids
n == 2^x where 0 ≤ x ≤ 9
The input trees are valid quad-trees

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Recursive Merge (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler