Minimum Difference Subarrays in Java

An input array inputArr[] is given to us that contains n numbers. Our task is to find the minimum difference between the two sub-arrays. The sub-arrays are made from the given input array. If an element is a part of one sub-array, then it can not be a part of the other subarray. Also, none of the subarrays should be empty. The following examples show the same.

Example 1:

Input

int arr[] = {7, 6, 8, 1, 5}

Output: 1

Explanation: If we create two subarrays as: subArr1 = {6, 8} and subArr2 = {7, 1, 5}, then we get the sum of elements of subarrays as: 6 + 8 = 14, and 7 + 1 + 5 = 13, and their difference is 14 - 13 = 1. Hence, the output is 1.

Example 2:

Input

int arr[] = {2, 4, 8, 9, 5, 7, 3, 6, 1}

Output: 1

Explanation: If we create two subarrays as: subArr1 = {8, 9, 5} and subArr2 = {2, 4, 7, 3, 6, 1}, then we get the sum of elements of subarrays as: 8 + 9 + 5 = 22, and 2 + 4 + 7 + 3 + 6 + 1 = 23, and their difference is 23 - 22 = 1. Hence, the output is 1.

Example 3:

Input

int arr[] = {3, 3, 3, 3, 3}

Output: 3

Explanation: If we create two subarrays as: subArr1 = {3, 3, 3} and subArr2 = {3, 3}, then we get the sum of elements of subarrays as: 3 + 3 + 3 = 9, and 3 + 3 = 6, and their difference is 9 - 6 = 3. Hence, the output is 3.

Approach: Brute Force

We will find all the possible values of the first subarray, and for each possible value, we will find the value for the second subarray. Then, we will compute the absolute difference between the value of the first subarray and the second subarray, and the absolute minimum difference is our answer. The following program illustrates the same.

FileName: MinDiffSubArrays.java

public class MinDiffSubArrays 
{

int minDiff = Integer.MAX_VALUE;

// a method that computes the minimum difference 
// between two subarrays taken from the input array
// inputArr whose size is n
public void findMinDiff(int inputArr[], int firstSubArrSum, int i, int n, int total) 
{
// handling the base case
if(i >= n)
{
return;
}
if(firstSubArrSum != 0)
{
int secondSubArrSum = total - firstSubArrSum;
minDiff = Math.min(minDiff, Math.abs(secondSubArrSum - firstSubArrSum));    
}

// including the element inputArr[i] in the firstSubArrSum
findMinDiff(inputArr, firstSubArrSum + inputArr[i], i + 1, n, total);

// excluding the element inputArr[i] in the firstSubArrSum
findMinDiff(inputArr, firstSubArrSum, i + 1, n, total);
}

// a method that finds the sum of element
// of the array arr[]
public int findSumEle(int arr[], int size)
{
int sum = 0;
for(int i = 0; i < size; i++)
{
sum = sum + arr[i];
}

return sum;
}

// main method
public static void main(String argvs[]) 
{

// Creating an object of the class MinDiffSubArrays 
MinDiffSubArrays obj = new MinDiffSubArrays();

// input 1
int arr[] = {7, 6, 8, 1, 5};   
int size = arr.length;
obj.findMinDiff(arr, 0, 0, size, obj.findSumEle(arr, size));
int ans = obj.minDiff;

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr[k] + " ");
}

System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );


// input 2
int arr1[] = {2, 4, 8, 9, 5, 7, 3, 6, 1};  
size = arr1.length;
obj.minDiff = Integer.MAX_VALUE;
obj.findMinDiff(arr1, 0, 0, size, obj.findSumEle(arr1, size));
ans = obj.minDiff;
System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr1[k] + " ");
}

System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );

// input 3
int arr2[] = {3, 3, 3, 3, 3};  
size = arr2.length;
obj.minDiff = Integer.MAX_VALUE;
obj.findMinDiff(arr2, 0, 0, size, obj.findSumEle(arr2, size));
ans = obj.minDiff;
System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr2[k] + " ");
}

System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );

}
}

Output:

For the input array: 
7 6 8 1 5 
The minimum difference between the two subarrays is: 1

For the input array: 
2 4 8 9 5 7 3 6 1 
The minimum difference between the two subarrays is: 1

For the input array: 
3 3 3 3 3 
The minimum difference between the two subarrays is: 3

Complexity Analysis: Every recursive call creates two exponential calls. Hence, the time complexity of the program is exponential.

The time complexity of the program is too high and is not suitable for the larger inputs. Therefore, we must do some optimization, and the same is mentioned in the following approach.

Approach: Using PrefixSum

With the help of an auxiliary array (prefixArr[]), we will store the prefix sum of the input array (inputArr[]), where prefixArr[j], represents the sum of elements from 0 to j.

Algorithm:

Step 1: Declare the array prefixArr for storing the prefix sum of the input array.

Step 2: Copy all the elements of the input array in the prefixArr.

Step 3: For every index j from 1 to s - 1 (s is the size of the input array), do the following:

assign prefixArr[j] as prefixArr[j] + prefixArr[j - 1].

Step 4: Declare a variable for storing the minimum difference, which is minDifference in our case.

Step 5: Declare a variable for storing the sum of elements of the first subarray, which is firstSubArrSum in our case.

Step 6: Declare a variable for storing the sum of elements of the second subarray, which is secondSubArrSum in our case.

Step 7: Assign the maximum integer value to the variable minDifference.

Step 8: For index j in the range 0 to s - 2, do the following:

Assign firstSubArrSum as prefixArr[j].(Sum of the first subarray)
Assign the secondSubArrSum as prefixArr[size of inputARr - 1] - prefixArr[j]. (Sum of the second subarray)
Assign minDifference as the minimum of the absolute difference between firstSubArrSum and secondSubArrSum and minDifference.

Step 9: Return the value of minDifference.

Implementation

Observe the implementation of the above-mentioned algorithm.

FileName: MinDiffSubArrays.java

public class MinDiffSubArrays 
{

// a method that computes the minimum difference 
// between two subarrays taken from the input array
// inputArr whose size is n
public int findMinDiff(int inputArr[], int n) 
{

// Allocating the memory for the prefix array prefixArr
int prefixArr[] = new int[n];

for(int k = 0; k < n; k++)
{
prefixArr[k] = inputArr[k];
}

// As mentioned in the algorithm,
// prefixArr[j] is the sum of elements
// from 0 to j of the input array.
for (int j = 1; j < n; j++) 
{
prefixArr[j] = prefixArr[j - 1] + prefixArr[j];
}

// Assigning the maximum value of the Integer to the
// variable minDifference.
// The variable minDifference contains the answer
int minDifference  = Integer.MAX_VALUE;

for (int k = 0; k <= n - 2; k++) 
{

// firstSubArrSum keeps the first subarray sum.
int firstSubArrSum  = prefixArr[k];

// secondSubArrSum keeps the second subarray sum.
int secondSubArrSum = prefixArr[n - 1] - prefixArr[k];

// Updating the minDifference
minDifference = Math.min(minDifference, Math.abs(firstSubArrSum - secondSubArrSum));
}
return minDifference;
}
// main method
public static void main(String argvs[]) 
{
// Creating an object of the class MinDiffSubArrays 
MinDiffSubArrays obj = new MinDiffSubArrays();
// input 1
int arr[] = {7, 6, 8, 1, 5};   
int size = arr.length;
int ans = obj.findMinDiff(arr, size);

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr[k] + " ");
}
System.out.println( );
System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
// input 2
int arr1[] = {2, 4, 8, 9, 5, 7, 3, 6, 1};  
size = arr1.length;
ans = obj.findMinDiff(arr1, size);

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr1[k] + " ");
}
System.out.println( );
System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
// input 3
int arr2[] = {3, 3, 3, 3, 3};  
size = arr2.length;
ans = obj.findMinDiff(arr2, size);
System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr2[k] + " ");
}
System.out.println( );
System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
}
}

Output:

For the input array: 
7 6 8 1 5 
The minimum difference between the two subarrays is: 1

For the input array: 
2 4 8 9 5 7 3 6 1 
The minimum difference between the two subarrays is: 1

For the input array: 
3 3 3 3 3 
The minimum difference between the two subarrays is: 3

Complexity Analysis: There are three for-loops that are used in the method findMinDiff(). However, none of them is nested. Thus, making the time-complexity O(n). Also, an auxiliary array is getting used in the program (prefixArr[]), thus making the space complexity O(n), where n is the total number of elements present in the input array.

We will be doing optimization on the space complexity. Observe the approach mentioned below.

Approach: Using Constant Space

In this approach, we will be using variables instead of the auxiliary array. We will be using a variable totalEleSum for storing the sum of all of the elements of the input array. Another variable, firstSubArrSum, is also used for storing the sum of the elements of the first subarray. The sum of elements of the second subarray can be computed easily by totalEleSum - firstSubArrSum. Now, the comparison is made for computing the absolute minimum difference for each of the indexes. Observe the following program.

FileName: MinDiffSubArrays.java

public class MinDiffSubArrays 
{

// a method that computes the minimum difference 
// between two subarrays taken from the input array
// inputArr whose size is n
public int findMinDiff(int inputArr[], int n) 
{
int totalEleSum = 0;

for(int k = 0; k < n; k++)
{
totalEleSum  = totalEleSum  + inputArr[k];
}

// Assigning the maximum value of the Integer to the
// variable minDifference.
// The variable minDifference contains the answer
int minDifference  = Integer.MAX_VALUE;

// currSum stores the sum of the first subarray.
int currSum = 0;

for(int k = 0; k < n - 1; k++) 
{

// updating the sum of the current subarray.
currSum = currSum + inputArr[k];

// the minimum difference has to be minimum
minDifference = Math.min(minDifference, Math.abs(currSum - (totalEleSum - currSum)));
}
return minDifference;
}
// main method
public static void main(String argvs[]) 
{

// Creating an object of the class MinDiffSubArrays 
MinDiffSubArrays obj = new MinDiffSubArrays();

// input 1
int arr[] = {7, 6, 8, 1, 5};   
int size = arr.length;
int ans = obj.findMinDiff(arr, size);

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr[k] + " ");
}
System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
// input 2
int arr1[] = {2, 4, 8, 9, 5, 7, 3, 6, 1};  
size = arr1.length;
ans = obj.findMinDiff(arr1, size);

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr1[k] + " ");
}
System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
// input 3
int arr2[] = {3, 3, 3, 3, 3};  
size = arr2.length;
ans = obj.findMinDiff(arr2, size);

System.out.println("For the input array: ");
for(int k = 0; k < size; k++)
{
System.out.print(arr2[k] + " ");
}
System.out.println( );

System.out.println("The minimum difference between the two subarrays is: " + ans + "\n" );
}
}

Output:

For the input array: 
7 6 8 1 5 
The minimum difference between the two subarrays is: 1

For the input array: 
2 4 8 9 5 7 3 6 1 
The minimum difference between the two subarrays is: 1

For the input array: 
3 3 3 3 3 
The minimum difference between the two subarrays is: 3

Complexity Analysis: The time complexity of the program is the same as the previous program. The space complexity of the program is constant, i.e., O(1), as the program is not using the auxiliary array.

Next TopicPlus One to Array Problem in Java

← prev next →