# Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible

Given an array arr[] consisting of N integers and an integer D, the task is to find the least integer T such that the entire array can be partitioned into at most D subarrays from the given array with sum atmost T.

Examples:

Input: D = 5, arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Output: 15
Explanation:
If T = 15, then 5 subarrays {{1, 2, 3, 4, 5}, {6, 7}, {8}, {9}, {10}}

Input: D = 2, arr[] = {1, 1, 1, 1, 1}
Output:
Explanation:
If T = 3, then the 2 partitions are {{1, 1, 1}, {1, 1}}

Naive Approach: The idea is to check for all possible values of T in the range [max(element), sum(element)] whether it is possible to have at most D partition.

Time Complexity: O( N*R )
Auxiliary Space: O(1)

Efficient Approach: The idea is to use Binary search to optimize the above approach. Follow the steps below to solve the problem:

• Consider T in the range R = [ max(element), sum(element) ].
• If median T can generates at most D partitions, then check for a median lesser than T.
• Otherwise, check for a median greater than current median T.
• Return the possible value of T at the end.

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Funtion to check if the array ` `// can be partitioned into atmost d ` `// subarray with sum atmost T ` `bool` `possible(``int` `T, ``int` `arr[], ``int` `n, ``int` `d) ` `{ ` `    ``// Initial partition ` `    ``int` `partition = 1; ` ` `  `    ``// Current sum ` `    ``int` `total = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``total = total + arr[i]; ` ` `  `        ``// If current sum exceeds T ` `        ``if` `(total > T) { ` ` `  `            ``// Create a new partition ` `            ``partition = partition + 1; ` `            ``total = arr[i]; ` ` `  `            ``// If count of partitions ` `            ``// exceed d ` `            ``if` `(partition > d) { ` `                ``return` `false``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `true``; ` `} ` ` `  `// Function to find the minimum ` `// possible value of T ` `void` `calcT(``int` `n, ``int` `d, ``int` `arr[]) ` `{ ` `    ``// Stores the maximum and ` `    ``// total sum of elements ` `    ``int` `mx = -1, sum = 0; ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Maximum element ` `        ``mx = max(mx, arr[i]); ` ` `  `        ``// Sum of all elements ` `        ``sum = sum + arr[i]; ` `    ``} ` ` `  `    ``int` `lb = mx; ` `    ``int` `ub = sum; ` ` `  `    ``while` `(lb < ub) { ` ` `  `        ``// Calculate median  T ` `        ``int` `T_mid = lb + (ub - lb) / 2; ` ` `  `        ``// If atmost D partitions possible ` `        ``if` `(possible(T_mid, arr, n, d) == ``true``) { ` ` `  `            ``// Check for smaller T ` `            ``ub = T_mid; ` `        ``} ` ` `  `        ``// Otherwise ` `        ``else` `{ ` ` `  `            ``// Check for larger T ` `            ``lb = T_mid + 1; ` `        ``} ` `    ``} ` ` `  `    ``// Print the minimum T required ` `    ``cout << lb << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `d = 2; ` `    ``int` `arr[] = { 1, 1, 1, 1, 1 }; ` ` `  `    ``int` `n = ``sizeof` `arr / ``sizeof` `arr; ` `    ``// Function call ` `    ``calcT(n, d, arr); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` `import` `java.io.*; ` ` `  `class` `GFG{ ` `     `  `// Function to check if the array ` `// can be partitioned into atmost d ` `// subarray with sum atmost T ` `public` `static` `boolean` `possible(``int` `T, ``int` `arr[], ` `                               ``int` `n, ``int` `d) ` `{ ` `     `  `    ``// Initial partition ` `    ``int` `partition = ``1``; ` ` `  `    ``// Current sum ` `    ``int` `total = ``0``; ` ` `  `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``total = total + arr[i]; ` ` `  `        ``// If current sum exceeds T ` `        ``if` `(total > T) ` `        ``{ ` `             `  `            ``// Create a new partition ` `            ``partition = partition + ``1``; ` `            ``total = arr[i]; ` ` `  `            ``// If count of partitions ` `            ``// exceed d ` `            ``if` `(partition > d) ` `            ``{ ` `                ``return` `false``; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// Function to find the minimum ` `// possible value of T ` `public` `static` `void` `calcT(``int` `n, ``int` `d, ` `                         ``int` `arr[]) ` `{ ` `     `  `    ``// Stores the maximum and ` `    ``// total sum of elements ` `    ``int` `mx = -``1``, sum = ``0``; ` ` `  `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `         `  `        ``// Maximum element ` `        ``mx = Math.max(mx, arr[i]); ` ` `  `        ``// Sum of all elements ` `        ``sum = sum + arr[i]; ` `    ``} ` ` `  `    ``int` `lb = mx; ` `    ``int` `ub = sum; ` ` `  `    ``while` `(lb < ub) ` `    ``{ ` `         `  `        ``// Calculate median T ` `        ``int` `T_mid = lb + (ub - lb) / ``2``; ` ` `  `        ``// If atmost D partitions possible ` `        ``if` `(possible(T_mid, arr, n, d) == ``true``) ` `        ``{ ` `             `  `            ``// Check for smaller T ` `            ``ub = T_mid; ` `        ``} ` ` `  `        ``// Otherwise ` `        ``else` `        ``{ ` `             `  `            ``// Check for larger T ` `            ``lb = T_mid + ``1``; ` `        ``} ` `    ``} ` `     `  `    ``// Print the minimum T required ` `    ``System.out.println(lb); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `d = ``2``; ` `    ``int` `arr[] = { ``1``, ``1``, ``1``, ``1``, ``1` `}; ` ` `  `    ``int` `n = arr.length; ` `     `  `    ``// Function call ` `    ``calcT(n, d, arr); ` `} ` `} ` ` `  `// This code is contributed by decoding `

## Python3

 `# Python3 program for the above approach ` ` `  `# Function to check if the array ` `# can be partitioned into atmost d ` `# subarray with sum atmost T ` `def` `possible(T, arr, n, d): ` `     `  `    ``# Initial partition ` `    ``partition ``=` `1``; ` ` `  `    ``# Current sum ` `    ``total ``=` `0``; ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``total ``=` `total ``+` `arr[i]; ` ` `  `        ``# If current sum exceeds T ` `        ``if` `(total > T): ` ` `  `            ``# Create a new partition ` `            ``partition ``=` `partition ``+` `1``; ` `            ``total ``=` `arr[i]; ` ` `  `            ``# If count of partitions ` `            ``# exceed d ` `            ``if` `(partition > d): ` `                ``return` `False``; ` ` `  `    ``return` `True``; ` ` `  `# Function to find the minimum ` `# possible value of T ` `def` `calcT(n, d, arr): ` `     `  `    ``# Stores the maximum and ` `    ``# total sum of elements ` `    ``mx ``=` `-``1``; ``sum` `=` `0``; ` ` `  `    ``for` `i ``in` `range``(n): ` `         `  `        ``# Maximum element ` `        ``mx ``=` `max``(mx, arr[i]); ` ` `  `        ``# Sum of all elements ` `        ``sum` `=` `sum` `+` `arr[i]; ` ` `  `    ``lb ``=` `mx; ` `    ``ub ``=` `sum``; ` ` `  `    ``while` `(lb < ub): ` ` `  `        ``# Calculate median T ` `        ``T_mid ``=` `lb ``+` `(ub ``-` `lb) ``/``/` `2``; ` ` `  `        ``# If atmost D partitions possible ` `        ``if` `(possible(T_mid, arr, n, d) ``=``=` `True``): ` ` `  `            ``# Check for smaller T ` `            ``ub ``=` `T_mid; ` ` `  `        ``# Otherwise ` `        ``else``: ` ` `  `            ``# Check for larger T ` `            ``lb ``=` `T_mid ``+` `1``; ` ` `  `    ``# Print the minimum T required ` `    ``print``(lb); ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``d ``=` `2``; ` `    ``arr ``=` `[ ``1``, ``1``, ``1``, ``1``, ``1` `]; ` ` `  `    ``n ``=` `len``(arr); ` ` `  `    ``# Function call ` `    ``calcT(n, d, arr); ` ` `  `# This code is contributed by Rajput-Ji`

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `// Function to check if the array ` `// can be partitioned into atmost d ` `// subarray with sum atmost T ` `public` `static` `bool` `possible(``int` `T, ``int` `[]arr, ` `                            ``int` `n, ``int` `d) ` `{ ` `     `  `    ``// Initial partition ` `    ``int` `partition = 1; ` ` `  `    ``// Current sum ` `    ``int` `total = 0; ` ` `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``total = total + arr[i]; ` ` `  `        ``// If current sum exceeds T ` `        ``if` `(total > T) ` `        ``{ ` `             `  `            ``// Create a new partition ` `            ``partition = partition + 1; ` `            ``total = arr[i]; ` ` `  `            ``// If count of partitions ` `            ``// exceed d ` `            ``if` `(partition > d) ` `            ``{ ` `                ``return` `false``; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// Function to find the minimum ` `// possible value of T ` `public` `static` `void` `calcT(``int` `n, ``int` `d, ` `                         ``int` `[]arr) ` `{ ` `     `  `    ``// Stores the maximum and ` `    ``// total sum of elements ` `    ``int` `mx = -1, sum = 0; ` ` `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// Maximum element ` `        ``mx = Math.Max(mx, arr[i]); ` ` `  `        ``// Sum of all elements ` `        ``sum = sum + arr[i]; ` `    ``} ` ` `  `    ``int` `lb = mx; ` `    ``int` `ub = sum; ` ` `  `    ``while` `(lb < ub) ` `    ``{ ` `         `  `        ``// Calculate median T ` `        ``int` `T_mid = lb + (ub - lb) / 2; ` ` `  `        ``// If atmost D partitions possible ` `        ``if` `(possible(T_mid, arr, n, d) == ``true``) ` `        ``{ ` `             `  `            ``// Check for smaller T ` `            ``ub = T_mid; ` `        ``} ` ` `  `        ``// Otherwise ` `        ``else` `        ``{ ` `             `  `            ``// Check for larger T ` `            ``lb = T_mid + 1; ` `        ``} ` `    ``} ` `     `  `    ``// Print the minimum T required ` `    ``Console.WriteLine(lb); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``int` `d = 2; ` `    ``int` `[]arr = { 1, 1, 1, 1, 1 }; ` ` `  `    ``int` `n = arr.Length; ` `     `  `    ``// Function call ` `    ``calcT(n, d, arr); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar  `

Output

```3
```

Time complexity: O( N*log(sum) )
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.