# Allocate Books

Given an array of integers **A** of size **N** and an integer **B**.

College library has **N** bags,the **ith** book has **A\[i]** number of pages.

You have to allocate books to **B** number of students so that maximum number of pages alloted to a student is minimum.

```
A book will be allocated to exactly one student.
Each student has to be allocated at least one book.
Allotment should be in contiguous order, for example: A student cannot be allocated book 1 and book 3, skipping book 2.
```

Calculate and return that minimum possible number.

**NOTE:** Return -1 if a valid assignment is not possible.

\
\
**Input Format**

```
The first argument given is the integer array A.
The second argument given is the integer B.
```

**Output Format**

```
Return that minimum possible number
```

**Constraints**

```
1 <= N <= 10^5
1 <= A[i] <= 10^5
```

**For Example**

```
Input 1:
    A = [12, 34, 67, 90]
    B = 2
Output 1:
    113
Explanation 1:
    There are 2 number of students. Books can be distributed in following fashion : 
        1) [12] and [34, 67, 90]
        Max number of pages is allocated to student 2 with 34 + 67 + 90 = 191 pages
        2) [12, 34] and [67, 90]
        Max number of pages is allocated to student 2 with 67 + 90 = 157 pages 
        3) [12, 34, 67] and [90]
        Max number of pages is allocated to student 1 with 12 + 34 + 67 = 113 pages

        Of the 3 cases, Option 3 has the minimum pages = 113.

Input 2:
    A = [5, 17, 100, 11]
    B = 4
Output 2:
    100
```

```java
public class Solution {
    public int helper(int[] A, int pagesAllowed) {
        int temp = 0;
        int students = 1;
        for (int i : A) {
            temp += i;
            if (temp > pagesAllowed) {
                students++;
                temp = i;
            }
        }
        return students;
    }

    public int books(int[] A, int B) {
        if (B > A.length)
            return -1;
        int lowerBound = Integer.MIN_VALUE;
        int upperBound = 0;
        for (int i : A) {
            lowerBound = Math.max(i, lowerBound);
            upperBound += i;
        }
        while (lowerBound <= upperBound) {
            int mid = (lowerBound + upperBound) / 2;
            int students = helper(A, mid);
            if (students == B) {
                upperBound = mid - 1;
            } else if (students < B) {
                upperBound = mid - 1;
            } else {
                lowerBound = mid + 1;
            }
        }
        return lowerBound;
    }
}

```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mayanktyagi3111.gitbook.io/interview-prep/binary-searching-and-sorting/allocate-books.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.