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

• Difficulty Level : Easy
• Last Updated : 07 Sep, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 generate at most D partitions, then check for a median lesser than T.
• Otherwise, check for a median greater than the 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;` `// Function 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`

## Javascript

 ``
Output
`3`

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

My Personal Notes arrow_drop_up