Smallest Common Region

Smallest Common Region - Problem

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

You are given some lists of regions where the first region of each list directly contains all other regions in that list.

If a region x contains a region y directly, and region y contains region z directly, then region x is said to contain region z indirectly.

Note that region x also indirectly contains all regions indirectly contained in y. Naturally, if a region x contains (either directly or indirectly) another region y, then x is bigger than or equal to y in size.

Also, by definition, a region x contains itself.

Given two regions: region1 and region2, return the smallest region that contains both of them.

It is guaranteed the smallest region exists.

Input & Output

Example 1 — Basic Hierarchy

$ 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 → Canada → North America → Earth, New York → United States → North America → Earth. First common ancestor is North America.

Example 2 — Same Region

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

› Output: "Canada"

💡 Note: Both regions are the same, so Canada contains itself.

Example 3 — Parent-Child Relationship

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

› Output: "North America"

💡 Note: North America directly contains United States, so North America is the smallest common region.

Constraints

1 ≤ regions.length ≤ 10⁴
1 ≤ regions[i].length ≤ 20
1 ≤ regions[i][j].length ≤ 20
All strings consist of English letters and spaces with at most 20 characters.
All strings are unique.
It is guaranteed a valid answer exists.

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8 M Microsoft 5

This problem is essentially finding the Lowest Common Ancestor (LCA) in a tree structure. The key insight is to build parent relationships from the region lists, then find where the ancestor paths of both regions first intersect. Best approach uses path comparison after building a parent map. Time: O(n + h), Space: O(n).

Common Approaches

✓ Brute Force - Find All Ancestors

⏱️ Time: O(n·h) Space: O(n + h)

Build ancestor sets for both regions by traversing up the hierarchy, then find the smallest common ancestor by checking all combinations.

Optimized - Direct Path Comparison

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

Build parent relationships once, then find paths from both regions to root simultaneously, comparing for the first common ancestor.

Brute Force - Find All Ancestors — Algorithm Steps

Build parent map from regions list
Find all ancestors for region1
Find all ancestors for region2
Return smallest common ancestor

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Parent Map

Create parent relationships from region lists

Collect Ancestors

Find all ancestors of region1 by traversing up

Find Common

Traverse region2's path until we hit a common ancestor

Code -

solution.c — C

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

#define MAX_REGIONS 1000
#define MAX_NAME_LEN 100
#define MAX_INPUT 10000

static char parent[MAX_REGIONS][MAX_NAME_LEN];
static char names[MAX_REGIONS][MAX_NAME_LEN];
static int name_count = 0;

int find_name_index(const char* name) {
    for (int i = 0; i < name_count; i++) {
        if (strcmp(names[i], name) == 0) return i;
    }
    strcpy(names[name_count], name);
    return name_count++;
}

char* solution(char regions[][20][MAX_NAME_LEN], int region_count, char* region1, char* region2) {
    // Build parent map
    memset(parent, 0, sizeof(parent));
    
    for (int i = 0; i < region_count; i++) {
        for (int j = 1; j < 20 && strlen(regions[i][j]) > 0; j++) {
            int child_idx = find_name_index(regions[i][j]);
            int parent_idx = find_name_index(regions[i][0]);
            strcpy(parent[child_idx], names[parent_idx]);
        }
    }
    
    // Find all ancestors of region1
    static char ancestors[MAX_REGIONS][MAX_NAME_LEN];
    int ancestor_count = 0;
    char current[MAX_NAME_LEN];
    strcpy(current, region1);
    
    while (strlen(current) > 0) {
        strcpy(ancestors[ancestor_count++], current);
        int idx = find_name_index(current);
        if (strlen(parent[idx]) > 0) {
            strcpy(current, parent[idx]);
        } else {
            current[0] = '\0';
        }
    }
    
    // Find first common ancestor in region2's path
    strcpy(current, region2);
    while (strlen(current) > 0) {
        for (int i = 0; i < ancestor_count; i++) {
            if (strcmp(current, ancestors[i]) == 0) {
                static char result[MAX_NAME_LEN];
                strcpy(result, current);
                return result;
            }
        }
        int idx = find_name_index(current);
        if (strlen(parent[idx]) > 0) {
            strcpy(current, parent[idx]);
        } else {
            current[0] = '\0';
        }
    }
    
    static char empty_result[1] = "";
    return empty_result;
}

void parse_string(char* str, char* dest) {
    int len = strlen(str);
    int j = 0;
    for (int i = 0; i < len; i++) {
        if (str[i] != '"') {
            dest[j++] = str[i];
        }
    }
    dest[j] = '\0';
}

int main() {
    static char input[MAX_INPUT];
    char region1[MAX_NAME_LEN], region2[MAX_NAME_LEN];
    static char regions[50][20][MAX_NAME_LEN];
    
    // Read JSON input
    fgets(input, MAX_INPUT, stdin);
    fgets(region1, MAX_NAME_LEN, stdin);
    fgets(region2, MAX_NAME_LEN, stdin);
    
    // Remove newlines
    region1[strcspn(region1, "\n")] = 0;
    region2[strcspn(region2, "\n")] = 0;
    
    // Parse JSON array
    int region_count = 0;
    char* ptr = input;
    
    // Find start of array
    while (*ptr && *ptr != '[') ptr++;
    ptr++; // skip '['
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n')) ptr++;
        
        if (*ptr == '[') {
            ptr++; // skip '['
            int item_count = 0;
            
            while (*ptr && *ptr != ']') {
                // Skip whitespace and commas
                while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
                
                if (*ptr == '"') {
                    ptr++; // skip opening quote
                    int len = 0;
                    while (*ptr && *ptr != '"') {
                        regions[region_count][item_count][len++] = *ptr;
                        ptr++;
                    }
                    regions[region_count][item_count][len] = '\0';
                    if (*ptr == '"') ptr++; // skip closing quote
                    item_count++;
                }
            }
            
            // Mark end of this region
            if (item_count < 20) {
                regions[region_count][item_count][0] = '\0';
            }
            
            if (*ptr == ']') ptr++; // skip ']'
            region_count++;
        }
    }
    
    char* result = solution(regions, region_count, region1, region2);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n·h)

Building parent map takes O(n), finding ancestors takes O(h) where h is height

✓ Linear Growth

Space Complexity

O(n + h)

Parent map stores O(n) relationships, ancestor sets store O(h) entries

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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 - Find All Ancestors — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler