Furthest Building You Can Reach - Practice Coding Problems

Furthest Building You Can Reach - Problem

Imagine you're a daredevil parkour athlete navigating a cityscape filled with buildings of varying heights! 🏢

You start at building 0 and want to reach as far as possible by jumping from one building to the next. Here's the challenge:

If the next building is lower or equal height, you can jump freely 🦘
If the next building is taller, you need help:
- Use a ladder (works for any height difference) 🪜
- OR use bricks equal to the height difference 🧱

Given an array heights representing building heights, plus your limited supply of bricks and ladders, find the furthest building index you can reach using optimal strategy!

Goal: Maximize the distance traveled by using your resources wisely.

Input & Output

example_1.py — Basic Example

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

› Output: 4

💡 Note: Starting at building 0 (height 4): Go to building 1 (height 2) - no resources needed. Go to building 2 (height 7) - use 5 bricks. Go to building 3 (height 6) - no resources needed. Go to building 4 (height 9) - use 1 ladder. Cannot reach building 5 (height 14) as we need 5 more units but have 0 bricks and 0 ladders.

example_2.py — Ladder Heavy

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

› Output: 7

💡 Note: We can optimally use ladders for the two largest gaps (height differences of 8 and 15) and bricks for smaller gaps. This allows us to reach building 7 before getting stuck.

example_3.py — All Decreasing

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

› Output: 3

💡 Note: From 14→3 (no resources), 3→19 (use 16 bricks), 19→3 (no resources). We can reach the end with bricks to spare.

Constraints

1 ≤ heights.length ≤ 10⁵
1 ≤ heights[i] ≤ 10⁶
0 ≤ bricks ≤ 10⁹
0 ≤ ladders ≤ heights.length
Note: Building indices are 0-based

Visualization

Tap to expand

Understanding the Visualization

Initial Strategy

Start by using ladders for every upward jump - they're the most flexible resource

Resource Tracking

Keep a min-heap of all height differences where you've used ladders

Smart Reallocation

When you run out of ladders, take back the ladder from the smallest gap and use bricks there instead

Optimal Assignment

Now use that freed ladder for the current (likely larger) gap - always keeping ladders for biggest obstacles

Key Takeaway

🎯 Key Insight: The optimal strategy is counter-intuitive - don't greedily assign ladders as you encounter gaps. Instead, use a priority queue to continuously optimize and ensure ladders are always used for the largest height differences encountered so far.

Asked in

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

The optimal solution uses a greedy approach with priority queue in O(n log n) time. The key insight is to always reserve ladders for the largest height differences encountered so far. Initially use ladders for all gaps, but when running out of ladders, use a min-heap to identify the smallest gap and replace its ladder usage with bricks instead.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Recursively try using ladders or bricks at each obstacle
Binary Search + Greedy Validation	O(n log²n)	O(n)	Binary search on answer, validate each position with greedy strategy
Greedy with Priority Queue (Optimal)	O(n log n)	O(n)	Use priority queue to always assign ladders to largest gaps

Brute Force (Try All Combinations) — Algorithm Steps

Start from building 0 with given ladders and bricks
At each building i, check if we need resources to reach i+1
If no resources needed, move to next building
If resources needed, try both: use ladder OR use bricks
Recursively explore both paths and return the maximum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Journey

Begin at building 0 with full resources

Hit Obstacle

When facing a taller building, branch into two choices

Explore Paths

Recursively try both ladder and brick options

Find Maximum

Return the furthest building reached across all paths

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int backtrack(int* heights, int len, int i, int bricksLeft, int laddersLeft) {
    if (i == len - 1) {
        return i;
    }
    
    int diff = heights[i + 1] - heights[i];
    if (diff <= 0) {
        return backtrack(heights, len, i + 1, bricksLeft, laddersLeft);
    }
    
    int maxReach = i;
    
    // Try using ladder
    if (laddersLeft > 0) {
        maxReach = max(maxReach, backtrack(heights, len, i + 1, bricksLeft, laddersLeft - 1));
    }
    
    // Try using bricks
    if (bricksLeft >= diff) {
        maxReach = max(maxReach, backtrack(heights, len, i + 1, bricksLeft - diff, laddersLeft));
    }
    
    return maxReach;
}

int furthestBuilding(int* heights, int len, int bricks, int ladders) {
    return backtrack(heights, len, 0, bricks, ladders);
}

int main() {
    int heights[1000];
    int len = 0;
    char c;
    while (scanf("%d%c", &heights[len], &c) == 2) {
        len++;
        if (c == '\n') break;
    }
    
    int bricks, ladders;
    scanf("%d %d", &bricks, &ladders);
    
    printf("%d\n", furthestBuilding(heights, len, bricks, ladders));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

At each obstacle, we make 2 choices, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n buildings

⚡ Linearithmic Space

82.1K Views

High Frequency

~18 min Avg. Time

1.8K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler