Split Array Largest Sum in Java

An array numArr[] is given, which only contains the non-negative integers, and an integer sp is also provided. The task is to partition the array into sp continuous subarrays such that the largest sum among these sp subarrays is minimum. Note that subarrays can never be empty. The constraint for this problem is that the size of the input array numArr[] can not be greater than 1000, and the minimum value of sp is 1.

For example, for an array numArr[] = {a1, a2, a3, a4, a5, a6} and sp = 2. Then, we can do the split or partition in the 5 ways. Observe the following diagram.

In each partition, we have created two subarrays. Suppose in the first partition, the sum of g2 (elements present in g2) is the maximum among g1 and g2. Also, suppose the sum of g4 is the maximum in the second partition, the sum of g6 is the maximum in the third partition, the sum of g8 is the maximum in the fourth partition, and the sum of g10 is the maximum in the fifth partition. Now we will find the minimum of (sum of g2, sum of g4, sum of g6, sum of g8, sum of g10). Suppose the sum of g4 is minimum, then we have to split our array as the second partition (as shown in the diagram), and the sum of g4 will be our answer.

Example 1:

Input: numArr[] = [2, 7, 10, 5, 8, 9, 4], sp = 2

Output: 24

Explanation: Let's see how we can partition the given input array.

Partition 1: g1 = {2}, g2 = {7, 10, 5, 8, 9, 4}

Sum of g1 = 2, and sum of g2 = 43

Maximum of (sum of g1, sum of g2) = 43

Partition 2: g1 = {2, 7}, g2 = {10, 5, 8, 9, 4}

Sum of g3 = 9, and sum of g4 = 36

Maximum of (sum of g3, sum of g4) = 36

Partition 3: g1 = {2, 7, 10}, g2 = {5, 8, 9, 4}

Sum of g5 = 19, and sum of g6 = 26

Maximum of (sum of g5, sum of g6) = 26

Partition 4: g1 = {2, 7, 10, 5}, g2 = {8, 9, 4}

Sum of g7 = 24, and sum of g8 = 21

Maximum of (sum of g7, sum of g8) = 24

Partition 5: g1 = {2, 7, 10, 5, 8}, g2 = {9, 4}

Sum of g9 = 32, and sum of g10 = 13

Maximum of (sum of g9, sum of g10) = 32

Partition 6: g1 = {2, 7, 10, 5, 8, 9}, g2 = {4}

Sum of g11 = 41, and sum of g12 = 4

Maximum of (sum of g11, sum of g12) = 41

Now, the minimum of (43, 36, 26, 24, 32, 41) = 24. The number 24 comes from partition 4. Hence, we need to use partition 4 to get the minimum among the largest sum of the subarrays.

Example 2:

Input: numArr[] = [8, 3, 9, 2], sp = 4

Output: 9

Explanation: Let's see how we can partition the given input array

Partition: g1 = {8}, g2 = {3}, g3 = {9}, g4 = {2}. No other parition is possible

In this partition, maximum of (sum of g1, sum of g2 of sum g3, sum of g4) is 9. Hence, our answer is 9.

Example 3:

Input: numArr[] = [8, 3, 9, 2, 9, 6, 9, 0], sp = 10

Output: Invalid input

Explanation: The total number of elements present in the numArr[] is 8, and the value of sp is 10. The maximum number of subarrays that can be created using 8 elements is 8 (each subarray containing 1 element). Therefore, if we try to create 10 subarrays (value of sp is 10), then atleast 2 subarrays have to remain empty. It is already mentioned above, those subarrays derived from the input array can never be empty. Hence, the input is invalid.

Approach: Using Dynamic Programming

Step 1: The approach is to use a prefixSum array that computes the sum of elements. It is required because whenever we hit the base case (where the subarray required is only one, then it is required to compute the sum of all of the remaining elements, in that case, we want the answer in O(1) time). Thus, the first step is to fill the prefixSum[] array.

Step 2: Begin with the index currentIndex as 0 and the number of subarrays subArrCount as sp. It shows the subarray within the range [0, size - 1] and sp subarrays.

Step 3: Select those elements that will be part of the current subarray by traversing over the indices beginning from the currentIndex to size - subArrCount. At every index:

Use the prefixSum for computing the sum of the elements in the current subarray (fstSplitSum).
Recursively invoke the getMinLargestSplitSum() method for computing the minimum largest subarray, which could be gained from the elements that are remaining.
The maximum of these two values forms the largest sub array sum provided the first sub array is [currentIndex, i].
Repeat this process for all j up to size - subArrCount, then keep the minimum possible maxSplitSum in the minLargestSplitSum.

Return minLargestSplitSum in order to avoid the repeat computations, also keep it in a memoization table memoArr[] corresponding to the currentIndex and subArrCount.

Implementation

Observe the following implementation that is done on the basis of the algorithm explained above.

FileName: SplitArrLargestNum.java

public class SplitArrLargestNum
{
    // Defined as per the maximum array and the split count

    Integer memoArr[][];
    
    private int getMinLargestSplitSum(int prefixSum[], int currentIndex, int subArrCount) 
    {
        int size = prefixSum.length - 1;
        
        // The answer for the index currentIndex and the count of the subarray subArrCount is 
        // already computed. Hence, simply return the computed answer.
        if (memoArr[currentIndex][subArrCount] != null) 
        {
            return memoArr[currentIndex][subArrCount];
        }
        
        // Handling the Base Case
        // subarrayCount = 1 means there is single subarray and the rest of the elements must go 
        // in that subarray
        if (subArrCount == 1) 
        {
            return memoArr[currentIndex][subArrCount] = prefixSum[size] - prefixSum[currentIndex];
        }
        // Otherwise, use the recursive relation for finding the minimum largest sub array
        // sum from the currentIndex till the end of the array with subArrCount sub arrays that are left.
        int minLargestSplitSum = Integer.MAX_VALUE;
        for (int j = currentIndex; j <= size - subArrCount; j++) 
        {
            // keeping the sum of the first sub array.
            int fstSplitSum = prefixSum[j + 1] - prefixSum[currentIndex];            
            // computing the max sub array sum for the current 1st split.
            int maxSplitSum = Math.max(fstSplitSum, getMinLargestSplitSum(prefixSum, j + 1, subArrCount - 1));
            
            // computing the minimum sum from all of the combinations that are possible
            minLargestSplitSum = Math.min(minLargestSplitSum, maxSplitSum);
             
            // if the split sum is larger than the already computed answer then discard it 
            if (fstSplitSum >= minLargestSplitSum) 
            {
                break;
            }
        }
        return memoArr[currentIndex][subArrCount] = minLargestSplitSum;
    }
    
    public int partitionArray(int[] numArr, int sp) 
    {
        // Storing the prefix sum of array numArr
        int size = numArr.length;
        
        if(size < sp)
        {
            return -1;
        }        
        int prefixSum[] = new int[size + 1];
        for (int j = 0; j < size; j++) 
        {
            prefixSum[j + 1] = prefixSum[j] + numArr[j];
        }
        return getMinLargestSplitSum(prefixSum, 0, sp);
    }
    // main method
    public static void main(String argvs[])
    {
        // creating an object of the class SplitArrLargestNum
        SplitArrLargestNum obj = new SplitArrLargestNum();
        // input 1
        int numArr[] = {2, 7, 10, 5, 8, 9, 4};
        int size = numArr.length;
        int sp = 2;
        obj.memoArr = new Integer[size + 1][sp + 1];
        int ans = obj.partitionArray(numArr, sp);
        System.out.println("For the given array: ");
        for(int i = 0; i < size; i++)
        {
            System.out.print(numArr[i] +  " ");
        }
        System.out.println("");        
        if(ans == -1)
        {
            System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
        }
        else
        {
            System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
        }
        System.out.println("\n");        
        // input 2
        int numArr1[] = {8, 3, 9, 2};
        size = numArr1.length;
        sp = 4;
        obj.memoArr = new Integer[size + 1][sp + 1];
        ans = obj.partitionArray(numArr1, sp);
        
        System.out.println("For the given array: ");
        
        for(int i = 0; i < size; i++)
        {
            System.out.print(numArr1[i] +  " ");
        }
        
        System.out.println("");
        
        if(ans == -1)
        {
            System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
        }
        else
        {
            System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
        }
        
        System.out.println("\n");
        // input 3
        int numArr2[] = {8, 3, 9, 2, 9, 6, 9, 0};
        size = numArr2.length;
        sp = 10;
        
        obj.memoArr = new Integer[size + 1][sp + 1];
        ans = obj.partitionArray(numArr2, sp);
        
        System.out.println("For the given array: ");
        
        for(int i = 0; i < size; i++)
        {
            System.out.print(numArr2[i] +  " ");
        }
        
        System.out.println("");
        
        if(ans == -1)
        {
            System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
        }
        else
        {
            System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
        }
        
        
    }
}

Output:

For the given array: 
2 7 10 5 8 9 4 
The minimum largest sum for the 2 subarrays is: 24.


For the given array: 
8 3 9 2 
The minimum largest sum for the 4 subarrays is: 9.


For the given array: 
8 3 9 2 9 6 9 0 
Partition for creating 10 subarrays is not possible.

Complexity Analysis: In the above program, we have covered almost N * M states with the help of recursion. Also, we have used a for loop that runs from the currentIndex, which further adds O(N) time complexity. Thus, the total time complexity of the program is O(N2 * M), where N represents the total number of elements present in the input array and M is the total number of splits or the subarrays that are allowed which is sp in our case. The array memoArr[] is consuming the space of size N * M. Hence, the space complexity of the above program is O(N * M).

In the above program, we have used recursion to solve the problem. However, we can also do the same using loops only. Observe the following program.

FileName: SplitArrLargestNum1.java

public class SplitArrLargestNum1
{
// Defined as per the maximum array and the split count
// memoArr[p][q] means the minimum largest sum for the 
// array that starts from the index p and the splits that 
// are required from the index p is q
int memoArr[][];

public int partitionArray(int[] numArr, int sp) 
{
int size = numArr.length;

// if split is greater than the size of the input
// array then the given input is invalid
if(size < sp)
{
return -1;
}
// Storing the prefix sum of the numArr[] array
int[] prefixSum = new int[size + 1];
for (int j = 0; j < size; j++) 
{
prefixSum[j + 1] = prefixSum[j] + numArr[j];
}

for (int subArrCount = 1; subArrCount <= sp; subArrCount++) 
{
for (int currentIndex = 0; currentIndex < size; currentIndex++) 
{
// Handling the Base Case
// subarrayCount = 1 means there is single subarray and the rest of the elements must go 
// in that subarray
if (subArrCount == 1) 
{
memoArr[currentIndex][subArrCount] = prefixSum[size] - prefixSum[currentIndex];

continue;
}

// Otherwise, use the recursive relation for finding the minimum largest sub array
// sum from the currentIndex till the end of the array with subArrCount sub arrays that are left.
int minLargestSplitSum = Integer.MAX_VALUE;
for (int j = currentIndex; j <= size - subArrCount; j++) 
{
// Store the sum of the first subarray.
int fstSplitSum = prefixSum[j + 1] - prefixSum[currentIndex];

// Computing the maximum sub array sum for the current first split.
int largestSplitSum = Math.max(fstSplitSum, memoArr[j + 1][subArrCount - 1]);

// Computing the minimum from all of the combinations that are possible.
minLargestSplitSum = Math.min(minLargestSplitSum, largestSplitSum);

if (fstSplitSum >= minLargestSplitSum) 
{
break;
}
}

memoArr[currentIndex][subArrCount] = minLargestSplitSum;
}
}

return memoArr[0][sp];
}

// main method
public static void main(String argvs[])
{
// creating an object of the class SplitArrLargestNum1
SplitArrLargestNum1 obj = new SplitArrLargestNum1();


// input 1
int numArr[] = {2, 7, 10, 5, 8, 9, 4};
int size = numArr.length;
int sp = 2;
obj.memoArr = new int[size + 1][sp + 1];
int ans = obj.partitionArray(numArr, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}

System.out.println("\n");


// input 2
int numArr1[] = {8, 3, 9, 2};
size = numArr1.length;
sp = 4;

obj.memoArr = new int[size + 1][sp + 1];
ans = obj.partitionArray(numArr1, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr1[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}

System.out.println("\n");

// input 3
int numArr2[] = {8, 3, 9, 2, 9, 6, 9, 0};
size = numArr2.length;
sp = 10;

obj.memoArr = new int[size + 1][sp + 1];
ans = obj.partitionArray(numArr2, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr2[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}


}
}

Output:

For the given array: 
2 7 10 5 8 9 4 
The minimum largest sum for the 2 subarrays is: 24.


For the given array: 
8 3 9 2 
The minimum largest sum for the 4 subarrays is: 9.


For the given array: 
8 3 9 2 9 6 9 0 
Partition for creating 10 subarrays is not possible.

Complexity Analysis: The complexity of the above program is the same as the previous program.

The complexity of the program can be reduced further with the help of binary search.

Approach: Using Binary Search

Step 1: Compute the sum of the elements present in the input array numArr[]. Store it in a variable called sumArr (one can also use the name of one's choice)

Step 2: Find out the element in the array numArr[], which is of maximum value. Store it in a variable, which is maxEle in our case.

Step 3: Fix the search space of the binary search using maxEle and sumVar, where maxEle will serve as the left boundary and sumArr will search as the right boundary.

Step 4: Start the binary search using a loop, where the terminating condition will be: when the left boundary is less than the right boundary.

Step 5: Find the middle value and treat it as the largest sum allowed for the subarrays. Keep it in a variable, which is the maximumSumAllowed.

Step 6: Compute the least number of subarrays whose sum is equal to maximumSumAllowed.

Step 7: Check whether the number of subarrays (found in step 6) is greater than, less than, or equal to sp or not. If the count of subarrays is less than or equal to sp, then reduce the value of the right boundary, and assign the value maximumSumAllowed to the answer. If the count of subarrays is more than sp, then increase the value of the left boundary.

Step 8: Return the answer.

Implementation

Let's see the implementation of the above algorithm.

FileName: SplitArrLargestNum2.java

public class SplitArrLargestNum2
{
    private int minSubArrReq(int[] numArr, int maximumSumAllowed) 
    {
        int size = numArr.length;
int currentSum = 0;
int splitsReq = 0;

for(int i = 0; i < size; i++)
{
if (currentSum + numArr[i] <= maximumSumAllowed) 
{
currentSum = currentSum + numArr[i];
} 
            
else 
{
// If the addition of the element makes the sum greater than the maximumSumAllowed
// then increase the number of splits required and reset the sum
currentSum = numArr[i];
splitsReq = splitsReq + 1;
}
}

return splitsReq + 1;
}
    
    public int partitionArray(int[] numArr, int sp) 
    {
        int size = numArr.length;
        
        // if split is greater than the size of the input
// array then the given input is invalid
if(size < sp)
{
return -1;
}
        // Computing the sum of all the elements and 
        // also finding the maximum element
        int sumArr = 0;
        int maxEle = Integer.MIN_VALUE;
        for (int j = 0; j < size; j++) 
        {
            sumArr = sumArr + numArr[j];
            maxEle = Math.max(maxEle, numArr[j]);
        }        
        // Defining the left and the right boundary of the binary search
        int lft = maxEle;
        int rgt = sumArr;
        int answer = 0;
        while (lft <= rgt) 
        {
            // computing the middle value
            int maximumSumAllowed = lft + (rgt - lft) / 2;
            
            // Computing the minimum number of splits. If the splits that are required are 
            // equal to or less than
            // sp move towards the left i.e., lesser values
            if (minSubArrReq(numArr, maximumSumAllowed) <= sp) 
            {
                rgt = maximumSumAllowed - 1;
                answer = maximumSumAllowed;
            } else 
            {
                // Moving towards the right if the required splits are more than sp
                lft = maximumSumAllowed + 1;
            }
        }        
        return answer;
    }
// main method
public static void main(String argvs[])
{
// creating an object of the class SplitArrLargestNum2
SplitArrLargestNum2 obj = new SplitArrLargestNum2();
// input 1
int numArr[] = {2, 7, 10, 5, 8, 9, 4};
int size = numArr.length;
int sp = 2;
//obj.memoArr = new int[size + 1][sp + 1];
int ans = obj.partitionArray(numArr, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}

System.out.println("\n");
// input 2
int numArr1[] = {8, 3, 9, 2};
size = numArr1.length;
sp = 4;
//obj.memoArr = new int[size + 1][sp + 1];
ans = obj.partitionArray(numArr1, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr1[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}

System.out.println("\n");

// input 3
int numArr2[] = {8, 3, 9, 2, 9, 6, 9, 0};
size = numArr2.length;
sp = 10;

//obj.memoArr = new int[size + 1][sp + 1];
ans = obj.partitionArray(numArr2, sp);

System.out.println("For the given array: ");

for(int i = 0; i < size; i++)
{
    System.out.print(numArr2[i] +  " ");
}

System.out.println("");

if(ans == -1)
{
    System.out.println("Parition for creating " + sp + " subarrays is not possible.");    
}
else
{
    System.out.println("The minimum largest sum for the " + sp + " subarrays is: " + ans + ".");
}


}
}

Output:

For the given array: 
2 7 10 5 8 9 4 
The minimum largest sum for the 2 subarrays is: 24.

For the given array: 
8 3 9 2 
The minimum largest sum for the 4 subarrays is: 9.

For the given array: 
8 3 9 2 9 6 9 0 
Partition for creating 10 subarrays is not possible.

Complexity Analysis: The method minSubArrReq() uses a loop that iterates over each element of the input array. Thus, making the time complexity of O(n). The binary search used in the program uses O(log(s)) time. Thus, the overall time complexity of the program is O(n * log(s)), where n is the total number of elements present in the array, and s is the total sum of elements present in the array. The program is not consuming any extra space (no data structure is used in the program). Hence, the space complexity of the program is constant, i.e., O(1).

Next TopicFind Original Array from a Double Array in Java

← prev next →