Filling Bookcase Shelves - Practice Coding Problems

Filling Bookcase Shelves - Problem

Imagine you're organizing a personal library and want to create the most space-efficient bookcase possible! 📚

You have an array of books where books[i] = [thickness_i, height_i] represents the thickness and height of the i-th book. You also have a shelfWidth constraint for each shelf.

The Challenge: Place all books in the given order onto shelves such that:

Books must be placed in the exact order given (no rearranging!)
Each shelf can hold books with total thickness ≤ shelfWidth
Each shelf's height equals the tallest book on that shelf
We want to minimize the total height of the bookcase

For example, if we have 5 books, we might place books 1-2 on shelf 1, book 3 on shelf 2, and books 4-5 on shelf 3. The total height would be the sum of the maximum heights from each shelf.

Goal: Return the minimum possible height of the bookcase after optimal shelf arrangement.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: The optimal arrangement is: Shelf 1: books [1,1] and [2,3] with total thickness 3 ≤ 4, height = max(1,3) = 3. Shelf 2: books [2,3] and [1,1] with total thickness 3 ≤ 4, height = max(3,1) = 3. Total height = 3 + 3 = 6.

example_2.py — Single Shelf

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

› Output: 4

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

example_3.py — Each Book on Separate Shelf

$ Input: books = [[7,3],[8,7],[2,7],[2,5]], shelf_width = 10

› Output: 15

💡 Note: Books [7,3] and [2,7] can share a shelf (thickness 9 ≤ 10, height = max(3,7) = 7). Book [8,7] goes on its own shelf (height = 7). Book [2,5] goes on its own shelf (height = 5). Total = 7 + 7 + 5 = 19. But better: each book on separate shelf gives 3 + 7 + 7 + 5 = 22. Actually optimal is: shelf 1: [7,3], shelf 2: [8,7], shelf 3: [2,7], [2,5] giving 3 + 7 + 7 = 17. Wait, let me recalculate... Optimal: [7,3] alone (height 3), [8,7] and [2,7] together (thickness 10, height 7), [2,5] alone (height 5). Total = 3 + 7 + 5 = 15.

Constraints

1 ≤ books.length ≤ 1000
1 ≤ thickness_i ≤ shelf_width ≤ 1000
1 ≤ height_i ≤ 1000
Books must be placed in the given order (no rearranging allowed)

Visualization

Tap to expand

Understanding the Visualization

Analyze the problem

Books must stay in order, shelves have width limits, height = tallest book per shelf

Consider choices

At each book, decide: start new shelf or continue current shelf?

Use dynamic programming

Remember optimal solutions for subproblems to avoid recalculation

Build up solution

dp[i] = minimum height for first i books

Key Takeaway

🎯 Key Insight: Dynamic programming transforms an exponential brute-force problem into an efficient O(n²) solution by remembering optimal arrangements for subproblems.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming with O(n²) time complexity. We build a DP array where dp[i] represents the minimum height to arrange the first i books. For each position, we look back and try different shelf arrangements, choosing the one that minimizes total height. The key insight is that at each book, we can either start a new shelf or add it to an existing shelf, and DP helps us remember the optimal choice for each subproblem.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n²)	O(n)	Use memoization to avoid recalculating the same subproblems
Brute Force (Try All Shelf Combinations)	O(2^n)	O(n)	Try every possible way to group consecutive books into shelves

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP array where dp[i] = minimum height for books[0...i-1]
For each book position i, try placing it on a new shelf or existing shelf
For existing shelf option, look back at all valid previous positions
Choose the option (new shelf vs existing) that gives minimum height
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[0] = 0, others = infinity

For each position i

Consider all ways to place books ending at position i

Look back at valid positions

Try grouping books[j...i-1] on the same shelf

Update optimal height

dp[i] = min(dp[i], dp[j] + current_shelf_height)

Code -

solution.c — C

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

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

int main() {
    printf("DP bookshelf solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n books, we look back at most n previous positions to find best shelf arrangement

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n to store minimum heights for each subproblem

⚡ Linearithmic Space

67.9K Views

Medium-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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler