Filling Bookcase Shelves

Filling Bookcase Shelves - Problem

You are given an array books where books[i] = [thickness_i, height_i] indicates the thickness and height of the i^th book. You are also given an integer shelfWidth.

We want to place these books in order onto bookcase shelves that have a total width shelfWidth. We choose some of the books to place on this shelf such that the sum of their thickness is less than or equal to shelfWidth, then build another level of the shelf so that the total height of the bookcase has increased by the maximum height of the books we just put down.

We repeat this process until there are no more books to place. Note that at each step of the above process, the order of the books we place is the same order as the given sequence of books.

Return the minimum possible height that the total bookshelf can be after placing shelves in this manner.

Input & Output

Example 1 — Basic Case

$ Input: books = [[1,1],[2,3],[2,1],[1,3]], shelfWidth = 4

› Output: 6

💡 Note: Optimal arrangement: Shelf 1: [1,1],[2,3] (width=3, height=3), Shelf 2: [2,1] (width=2, height=1), Shelf 3: [1,3] (width=1, height=3). Total height = 3+1+3 = 6.

Example 2 — All Books on One Shelf

$ Input: books = [[1,3],[2,4],[3,2]], shelfWidth = 6

› Output: 4

💡 Note: All books fit on one shelf: total width = 1+2+3 = 6 ≤ 6, height = max(3,4,2) = 4.

Example 3 — Each Book Separate

$ Input: books = [[3,5],[3,4],[3,3]], shelfWidth = 3

› Output: 12

💡 Note: Each book must be on its own shelf since each has width 3. Total height = 5+4+3 = 12.

Constraints

1 ≤ books.length ≤ 1000
1 ≤ thickness_i ≤ shelfWidth ≤ 1000
1 ≤ height_i ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 8 G Google 6 M Microsoft 4 f Facebook 3

The key insight is that this is a dynamic programming problem where we need to decide optimal shelf partitions. For each book position, we try all valid ways to end the current shelf and recursively solve for remaining books. The optimal approach uses bottom-up DP with Time: O(n²), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use a 1D DP array where dp[i] represents minimum height to arrange books from index i to end. Fill the array backwards, considering all valid shelf configurations for each position.

Memoized Recursion

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

Same recursive approach but cache results for each starting position to avoid redundant calculations. This dramatically reduces time complexity from exponential to quadratic.

Recursive Brute Force

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

For each book, recursively try placing it on the current shelf (if it fits) or starting a new shelf. Explore all possibilities and return the minimum height.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP array for minimum height from each position
Fill array backwards from last book to first
For each position, try all valid shelf endings and take minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP array where dp[i] = min height for books from i to end

Fill Backwards

For each position, try all valid shelf configurations

Result

dp[0] contains minimum height for all books

Code -

solution.c — C

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

int solution(int books[][2], int n, int shelfWidth) {
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = n - 1; i >= 0; i--) {
        int currentWidth = 0;
        int maxHeight = 0;
        dp[i] = INT_MAX;
        
        for (int j = i; j < n; j++) {
            currentWidth += books[j][0];
            if (currentWidth > shelfWidth) break;
            if (books[j][1] > maxHeight) maxHeight = books[j][1];
            int totalHeight = maxHeight + dp[j + 1];
            if (totalHeight < dp[i]) dp[i] = totalHeight;
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int books[1000][2];
    int n = 0;
    
    char* ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            ptr++;
            books[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            books[n][1] = atoi(ptr);
            n++;
        }
        ptr++;
    }
    
    int shelfWidth;
    scanf("%d", &shelfWidth);
    
    printf("%d\n", solution(books, n, shelfWidth));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Double nested loops - for each of n positions, we try up to n different shelf endings

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n to store minimum height for each starting position

⚡ Linearithmic Space

95.0K Views

Medium Frequency

~25 min Avg. Time

2.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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler