Add Minimum Number of Rungs - Problem

Array Greedy Medium

You are given a strictly increasing integer array rungs that represents the height of rungs on a ladder. You are currently on the floor at height 0, and you want to reach the last rung.

You are also given an integer dist. You can only climb to the next highest rung if the distance between where you are currently at (the floor or on a rung) and the next rung is at most dist. You are able to insert rungs at any positive integer height if a rung is not already there.

Return the minimum number of rungs that must be added to the ladder in order for you to climb to the last rung.

Input & Output

Example 1 — Basic Gap Filling

$ Input: rungs = [1,3,5,10], dist = 2

› Output: 2

💡 Note: Gap from 0→1 is 1 (≤2, ok). Gap from 1→3 is 2 (≤2, ok). Gap from 3→5 is 2 (≤2, ok). Gap from 5→10 is 5 (>2), need (5-1)/2 = 2 rungs at heights 7 and 9.

Example 2 — Multiple Small Gaps

$ Input: rungs = [3,6,8,10], dist = 3

› Output: 0

💡 Note: Gap 0→3 is 3 (≤3, ok). Gap 3→6 is 3 (≤3, ok). Gap 6→8 is 2 (≤3, ok). Gap 8→10 is 2 (≤3, ok). No additional rungs needed.

Example 3 — Large Initial Gap

$ Input: rungs = [3,4,6,7], dist = 2

› Output: 1

💡 Note: Gap 0→3 is 3 (>2), need (3-1)/2 = 1 rung. All other gaps are ≤2. Total: 1 rung.

Constraints

1 ≤ rungs.length ≤ 10⁵
1 ≤ rungs[i] ≤ 10⁹
1 ≤ dist ≤ 10⁹
rungs is strictly increasing

Visualization

Tap to expand

Asked in

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

The key insight is to use a greedy approach: for each gap larger than dist, add exactly (gap-1)/dist rungs. This gives the minimum number since we can space added rungs exactly dist apart. Best approach is greedy with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible combination of adding rungs at different heights between existing rungs. For each combination, check if the ladder becomes climbable and track the minimum rungs needed.

Greedy - Optimal Gap Filling

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

Iterate through each pair of consecutive rungs and calculate the gap. If the gap exceeds dist, add exactly the minimum number of rungs needed to make that gap climbable.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible positions to add rungs
For each combination, check if ladder is climbable
Return minimum rungs from valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible rung placements

Validate

Check if each combination allows climbing

Minimize

Find combination with minimum added rungs

Code -

solution.c — C

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

int canClimb(int* positions, int size, int maxDist) {
    int prev = 0;
    for (int i = 0; i < size; i++) {
        if (positions[i] - prev > maxDist) {
            return 0;
        }
        prev = positions[i];
    }
    return 1;
}

int backtrack(int* rungs, int rungsSize, int dist, int index, int* currentRungs, int currentSize, int addedCount) {
    if (index >= rungsSize) {
        if (canClimb(currentRungs, currentSize, dist)) {
            return addedCount;
        }
        return INT_MAX;
    }
    
    currentRungs[currentSize] = rungs[index];
    int result = backtrack(rungs, rungsSize, dist, index + 1, currentRungs, currentSize + 1, addedCount);
    
    int prevHeight = currentSize == 0 ? 0 : currentRungs[currentSize - 1];
    int gap = rungs[index] - prevHeight;
    
    if (gap > dist) {
        for (int addCount = 1; addCount <= gap / dist + 1; addCount++) {
            int testRungs[1000];
            for (int i = 0; i < currentSize; i++) {
                testRungs[i] = currentRungs[i];
            }
            int testSize = currentSize;
            for (int i = 1; i <= addCount; i++) {
                testRungs[testSize++] = prevHeight + i * dist;
            }
            testRungs[testSize++] = rungs[index];
            int temp = backtrack(rungs, rungsSize, dist, index + 1, testRungs, testSize, addedCount + addCount);
            if (temp != INT_MAX && temp < result) {
                result = temp;
            }
        }
    }
    
    return result;
}

int solution(int* rungs, int rungsSize, int dist) {
    int currentRungs[1000];
    return backtrack(rungs, rungsSize, dist, 0, currentRungs, 0, 0);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each possible position between rungs, we have 2 choices (add rung or not), leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space to store current combination

⚡ Linearithmic Space

26.3K Views

Medium Frequency

~15 min Avg. Time

847 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

Add Minimum Number of Rungs - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler