Find Building Where Alice and Bob Can Meet - Problem

Array Binary Search Stack Binary Indexed Tree Segment Tree Heap (Priority Queue) Monotonic Stack Hard

You are given a 0-indexed array heights of positive integers, where heights[i] represents the height of the i-th building.

If a person is in building i, they can move to any other building j if and only if i < j and heights[i] < heights[j].

You are also given another array queries where queries[i] = [a_i, b_i]. On the i-th query, Alice is in building a_i while Bob is in building b_i.

Return an array ans where ans[i] is the index of the leftmost building where Alice and Bob can meet on the i-th query. If Alice and Bob cannot move to a common building on query i, set ans[i] to -1.

Input & Output

Example 1 — Basic Meeting

$ Input: heights = [6,4,8,5,2,7], queries = [[0,1],[0,3],[2,4],[3,4],[2,2]]

› Output: [2,5,-1,-1,2]

💡 Note: Query [0,1]: Alice at 6, Bob at 4. First building both can reach is index 2 (height 8). Query [0,3]: Alice needs height > 6, Bob needs > 5, first such building is index 5 (height 7). Query [2,4]: Alice at 8, Bob at 2, but no building after index 4 is taller than 8. Query [3,4]: Bob at 2, Alice at 5, no building after index 4 is taller than 5. Query [2,2]: Same position, return 2.

Example 2 — Direct Reach

$ Input: heights = [5,3,8,2,6,1,4,6], queries = [[0,7],[3,5],[2,6]]

› Output: [7,5,2]

💡 Note: Query [0,7]: Alice at height 5, Bob at height 6. Since Bob's building (index 7) is to the right and taller than Alice's, they can meet at index 7. Query [3,5]: Alice at height 2, Bob at height 1. Alice can reach Bob's position since index 5 > 3 and height 1 < 2 is false, but 6 > 2, so answer is 5. Query [2,6]: Alice already at height 8, Bob at height 4, Alice's position works.

Example 3 — No Meeting Possible

$ Input: heights = [1,2,1,2], queries = [[0,0],[1,3]]

› Output: [0,-1]

💡 Note: Query [0,0]: Same building, return 0. Query [1,3]: Alice at height 2 (index 1), Bob at height 2 (index 3). No building after index 3 exists, so they cannot meet at a common taller building.

Constraints

1 ≤ heights.length ≤ 5 × 10⁴
1 ≤ heights[i] ≤ 10⁹
1 ≤ queries.length ≤ 5 × 10⁴
queries[i] = [a_i, b_i]
0 ≤ a_i, b_i ≤ heights.length - 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that people can only move to taller buildings with higher indices. For each query, check if one person can reach the other's building directly, otherwise find the leftmost building both can reach. Best approach uses brute force with optimizations for direct reachability checks. Time: O(q × n), Space: O(1).

Common Approaches

✓ Sort First

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

Brute Force

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

For each query, iterate through all buildings to the right of both Alice and Bob's positions. Check if both can reach each building (it must be taller than their current buildings and have a greater index). Return the first such building found.

Monotonic Stack with Binary Search

⏱️ Time: O(n + q log n) Space: O(n)

For each position, precompute which buildings it can reach using a monotonic decreasing stack. For each query, use binary search to find the leftmost building both Alice and Bob can reach. This reduces the time complexity significantly for multiple queries.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int* heights, int heightsSize, int** queries, int queriesSize, int* returnSize) {
    int* result = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int a = queries[q][0];
        int b = queries[q][1];
        
        // If they're at the same building
        if (a == b) {
            result[q] = a;
            continue;
        }
        
        // Make sure a <= b
        if (a > b) {
            int temp = a;
            a = b;
            b = temp;
        }
        
        // If Bob is already at a taller building to the right
        if (heights[b] > heights[a]) {
            result[q] = b;
            continue;
        }
        
        // Look for the leftmost building both can reach
        int found = 0;
        for (int i = b + 1; i < heightsSize; i++) {
            if (heights[i] > heights[a] && heights[i] > heights[b]) {
                result[q] = i;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            result[q] = -1;
        }
    }
    
    return result;
}

int parseArray(char* line, int** arr) {
    *arr = malloc(1000 * sizeof(int));
    int count = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    
    ptr++;
    if (*ptr == ']') return 0;
    
    while (*ptr) {
        while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
        if (!*ptr || *ptr == ']') break;
        
        (*arr)[count] = strtol(ptr, &ptr, 10);
        count++;
        
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ']') break;
        if (*ptr == ',') ptr++;
    }
    
    return count;
}

int parseQueries(char* line, int*** queries) {
    *queries = malloc(1000 * sizeof(int*));
    int count = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    
    ptr++;
    if (*ptr == ']') return 0;
    
    while (*ptr) {
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        
        ptr++;
        (*queries)[count] = malloc(2 * sizeof(int));
        
        // Parse first number
        while (*ptr && !isdigit(*ptr)) ptr++;
        if (!*ptr) break;
        
        (*queries)[count][0] = strtol(ptr, &ptr, 10);
        
        // Skip to comma
        while (*ptr && *ptr != ',') ptr++;
        if (!*ptr) break;
        ptr++;
        
        // Parse second number
        while (*ptr && !isdigit(*ptr)) ptr++;
        if (!*ptr) break;
        
        (*queries)[count][1] = strtol(ptr, &ptr, 10);
        count++;
        
        // Skip to closing ']'
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr) ptr++;
    }
    
    return count;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int* heights;
    int heightsSize = parseArray(line, &heights);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int** queries;
    int queriesSize = parseQueries(line, &queries);
    
    int returnSize;
    int* result = solution(heights, heightsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Free memory
    free(heights);
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

245 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