Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 07 Sep, 2021
Improve Article
Save Article

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 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 <bits/stdc++.h>
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[0];
    // 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




<script>
// JavaScript program for the
// above approach
  
// Function to check if the array
// can be partitioned into atmost d
// subarray with sum atmost T
function possible(T, arr,
                               n, d)
{
       
    // Initial partition
    let partition = 1;
   
    // Current sum
    let total = 0;
   
    for(let 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
function calcT(n, d, arr)
{
       
    // Stores the maximum and
    // total sum of elements
    let mx = -1, sum = 0;
   
    for(let i = 0; i < n; i++)
    {
           
        // Maximum element
        mx = Math.max(mx, arr[i]);
   
        // Sum of all elements
        sum = sum + arr[i];
    }
   
    let lb = mx;
    let ub = sum;
   
    while (lb < ub)
    {
           
        // Calculate median T
        let 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
    document.write(lb);
}
 
// Driver Code
 
    let d = 2;
    let arr = [ 1, 1, 1, 1, 1 ];
   
    let n = arr.length;
       
    // Function call
    calcT(n, d, arr);
 
</script>

Output

3

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!