Smallest Common Region - Practice Coding Problems

Smallest Common Region - Problem

Array Hash Table String Tree Depth-First Search Breadth-First Search Medium

Imagine a hierarchical system of regions where larger regions contain smaller ones, like countries containing states, states containing cities. You're given several lists where the first region in each list directly contains all other regions in that list.

The containment relationship works transitively: if region X contains region Y, and region Y contains region Z, then X indirectly contains Z. By definition, every region contains itself.

Your task: Given two specific regions, find the smallest region that contains both of them. This is essentially finding the Lowest Common Ancestor (LCA) in a tree structure.

Example: If you have regions like ["Earth", "North America", "USA"] and ["North America", "Canada", "Ontario"], and you're looking for the smallest common region containing both "USA" and "Ontario", the answer would be "North America".

Input & Output

example_1.py — Basic Tree Structure

$ Input: regions = [["Earth","North America","South America"], ["North America","United States","Canada"], ["United States","New York","Boston"], ["Canada","Ontario","Quebec"], ["South America","Brazil"]], region1 = "Quebec", region2 = "New York"

› Output: "North America"

💡 Note: Quebec is in Canada, New York is in United States. Both Canada and United States are in North America, which is the smallest region containing both Quebec and New York.

example_2.py — Same Parent

$ Input: regions = [["Earth", "North America", "South America"], ["North America", "United States", "Canada"]], region1 = "United States", region2 = "Canada"

› Output: "North America"

💡 Note: Both United States and Canada are direct children of North America, so North America is their lowest common ancestor.

example_3.py — One Contains Other

$ Input: regions = [["Earth", "North America", "South America"], ["North America", "United States", "Canada"], ["United States", "New York", "Boston"]], region1 = "United States", region2 = "New York"

› Output: "United States"

💡 Note: Since United States directly contains New York, United States itself is the smallest common region containing both.

Constraints

2 ≤ regions.length ≤ 10⁴
2 ≤ regions[i].length ≤ 20
1 ≤ regions[i][j].length, region1.length, region2.length ≤ 20
regions[i][j], region1, and region2 consist of English letters and spaces only
It's guaranteed that the smallest region exists
All regions form a valid tree structure

Visualization

Tap to expand

Understanding the Visualization

Parse Region Lists

Convert input lists into parent-child relationships

Build Tree Structure

Create a mapping where each region points to its parent

Mark First Path

Trace from region1 to root, marking all ancestors

Find Intersection

Trace from region2 upward until hitting a marked ancestor

Return LCA

The first marked ancestor encountered is the answer

Key Takeaway

🎯 Key Insight: Convert the region containment problem into a tree structure where finding the smallest common region becomes finding the Lowest Common Ancestor (LCA) - a classic tree algorithm!

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses the Lowest Common Ancestor (LCA) approach: build a parent mapping from the region lists, then trace one region's path to root while marking visited nodes, and trace the second region's path until hitting a marked node. This gives us O(n + h) time complexity where n is the total number of regions and h is the tree height, with O(n) space complexity for the parent mapping and path tracking.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n + h)	O(n)	Build parent relationships first, then trace paths to find LCA
Brute Force (Path Collection)	O(n + h)	O(n + h)	Collect all ancestors for both regions, then find the closest common one
One-Pass Optimal Solution	O(n + h)	O(n)	Build parent map and find LCA in a single optimized traversal

Two-Pass Hash Table — Algorithm Steps

First pass: Build parent mapping from all region lists
Trace from region1 to root, marking all visited nodes
Trace from region2 to root, stop at first marked node
Return the first marked node encountered

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Parent Map

Create complete parent-child mapping

Mark Path 1

Trace region1 to root, marking all nodes

Trace Path 2

Trace region2 until hitting marked node

Return LCA

First marked node encountered is the LCA

Code -

solution.c — C

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

#define MAX_REGIONS 1000
#define MAX_LEN 100

struct ParentMap {
    char child[MAX_LEN];
    char parent[MAX_LEN];
};

struct VisitedSet {
    char region[MAX_LEN];
    int visited;
};

char* findSmallestRegion(char*** regions, int regionsSize, int* regionsColSize, char* region1, char* region2) {
    struct ParentMap parent[MAX_REGIONS];
    int parentCount = 0;
    
    // First pass: Build parent mapping
    for (int i = 0; i < regionsSize; i++) {
        for (int j = 1; j < regionsColSize[i]; j++) {
            strcpy(parent[parentCount].child, regions[i][j]);
            strcpy(parent[parentCount].parent, regions[i][0]);
            parentCount++;
        }
    }
    
    // Second pass: Mark path from region1 to root
    struct VisitedSet visited[MAX_REGIONS];
    int visitedCount = 0;
    char current[MAX_LEN];
    strcpy(current, region1);
    
    while (strlen(current) > 0) {
        strcpy(visited[visitedCount].region, current);
        visited[visitedCount].visited = 1;
        visitedCount++;
        
        // Find parent of current
        int found = 0;
        for (int i = 0; i < parentCount; i++) {
            if (strcmp(parent[i].child, current) == 0) {
                strcpy(current, parent[i].parent);
                found = 1;
                break;
            }
        }
        if (!found) break;
    }
    
    // Trace from region2 until hitting visited node
    strcpy(current, region2);
    while (strlen(current) > 0) {
        // Check if current is visited
        for (int i = 0; i < visitedCount; i++) {
            if (strcmp(visited[i].region, current) == 0) {
                char* result = (char*)malloc(strlen(current) + 1);
                strcpy(result, current);
                return result;
            }
        }
        
        // Find parent of current
        int found = 0;
        for (int i = 0; i < parentCount; i++) {
            if (strcmp(parent[i].child, current) == 0) {
                strcpy(current, parent[i].parent);
                found = 1;
                break;
            }
        }
        if (!found) break;
    }
    
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + h)

O(n) to build parent mapping, O(h) for two traversals up the tree height

✓ Linear Growth

Space Complexity

O(n)

O(n) for parent mapping and O(h) for visited set in worst case

⚡ Linearithmic Space

24.3K Views

Medium Frequency

~15 min Avg. Time

847 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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler