# Allocate minimum number of pages (Non Consecutive)

Given the number of pages in **N** different books and **M** students. Every student is assigned to read some books that can be consecutive or non-consecutive. The task is to assign books so that the maximum number of pages assigned to a student is minimum.

**Examples:**

Input: pages = {8, 15, 10, 20, 8}, M = 2Output:31Explanation:One optimal distribution is [8, 15, 8] and [10, 20]

- The 1st student receives [8, 15, 8] which has a total of 8 + 15 + 8 = 31 pages.
- The 2nd student receives [10, 20] which has a total of 10 + 20 = 30 pages.
- The distribution is max(31, 30) = 31.
It can be shown that there is no distribution with maximum number of pages less than 31.

Input:pages = {6, 1, 3, 2, 2, 4, 1, 2}, M = 3Output:7Explanation:One optimal distribution is [6, 1], [3, 2, 2], and [4, 1, 2]

- The 1st student receives [6, 1] which has a total of 6 + 1 = 7 pages.
- The 2nd student receives [3, 2, 2] which has a total of 3 + 2 + 2 = 7 pages.
- The 3rd student receives [4, 1, 2] which has a total of 4 + 1 + 2 = 7 pages.
- The distribution is max(7, 7, 7) = 7.
It can be shown that there is no distribution maximum number of pages less than 7.

**Approach:** The problem can be solved based on the concept of **backtracking**:

For each book there are two choices

- Give a book to student and sum the no of pages for that student
- Skip that student and give the book to another student.
After all books are allocated

- Find the maximum no of pages allocated for a student in every case and
- Store the minimum among the maximum allocation

Follow the given steps to solve the problem using the above approach:

- Recursively for every book:
- Loop through each student and assign the book to him or move on to the next student.

- Once all the books have been distributed,
- Calculate the maximum number of pages assigned to a student and
- Return the minimum of the current maximum, and answer calculated in the earlier steps

Below is the implementation for the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `int` `ans = INT_MAX;` `vector<` `int` `> students;` `// Function to minimize the maximum number of pages` `void` `rec(` `int` `i, ` `int` `N, vector<` `int` `>& pages, ` `int` `M)` `{` ` ` `if` `(i == N) {` ` ` `// If all books are included then find` ` ` `// the maximum no of pages for any` ` ` `// student store minimum among` ` ` `// the maximum` ` ` `ans = min(ans, *max_element(students.begin(),` ` ` `students.end()));` ` ` `return` `;` ` ` `}` ` ` `// ith book can go in any of the students` ` ` `for` `(` `int` `j = 0; j < M; ++j) {` ` ` `// Include the book for jth student` ` ` `students[j] += pages[i];` ` ` `// Recursively call for the next book` ` ` `rec(i + 1, N, pages, M);` ` ` `// If the ith book is not included for jth student` ` ` `students[j] -= pages[i];` ` ` `}` `}` `// Driver's code` `int` `main()` `{` ` ` `vector<` `int` `> pages = { 8, 15, 10, 20, 8 };` ` ` `int` `M = 2;` ` ` `students.assign(M, 0);` ` ` `// Function call` ` ` `rec(0, pages.size(), pages, M);` ` ` `cout << ans << endl;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG {` ` ` `static` `int` `ans = Integer.MAX_VALUE;` ` ` `static` `int` `[] students = ` `new` `int` `[` `2` `];` ` ` `// Function to minimize the maximum number of pages` ` ` `static` `void` `rec(` `int` `i, ` `int` `N, ` `int` `[] pages, ` `int` `M)` ` ` `{` ` ` `if` `(i == N) {` ` ` `// If all books are included then find the` ` ` `// maximum no of pages for any student store` ` ` `// minimum among the maximum` ` ` `ans = Math.min(` ` ` `ans,` ` ` `Arrays.stream(students).max().getAsInt());` ` ` `return` `;` ` ` `}` ` ` `// ith book can go in any of the students` ` ` `for` `(` `int` `j = ` `0` `; j < M; j++) {` ` ` `// Include the book for jth student` ` ` `students[j] += pages[i];` ` ` `// Recursively call for the next book` ` ` `rec(i + ` `1` `, N, pages, M);` ` ` `// If the ith book is not included for jth` ` ` `// student` ` ` `students[j] -= pages[i];` ` ` `}` ` ` `}` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `[] pages = { ` `8` `, ` `15` `, ` `10` `, ` `20` `, ` `8` `};` ` ` `int` `M = ` `2` `;` ` ` `// Function call` ` ` `rec(` `0` `, pages.length, pages, M);` ` ` `System.out.print(ans);` ` ` `}` `}` `// This code is contributed by lokesh (lokeshmvs21).` |

## Python3

`# python3 code to implement the above approach` `import` `sys` `ans ` `=` `2147483647` `students ` `=` `[]` ` ` `# Function to minimize the maximum number of pages` `def` `rec(i, N, pages, M) :` ` ` ` ` `global` `ans` ` ` ` ` `if` `(i ` `=` `=` `N) :` ` ` ` ` `# If all books are included then find` ` ` `# the maximum no of pages for any` ` ` `# student store minimum among` ` ` `# the maximum` ` ` `ans ` `=` `min` `(ans, ` `max` `(students))` ` ` `return` ` ` ` ` ` ` `# ith book can go in any of the students` ` ` `for` `j ` `in` `range` `(` `0` `, M) :` ` ` ` ` `# Include the book for jth student` ` ` `students[j] ` `+` `=` `pages[i]` ` ` ` ` `# Recursively call for the next book` ` ` `rec(i ` `+` `1` `, N, pages, M)` ` ` ` ` `# If the ith book is not included for jth student` ` ` `students[j] ` `-` `=` `pages[i]` ` ` `# Driver's code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `pages ` `=` `[ ` `8` `, ` `15` `, ` `10` `, ` `20` `, ` `8` `]` ` ` `M ` `=` `2` ` ` `students ` `=` `[` `0` `] ` `*` `M` ` ` ` ` `# Function call` ` ` `rec(` `0` `, ` `len` `(pages), pages, M)` ` ` `print` `(ans)` ` ` ` ` `# This code is contributed by code_hunt.` |

## C#

`// C# program to of the above approach` `using` `System;` `using` `System.Linq;` `class` `GFG {` ` ` `static` `int` `ans = Int32.MaxValue;` ` ` `static` `int` `[] students = ` `new` `int` `[2];` ` ` `// Function to minimize the maximum number of pages` ` ` `static` `void` `rec(` `int` `i, ` `int` `N, ` `int` `[] pages, ` `int` `M)` ` ` `{` ` ` `if` `(i == N) {` ` ` `// If all books are included then find the` ` ` `// maximum no of pages for any student store` ` ` `// minimum among the maximum` ` ` `ans = Math.Min(` ` ` `ans, students.Max());` ` ` `return` `;` ` ` `}` ` ` `// ith book can go in any of the students` ` ` `for` `(` `int` `j = 0; j < M; j++) {` ` ` `// Include the book for jth student` ` ` `students[j] += pages[i];` ` ` `// Recursively call for the next book` ` ` `rec(i + 1, N, pages, M);` ` ` `// If the ith book is not included for jth` ` ` `// student` ` ` `students[j] -= pages[i];` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[] pages = { 8, 15, 10, 20, 8 };` ` ` `int` `M = 2;` ` ` `// Function call` ` ` `rec(0, pages.Length, pages, M);` ` ` `Console.Write(ans);` ` ` `}` `}` `// This code is contributed by sanjoy_62.` |

## Javascript

`<script>` ` ` `// JavaScript program for the above approach` ` ` `let ans = 2147483647;` ` ` `let students = [];` ` ` `// Function to minimize the maximum number of pages` ` ` `const rec = (i, N, pages, M) => {` ` ` `if` `(i == N) {` ` ` `// If all books are included then find` ` ` `// the maximum no of pages for any` ` ` `// student store minimum among` ` ` `// the maximum` ` ` `ans = Math.min(ans, Math.max(...students));` ` ` `return` `;` ` ` `}` ` ` `// ith book can go in any of the students` ` ` `for` `(let j = 0; j < M; ++j) {` ` ` `// Include the book for jth student` ` ` `students[j] += pages[i];` ` ` `// Recursively call for the next book` ` ` `rec(i + 1, N, pages, M);` ` ` `// If the ith book is not included for jth student` ` ` `students[j] -= pages[i];` ` ` `}` ` ` `}` ` ` `// Driver's code` ` ` `let pages = [8, 15, 10, 20, 8];` ` ` `let M = 2;` ` ` `students = ` `new` `Array(M).fill(0);` ` ` `// Function call` ` ` `rec(0, pages.length, pages, M);` ` ` `document.write(ans);` ` ` `// This code is contributed by rakeshsahni` `</script>` |

**Output**

Minimum no of pages: 31

**Time Complexity: **O(M * M^{N})**Auxiliary Space: **O(1)