Find Building Where Alice and Bob Can Meet

Find Building Where Alice and Bob Can Meet - Problem

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

Imagine a futuristic city where people can only move between buildings by jumping from one to another, but there's a catch - you can only jump to a taller building that's positioned to your right!

You're given an array heights where heights[i] represents the height of the i-th building. A person in building i can move to building j if and only if:

i < j (building j is to the right)
heights[i] < heights[j] (building j is taller)

You have multiple queries where Alice starts at building a[i] and Bob starts at building b[i]. For each query, find the leftmost building where both Alice and Bob can meet. If they can't meet anywhere, return -1.

The key challenge: Both Alice and Bob must be able to reach the same building following the jumping rules!

Input & Output

example_1.py — Basic Meeting Scenario

$ 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 building 0 (height 6), Bob at building 1 (height 4). Both can reach building 2 (height 8). Query [0,3]: Alice at 0 (height 6), Bob at 3 (height 5). Both can reach building 5 (height 7). Query [2,4]: Alice at 2 (height 8), Bob at 4 (height 2). No building to the right is taller than 8. Query [3,4]: Alice at 3 (height 5), Bob at 4 (height 2). No valid meeting building. Query [2,2]: Alice and Bob both at building 2, so answer is 2.

example_2.py — Direct Jump Possible

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

› Output: [7,5,-1]

💡 Note: Query [0,7]: Alice at 0 (height 5), Bob at 7 (height 6). Alice can jump directly to Bob since 5 < 6. Query [3,5]: Alice at 3 (height 2), Bob at 5 (height 1). Alice can reach Bob at building 5. Query [5,2]: Alice at 5 (height 1), Bob at 2 (height 8). Since Alice is to the right of Bob but can't reach any building taller than Bob's, answer is -1.

example_3.py — No Valid Meeting Point

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

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

💡 Note: Query [0,0]: Same building, answer is 0. Query [0,1]: Alice at 0 (height 1), Bob at 1 (height 2). Alice can jump to Bob. Query [0,2]: Both need to reach a building taller than max(1,1)=1, which is building 3. Query [0,3]: Alice can jump to building 3 directly. Similar logic for remaining queries.

Visualization

Tap to expand

Understanding the Visualization

Starting Positions

Alice and Bob begin at their respective buildings with specific heights

Jump Constraints

They can only jump to buildings that are taller and positioned to the right

Finding Meeting Point

Search for the leftmost building both can reach following the jump rules

Optimal Processing

Use monotonic stack to efficiently process multiple queries

Key Takeaway

🎯 Key Insight: The problem transforms into finding the leftmost 'next greater element' that satisfies both players' constraints. Using a monotonic stack with binary search achieves optimal O((n+m)log n) complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

For each of m queries, we potentially check all n buildings

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

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

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses a monotonic stack with binary search to efficiently process queries. Key insights: (1) Group queries by their rightmost position, (2) Maintain a monotonic decreasing stack of potential meeting buildings, (3) Use binary search to find the leftmost valid meeting point. Time complexity: O((n + m) log n) where n is buildings and m is queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Buildings)	O(n * m)	O(1)	For each query, check every possible meeting building from left to right
Monotonic Stack + Priority Queue (Optimal)	O((n + m) log n)	O(n + m)	Use monotonic stack preprocessing and priority queue for efficient query processing

Brute Force (Check All Buildings) — Algorithm Steps

For each query (Alice at position a, Bob at position b)
Start checking from building max(a, b) + 1 (first possible meeting point)
For each potential meeting building k, check if both can reach it
Alice can reach k if heights[a] < heights[k], Bob can reach k if heights[b] < heights[k]
Return the first valid meeting building, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Query

Alice at building A, Bob at building B

Check Each Building

Starting from max(A,B)+1, check if both can reach each building

Validate Jump Rules

Both must be able to jump to a taller building on the right

Return First Valid

Return the leftmost building where they can meet

Code -

solution.c — C

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

int* leftmostBuildingQueries(int* heights, int heightsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        int a = queries[i][0];
        int b = queries[i][1];
        
        // Ensure a <= b
        if (a > b) {
            int temp = a;
            a = b;
            b = temp;
        }
        
        // Same building
        if (a == b) {
            result[i] = a;
            continue;
        }
        
        // Alice can jump directly to Bob's building
        if (heights[a] < heights[b]) {
            result[i] = b;
            continue;
        }
        
        // Find leftmost meeting building
        int found = 0;
        for (int k = b + 1; k < heightsSize; k++) {
            if (heights[a] < heights[k] && heights[b] < heights[k]) {
                result[i] = k;
                found = 1;
                break;
            }
        }
        
        if (!found) {
            result[i] = -1;
        }
    }
    
    return result;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

For each of m queries, we potentially check all n buildings

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

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

34.8K Views

Medium-High Frequency

~35 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Buildings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler