The painter’s partition problem | Set 2

11 Nov, 2021
We have to paint n boards of length {A1, A2, .. An}. There are k painters available and each takes 1 unit time to paint 1 unit of board. The problem is to find the minimum time to get this job done under the constraints that any painter will only paint continuous sections of boards, say board {2, 3, 4} or only board {1} or nothing but not board {2, 4, 5}.
Examples : 
Input : k = 2, A = {10, 10, 10, 10} 
Output : 20.
Here we can divide the boards into 2
equal sized partitions, so each painter 
gets 20 units of board and the total
time taken is 20. 

Input : k = 2, A = {10, 20, 30, 40} 
Output : 60.
Here we can divide first 3 boards for
one painter and the last board for 
second painter.
In the previous post we discussed a dynamic programming based approach having time complexity of and extra space. In this post we will look into a more efficient approach using binary search. We know that the invariant of binary search has two main parts: * the target value would always be in the searching range. * the searching range will decrease in each loop so that the termination can be reached. 
We also know that the values in this range must be in sorted order. Here our target value is the maximum sum of a contiguous section in the optimal allocation of boards. Now how can we apply binary search for this? We can fix the possible low to high range for the target value and narrow down our search to get the optimal allocation.
We can see that the highest possible value in this range is the sum of all the elements in the array and this happens when we allot 1 painter all the sections of the board. The lowest possible value of this range is the maximum value of the array max, as in this allocation we can allot max to one painter and divide the other sections such that the cost of them is less than or equal to max and as close as possible to max. Now if we consider we use x painters in the above scenarios, it is obvious that as the value in the range increases, the value of x decreases and vice-versa. From this we can find the target value when x=k and use a helper function to find x, the minimum number of painters required when the maximum length of section a painter can paint is given.
C++
Java
Python3
C#
PHP
Javascript
// CPP program for painter's partition problem#include <iostream>#include <climits>using namespace std; // return the maximum element from the arrayint getMax(int arr[], int n){    int max = INT_MIN;    for (int i = 0; i < n; i++)        if (arr[i] > max)            max = arr[i];    return max;} // return the sum of the elements in the arrayint getSum(int arr[], int n){    int total = 0;    for (int i = 0; i < n; i++)        total += arr[i];    return total;} // find minimum required painters for given maxlen// which is the maximum length a painter can paintint numberOfPainters(int arr[], int n, int maxLen){    int total = 0, numPainters = 1;     for (int i = 0; i < n; i++) {        total += arr[i];         if (total > maxLen) {             // for next count            total = arr[i];            numPainters++;        }    }     return numPainters;} int partition(int arr[], int n, int k){    int lo = getMax(arr, n);    int hi = getSum(arr, n);     while (lo < hi) {        int mid = lo + (hi - lo) / 2;        int requiredPainters = numberOfPainters(arr, n, mid);         // find better optimum in lower half        // here mid is included because we        // may not get anything better        if (requiredPainters <= k)            hi = mid;         // find better optimum in upper half        // here mid is excluded because it gives        // required Painters > k, which is invalid        else            lo = mid + 1;    }     // required    return lo;} // driver functionint main(){    int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 3;    cout << partition(arr, n, k) << endl;    return 0;}
// Java Program for painter's partition problemimport java.util.*;import java.io.*; class GFG {    // return the maximum element from the array    static int getMax(int arr[], int n)    {        int max = Integer.MIN_VALUE;        for (int i = 0; i < n; i++)            if (arr[i] > max)                max = arr[i];        return max;    }     // return the sum of the elements in the array    static int getSum(int arr[], int n)    {        int total = 0;        for (int i = 0; i < n; i++)            total += arr[i];        return total;    }     // find minimum required painters for given maxlen    // which is the maximum length a painter can paint    static int numberOfPainters(int arr[], int n, int maxLen)    {        int total = 0, numPainters = 1;         for (int i = 0; i < n; i++) {            total += arr[i];             if (total > maxLen) {                 // for next count                total = arr[i];                numPainters++;            }        }         return numPainters;    }     static int partition(int arr[], int n, int k)    {        int lo = getMax(arr, n);        int hi = getSum(arr, n);         while (lo < hi) {            int mid = lo + (hi - lo) / 2;            int requiredPainters = numberOfPainters(arr, n, mid);             // find better optimum in lower half            // here mid is included because we            // may not get anything better            if (requiredPainters <= k)                hi = mid;             // find better optimum in upper half            // here mid is excluded because it gives            // required Painters > k, which is invalid            else                lo = mid + 1;        }         // required        return lo;    }     // Driver code    public static void main(String args[])    {        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };         // Calculate size of array.        int n = arr.length;        int k = 3;        System.out.println(partition(arr, n, k));    }} // This code is contributed by Sahil_Bansall
# Python program for painter's partition problem # Find minimum required painters for given maxlen# which is the maximum length a painter can paintdef numberOfPainters(arr, n, maxLen):    total = 0    numPainters = 1     for i in arr:        total += i         if (total > maxLen):             # for next count            total = i            numPainters += 1     return numPainters def partition(arr, n, k):    lo = max(arr)    hi = sum(arr)     while (lo < hi):        mid = lo + (hi - lo) // 2        requiredPainters = numberOfPainters(arr, n, mid)         # find better optimum in lower half        # here mid is included because we        # may not get anything better        if (requiredPainters <= k):            hi = mid         # find better optimum in upper half        # here mid is excluded because it gives        # required Painters > k, which is invalid        else:            lo = mid + 1     # required    return lo # Driver codearr = [1, 2, 3, 4, 5, 6, 7, 8, 9]n = len(arr)k = 3print(int(partition(arr, n, k)))
// C# Program for painter's// partition problemusing System; class GFG {     // return the maximum    // element from the array    static int getMax(int[] arr, int n)    {        int max = int.MinValue;        for (int i = 0; i < n; i++)            if (arr[i] > max)                max = arr[i];        return max;    }     // return the sum of the    // elements in the array    static int getSum(int[] arr, int n)    {        int total = 0;        for (int i = 0; i < n; i++)            total += arr[i];        return total;    }     // find minimum required    // painters for given    // maxlen which is the    // maximum length a painter    // can paint    static int numberOfPainters(int[] arr,                                int n, int maxLen)    {        int total = 0, numPainters = 1;         for (int i = 0; i < n; i++) {            total += arr[i];             if (total > maxLen) {                 // for next count                total = arr[i];                numPainters++;            }        }         return numPainters;    }     static int partition(int[] arr,                         int n, int k)    {        int lo = getMax(arr, n);        int hi = getSum(arr, n);         while (lo < hi) {            int mid = lo + (hi - lo) / 2;            int requiredPainters = numberOfPainters(arr, n, mid);             // find better optimum in lower            // half here mid is included            // because we may not get            // anything better            if (requiredPainters <= k)                hi = mid;             // find better optimum in upper            // half here mid is excluded            // because it gives required            // Painters > k, which is invalid            else                lo = mid + 1;        }         // required        return lo;    }     // Driver code    static public void Main()    {        int[] arr = { 1, 2, 3, 4, 5,                      6, 7, 8, 9 };         // Calculate size of array.        int n = arr.Length;        int k = 3;        Console.WriteLine(partition(arr, n, k));    }} // This code is contributed by ajit
<?php// PHP program for painter's// partition problem // return the maximum// element from the arrayfunction getMax($arr, $n){    $max = PHP_INT_MIN;    for ($i = 0; $i < $n; $i++)        if ($arr[$i] > $max)            $max = $arr[$i];    return $max;} // return the sum of the// elements in the arrayfunction getSum($arr, $n){    $total = 0;    for ($i = 0; $i < $n; $i++)        $total += $arr[$i];    return $total;} // find minimum required painters// for given maxlen which is the// maximum length a painter can paintfunction numberOfPainters($arr, $n,                          $maxLen){    $total = 0; $numPainters = 1;     for ($i = 0; $i < $n; $i++)    {        $total += $arr[$i];         if ($total > $maxLen)        {             // for next count            $total = $arr[$i];            $numPainters++;        }    }     return $numPainters;} function partition($arr, $n, $k){    $lo = getMax($arr, $n);    $hi = getSum($arr, $n);     while ($lo < $hi)    {        $mid = $lo + ($hi - $lo) / 2;        $requiredPainters =                    numberOfPainters($arr,                                     $n, $mid);         // find better optimum in        // lower half here mid is        // included because we may        // not get anything better        if ($requiredPainters <= $k)            $hi = $mid;         // find better optimum in        // upper half here mid is        // excluded because it        // gives required Painters > k,        // which is invalid        else            $lo = $mid + 1;    }     // required    return floor($lo);} // Driver Code$arr = array(1, 2, 3,             4, 5, 6,             7, 8, 9);$n = sizeof($arr);$k = 3; echo partition($arr, $n, $k), "\n"; // This code is contributed by ajit?>
<script> // Javascript Program for painter's partition problem    // Return the maximum element from the arrayfunction getMax(arr, n){    let max = Number.MIN_VALUE;    for(let i = 0; i < n; i++)        if (arr[i] > max)            max = arr[i];                 return max;} // Return the sum of the elements in the arrayfunction getSum(arr, n){    let total = 0;    for(let i = 0; i < n; i++)        total += arr[i];             return total;} // Find minimum required paleters for given maxlen// which is the maximum length a paleter can paletfunction numberOfPaleters(arr, n, maxLen){    let total = 0, numPaleters = 1;     for(let i = 0; i < n; i++)    {        total += arr[i];         if (total > maxLen)        {             // For next count            total = arr[i];            numPaleters++;        }    }    return numPaleters;} function partition(arr, n, k){    let lo = getMax(arr, n);    let hi = getSum(arr, n);     while (lo < hi)    {        let mid = lo + (hi - lo) / 2;        let requiredPaleters = numberOfPaleters(            arr, n, mid);         // Find better optimum in lower half        // here mid is included because we        // may not get anything better        if (requiredPaleters <= k)            hi = mid;         // find better optimum in upper half        // here mid is excluded because it gives        // required Paleters > k, which is invalid        else            lo = mid + 1;    }     // Required    return lo;} // Driver codelet arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; // Calculate size of array.let n = arr.length;let k = 3; document.write(Math.round(partition(arr, n, k))); // This code is contributed by sanjoy_62 </script>
Output : 
17
For better understanding, please trace the example given in the program in pen and paper. The time complexity of the above approach is .References: https://articles.leetcode.com/the-painters-partition-problem-part-ii/ https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/Asked in: Google, Codenation. 
jit_t
adwaith1990
sanjoy_62
cyclades
ks9192174414
Binary Search
Codenation
Google
Competitive Programming
Divide and Conquer
Dynamic Programming
Searching
Google
Codenation
Searching
Dynamic Programming
Divide and Conquer
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Competitive Programming - A Complete Guide
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Modulo 10^9+7 (1000000007)
Prefix Sum Array - Implementation and Applications in Competitive Programming
Merge Sort
QuickSort
Binary Search
Count Inversions in an array | Set 1 (Using Merge Sort)
Median of two sorted arrays of different sizes