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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program for the above approach
#include <bits/stdc++.h>
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[0];
    // Function call
    calcT(n, d, arr);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


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

Recommended Posts:


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.