Maximum Number of Books You Can Take - Practice Coding Problems

Maximum Number of Books You Can Take - Problem

Imagine you're in a grand library where books are arranged on shelves in a special way. You have an array books where books[i] represents the number of books on the i-th shelf.

Here's the challenge: you can select any contiguous section of shelves from position l to r, but there's a strict rule - for consecutive shelves in your selection, you must take strictly fewer books from each shelf than the next one. This creates an ascending pattern in the number of books you take.

Goal: Find the maximum total number of books you can collect while following this ascending constraint.

Example: If you have [8,5,2,7,9] and choose shelves 2-4 (values [2,7,9]), you could take [1,2,3] books respectively, totaling 6 books.

Input & Output

example_1.py — Basic case

$ Input: [8,5,2,7,9]

› Output: 19

💡 Note: We can choose the entire array [8,5,2,7,9] and take [5,1,2,7,9] books respectively (total = 24). Or we could choose subarray [7,9] and take [1,2] books (total = 3). The optimal is to choose [2,7,9] and take [1,2,3] books for a total of 6 books. Actually, the maximum is 19 by taking the subarray ending at index 4 optimally.

example_2.py — Single element

$ Input: [7]

› Output: 7

💡 Note: With only one shelf, we can take all 7 books from it since there's no constraint to satisfy.

example_3.py — Decreasing sequence

$ Input: [5,4,3,2,1]

› Output: 5

💡 Note: Since the array is decreasing, the best we can do is take all books from any single shelf. The maximum is 5 books from the first shelf.

Visualization

Tap to expand

Understanding the Visualization

Identify constraint pattern

For position i to be reachable from position j, we need books[j] - j ≤ books[i] - i

Use monotonic stack

Stack maintains positions in increasing order of books[i] - i value

Calculate arithmetic sum

For each valid range, compute sum using arithmetic sequence formula

Key Takeaway

🎯 Key Insight: The monotonic stack efficiently finds the optimal 'foundation' for each staircase endpoint, allowing us to calculate the maximum books in O(n) time using arithmetic sequence properties.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Space for the monotonic stack and dp array

⚡ Linearithmic Space

Constraints

1 ≤ books.length ≤ 10⁵
0 ≤ books[i] ≤ 10⁵
The selected range must be contiguous
Books taken must form a strictly increasing sequence

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a monotonic stack to efficiently find the leftmost valid starting position for each ending position. By maintaining the constraint that books[i] - i increases, we can calculate the maximum books using arithmetic sequence formulas. This achieves O(n) time complexity compared to the O(n³) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Stack	O(n)	O(n)	Use monotonic stack to find valid ranges, then calculate maximum books
Brute Force (Try All Subarrays)	O(n³)	O(1)	Check every possible contiguous subarray and calculate maximum books for each

Dynamic Programming with Stack — Algorithm Steps

Use monotonic stack to find the leftmost valid starting position for each ending position
For each position i, find how far left we can extend while maintaining constraint
Calculate the sum of arithmetic sequence for the optimal range ending at each position
Return the maximum sum across all positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Build monotonic stack

Stack maintains positions in increasing order of books[i] - i

Find left boundaries

For each position, find how far left we can extend

Calculate arithmetic sums

Use formula for arithmetic sequences

Code -

solution.c — C

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

long long min(long long a, long long b) {
    return a < b ? a : b;
}

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

long long maximumBooks(int* books, int n) {
    int* leftBound = (int*)malloc(n * sizeof(int));
    int* stack = (int*)malloc(n * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < n; i++) {
        leftBound[i] = -1;
    }
    
    for (int i = 0; i < n; i++) {
        while (stackSize > 0 && books[stack[stackSize-1]] - stack[stackSize-1] >= books[i] - i) {
            stackSize--;
        }
        
        if (stackSize > 0) {
            leftBound[i] = stack[stackSize-1];
        }
        stack[stackSize++] = i;
    }
    
    long long maxBooks = 0;
    for (int i = 0; i < n; i++) {
        int left = leftBound[i] + 1;
        long long length = i - left + 1;
        long long takeAtI = min((long long)books[i], length);
        
        long long booksSum;
        if (takeAtI >= length) {
            booksSum = length * takeAtI - length * (length - 1) / 2;
        } else {
            booksSum = takeAtI * (takeAtI + 1) / 2;
        }
        
        maxBooks = max(maxBooks, booksSum);
    }
    
    free(leftBound);
    free(stack);
    return maxBooks;
}

int main() {
    int books[] = {8, 5, 2, 7, 9};
    int n = 5;
    printf("%lld\n", maximumBooks(books, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Space for the monotonic stack and dp array

⚡ Linearithmic Space

Constraints

1 ≤ books.length ≤ 10⁵
0 ≤ books[i] ≤ 10⁵
The selected range must be contiguous
Books taken must form a strictly increasing sequence

28.9K Views

Medium Frequency

~25 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler