Furthest Building You Can Reach

Furthest Building You Can Reach - Problem

You are given an integer array heights representing the heights of buildings, along with a certain number of bricks and ladders.

You start your journey from building 0 and move to the next building by possibly using bricks or ladders.

While moving from building i to building i+1 (0-indexed):

If the current building's height is greater than or equal to the next building's height, you do not need a ladder or bricks.
If the current building's height is less than the next building's height, you can either use one ladder or (h[i+1] - h[i]) bricks.

Return the furthest building index (0-indexed) you can reach if you use the given ladders and bricks optimally.

Input & Output

Example 1 — Basic Case

$ Input: heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1

› Output: 4

💡 Note: Starting at building 0, we can reach building 4: gaps are -2 (free), +5 (use 5 bricks), -1 (free), +3 (use ladder). At gap +5 to building 5, we need bricks but have none left.

Example 2 — Use All Resources

$ Input: heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2

› Output: 7

💡 Note: Use ladders for gaps +8 and +15, use 10 bricks for gaps +5 and +5. Can reach building 7, but gap +16 to building 8 is too large.

Example 3 — All Decreasing

$ Input: heights = [14,3,19,3], bricks = 17, ladders = 0

› Output: 3

💡 Note: Gap -11 (free), +16 (use 16 bricks), -16 (free). We can reach the end using only bricks for the one upward gap.

Constraints

1 ≤ heights.length ≤ 10⁵
1 ≤ heights[i] ≤ 10⁶
0 ≤ bricks ≤ 10⁶
0 ≤ ladders ≤ heights.length

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22

The key insight is to use ladders for the largest gaps and bricks for smaller ones. The optimal approach uses a min-heap to dynamically track which gaps should use ladders versus bricks. Time: O(n log n), Space: O(n)

Common Approaches

✓ Greedy with Min-Heap

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

Use a min-heap to track the largest gaps we've used ladders for. When we encounter a new gap, use a ladder first. If we run out of ladders, replace the smallest ladder-used gap with bricks.

Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

For each gap between buildings, recursively explore both options: using a ladder or using the required bricks. This generates all possible combinations of resource usage.

Greedy with Min-Heap — Algorithm Steps

Iterate through buildings
For each gap, initially use a ladder
If out of ladders, use bricks for the smallest gap in heap
If not enough bricks, return current position

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Gap

Use ladder for each gap, add to min-heap

Swap

If too many ladders used, swap smallest to bricks

Continue

Keep largest gaps on ladders, use bricks efficiently

Code -

solution.c — C

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

void heapifyUp(int* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap[parent] <= heap[index]) break;
        int temp = heap[parent];
        heap[parent] = heap[index];
        heap[index] = temp;
        index = parent;
    }
}

void heapifyDown(int* heap, int size, int index) {
    while (1) {
        int minIndex = index;
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        
        if (leftChild < size && heap[leftChild] < heap[minIndex]) {
            minIndex = leftChild;
        }
        if (rightChild < size && heap[rightChild] < heap[minIndex]) {
            minIndex = rightChild;
        }
        
        if (minIndex == index) break;
        int temp = heap[index];
        heap[index] = heap[minIndex];
        heap[minIndex] = temp;
        index = minIndex;
    }
}

void heapPush(int* heap, int* size, int val) {
    heap[*size] = val;
    heapifyUp(heap, *size);
    (*size)++;
}

int heapPop(int* heap, int* size) {
    int min = heap[0];
    (*size)--;
    heap[0] = heap[*size];
    heapifyDown(heap, *size, 0);
    return min;
}

int solution(int* heights, int heightsSize, int bricks, int ladders) {
    int heap[1000];
    int heapSize = 0;
    
    for (int i = 0; i < heightsSize - 1; i++) {
        int gap = heights[i + 1] - heights[i];
        
        if (gap <= 0) continue;
        
        heapPush(heap, &heapSize, gap);
        
        if (heapSize > ladders) {
            int bricksNeeded = heapPop(heap, &heapSize);
            if (bricks < bricksNeeded) {
                return i;
            }
            bricks -= bricksNeeded;
        }
    }
    
    return heightsSize - 1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int heights[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        heights[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int bricks, ladders;
    scanf("%d", &bricks);
    scanf("%d", &ladders);
    
    int result = solution(heights, size, bricks, ladders);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We process n buildings, each heap operation takes O(log n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Min-heap can store up to n gaps in worst case

⚡ Linearithmic Space

86.0K Views

Medium Frequency

~25 min Avg. Time

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

Greedy with Min-Heap — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler