Allocate Minimum Pages Binary Search on Answer in DSA Python - Time & Space Complexity

Time Complexity: Allocate Minimum Pages Binary Search on Answer

O(n * log(sum_of_pages))

Understanding Time Complexity

We want to find how fast the binary search approach works to allocate minimum pages among students.

How does the number of operations grow as the number of books or pages increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

def is_possible(arr, n, m, mid):
    students_required = 1
    current_sum = 0
    for i in range(n):
        if arr[i] > mid:
            return False
        if current_sum + arr[i] > mid:
            students_required += 1
            current_sum = arr[i]
            if students_required > m:
                return False
        else:
            current_sum += arr[i]
    return True


def find_pages(arr, n, m):
    start = max(arr)
    end = sum(arr)
    result = end
    while start <= end:
        mid = (start + end) // 2
        if is_possible(arr, n, m, mid):
            result = mid
            end = mid - 1
        else:
            start = mid + 1
    return result

This code tries to find the minimum maximum pages assigned to any student by using binary search on the answer range.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop inside is_possible that checks if pages can be allocated within the mid limit.
• How many times: This loop runs for all books (n) inside each binary search step.
• Binary search steps: The while loop halves the search space between max pages and total pages.

How Execution Grows With Input

Each binary search step checks all books once. The number of binary search steps depends on the range of pages.

Input Size (n)	Approx. Operations
10 (books)	About 10 * log(sum of pages) checks
100 (books)	About 100 * log(sum of pages) checks
1000 (books)	About 1000 * log(sum of pages) checks

Pattern observation: Operations grow linearly with number of books and logarithmically with the page range.

Final Time Complexity

Time Complexity: O(n * log(sum_of_pages))

This means the time grows linearly with the number of books and logarithmically with the total pages range.

Common Mistake

[X] Wrong: "The binary search runs in O(log n) where n is the number of books."

[OK] Correct: The binary search runs on the range of possible page sums, not on the number of books. The number of books affects the linear check inside each step.

Interview Connect

Understanding this time complexity helps you explain how binary search can be applied beyond simple arrays, showing problem-solving skills with search on answer space.

Self-Check

"What if we changed the allocation check to use recursion instead of a loop? How would the time complexity change?"

Practice

1. What is the main goal of the Allocate Minimum Pages problem when using binary search on the answer?

easy

A. To find the minimum maximum number of pages assigned to a student

B. To maximize the total pages assigned to all students

C. To find the maximum number of students that can be assigned books

D. To minimize the total number of books assigned

Solution

1. Step 1: Understand the problem goal

   The problem aims to allocate books to students such that the maximum pages assigned to any student is minimized.

2. Step 2: Clarify the binary search target

   Binary search is used on the range of possible maximum pages to find the smallest feasible maximum.

3. Final Answer:

   To find the minimum maximum number of pages assigned to a student -> Option A

4. Quick Check:

   Minimum max pages = goal [OK]

Hint: Focus on minimizing the largest pages any student gets [OK]

Common Mistakes:

• Confusing total pages with maximum pages per student
• Trying to maximize pages instead of minimizing
• Ignoring the binary search on answer approach

2. Which of the following is the correct way to initialize the binary search boundaries for the Allocate Minimum Pages problem given an array pages of book pages?

easy

A. low = sum(pages), high = max(pages)

B. low = max(pages), high = sum(pages)

C. low = 0, high = max(pages)

D. low = 0, high = sum(pages) * 2

Solution

1. Step 1: Determine minimum and maximum possible max pages

   The minimum max pages is at least the largest single book (max of pages), and the maximum is the sum of all pages if one student gets all books.

2. Step 2: Set binary search boundaries accordingly

   Set low = max(pages) and high = sum(pages) to cover all feasible max page values.

3. Final Answer:

   low = max(pages), high = sum(pages) -> Option B

4. Quick Check:

   Boundaries = max and sum [OK]

Hint: Low starts at max single book, high at total pages sum [OK]

Common Mistakes:

• Setting low to 0 which is invalid
• Swapping low and high values
• Using arbitrary high value instead of sum

3. What will be the output of the following code snippet?

def is_possible(pages, students, mid):
    count = 1
    total = 0
    for p in pages:
        if total + p > mid:
            count += 1
            total = p
            if count > students:
                return False
        else:
            total += p
    return True

pages = [10, 20, 30, 40]
students = 2
mid = 50
print(is_possible(pages, students, mid))

medium

A. True

B. None

C. SyntaxError

D. False

Solution

1. Step 1: Trace the allocation with mid = 50

   pages=[10,20,30,40], students=2: count=1, total=0 - p=10: total=10 <=50 - p=20: total=30 <=50 - p=30: 30+30=60 >50 -> count=2, total=30 - p=40: 30+40=70 >50 -> count=3 >2 -> return False

2. Step 2: Check if count exceeds students

   Count reaches 3 > 2, so return False.

3. Final Answer:

   False -> Option D

4. Quick Check:

   Allocation not possible with mid=50 = False [OK]

Hint: Check if books fit in mid pages per student [OK]

Common Mistakes:

• Miscounting students needed
• Adding pages incorrectly
• Confusing > and >= in condition

4. Identify the bug in the following code snippet for the Allocate Minimum Pages problem:

def allocate_pages(pages, students):
    low = max(pages)
    high = sum(pages)
    result = 0
    while low <= high:
        mid = (low + high) // 2
        if is_possible(pages, students, mid):
            result = mid
            low = mid + 1
        else:
            high = mid - 1
    return result

medium

A. The high pointer should move to mid - 1 when allocation is possible

B. The low pointer should move to mid + 1 when allocation is possible

C. The low pointer should move to mid when allocation is possible

D. The low pointer should move to mid - 1 when allocation is not possible

Solution

1. Step 1: Understand binary search update rules

   If allocation is possible at mid, we try to find smaller max pages by moving high to mid - 1. If not possible, we increase low to mid + 1.

2. Step 2: Identify incorrect pointer update

   The code incorrectly moves low to mid + 1 when allocation is possible instead of high to mid - 1, which searches larger values instead of smaller.

3. Final Answer:

   The high pointer should move to mid - 1 when allocation is possible -> Option A

4. Quick Check:

   Move high down when allocation succeeds [OK]

Hint: Move low up only when allocation fails, else move high down [OK]

Common Mistakes:

• Swapping low and high updates
• Not updating pointers correctly causing infinite loop
• Returning wrong result due to pointer errors

5. Given the books with pages [12, 34, 67, 90] and 3 students, what is the minimum possible maximum number of pages assigned to a student using binary search on answer?

hard

A. 67

B. 113

C. 90

D. 34

Solution

1. Step 1: Set binary search boundaries

   low = max(pages) = 90, high = sum(pages) = 203.

2. Step 2: Check feasibility at mid values

   Try mid = (90+203)//2 = 146: count=1, total=0 - p=12: total=12 <=146 - p=34: total=46 <=146 - p=67: total=113 <=146 - p=90: 113+90=203 >146 -> count=2, total=90 count=2 <=3, possible -> try smaller max Try mid = (90+145)//2 = 117: count=1, total=0 - p=12: total=12 <=117 - p=34: total=46 <=117 - p=67: total=113 <=117 - p=90: 113+90=203 >117 -> count=2, total=90 count=2 <=3, possible -> try smaller max Try mid = (90+116)//2 = 103: count=1, total=0 - p=12: total=12 <=103 - p=34: total=46 <=103 - p=67: 46+67=113 >103 -> count=2, total=67 - p=90: 67+90=157 >103 -> count=3, total=90 count=3 <=3, possible -> try smaller max Try mid = (90+102)//2 = 96: count=1, total=0 - p=12: total=12 <=96 - p=34: total=46 <=96 - p=67: 46+67=113 >96 -> count=2, total=67 - p=90: 67+90=157 >96 -> count=3, total=90 count=3 <=3, possible -> try smaller max Try mid = (90+95)//2 = 92: count=1, total=0 - p=12: total=12 <=92 - p=34: total=46 <=92 - p=67: 46+67=113 >92 -> count=2, total=67 - p=90: 67+90=157 >92 -> count=3, total=90 count=3 <=3, possible -> try smaller max Try mid = (90+91)//2 = 90: count=1, total=0 - p=12: total=12 <=90 - p=34: total=46 <=90 - p=67: 46+67=113 >90 -> count=2, total=67 - p=90: 67+90=157 >90 -> count=3, total=90 count=3 <=3, possible Try mid = (90+89)//2 = 89 (low > high, stop) Minimum max pages = 90

3. Final Answer:

   90 -> Option C

4. Quick Check:

   Minimum max pages = 90 [OK]

Hint: Binary search between max single book and total pages sum [OK]

Common Mistakes:

• Choosing max single book as answer without checking feasibility
• Not updating low and high correctly during binary search
• Misallocating books to students during checks