Array Partition Problem in Java

The array partition problem involves dividing an array into two subsets such that the difference between their sums is minimized. This problem is a classic example of partitioning problems and has applications in load balancing, fair distribution, and optimization tasks.

Using Recursion and Memoization
Using Dynamic Programming

Each method has its own advantages and trade-offs in terms of time and space complexity.

Method 1: Using Recursion and Memoization

This method involves a recursive approach where we explore all possible partitions. To optimize the solution and avoid redundant calculations, we use memoization to store intermediate results.

Recursive Function: Create a recursive function that explores including or excluding each element in the subset.

Memoization: Use a HashMap or array to store intermediate results to avoid redundant calculations.

File Name: ArrayPartitionRecursionMemoization.java

 
import java.util.HashMap;
import java.util.Map;
public class ArrayPartitionRecursionMemoization {
    public static int minDifference(int[] nums) {
        int totalSum = 0;
        for (int num : nums) {
            totalSum += num;
        }
        Map<String, Integer> memo = new HashMap<>();
        return minDifferenceHelper(nums, 0, 0, totalSum, memo);
    }
    private static int minDifferenceHelper(int[] nums, int index, int currentSum, int totalSum, Map<String, Integer> memo) {
        if (index == nums.length) {
            return Math.abs((totalSum - currentSum) - currentSum);
        }
        String key = index + "-" + currentSum;
        if (memo.containsKey(key)) {
            return memo.get(key);
        }
        int include = minDifferenceHelper(nums, index + 1, currentSum + nums[index], totalSum, memo);
        int exclude = minDifferenceHelper(nums, index + 1, currentSum, totalSum, memo);
        int result = Math.min(include, exclude);
        memo.put(key, result);
        return result;
    }
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 9};
        System.out.println("The minimum difference is " + minDifference(nums));
    }
}   

Output:

 
The minimum difference is 3

Time Complexity:

O(n² ) without memoization, O(n⋅S) with memoization, where S is the sum of the array.

Space Complexity:

O(n⋅S) due to the memoization table.

Method 2: Using Dynamic Programming

Dynamic programming can be used to solve this problem efficiently by avoiding the recomputation of subproblems. The idea is to use a boolean DP table where dp[i][j] indicates whether a subset with sum j can be formed using the first i elements.

DP Table Initialization: Initialize a DP table with dimensions (n+1) x (sum/2 + 1), where n is the number of elements and sum is the total sum of the array.

Fill DP Table: Update the table based on whether the current element is included in the subset or not.

Find Minimum Difference: The result can be derived from the last row of the DP table.

File Name: ArrayPartitionDP.java

 
public class ArrayPartitionDP {
    public static int minDifference(int[] nums) {
        int totalSum = 0;
        for (int num : nums) {
            totalSum += num;
        }        
        int n = nums.length;
        boolean[][] dp = new boolean[n + 1][totalSum / 2 + 1];
        
        for (int i = 0; i <= n; i++) {
            dp[i][0] = true;
        }        
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= totalSum / 2; j++) {
                if (nums[i - 1] <= j) {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }        
        int sum1 = 0;
        for (int j = totalSum / 2; j >= 0; j--) {
            if (dp[n][j]) {
                sum1 = j;
                break;
            }
        }        
        int sum2 = totalSum - sum1;
        return Math.abs(sum2 - sum1);
    }
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 9};
        System.out.println("The minimum difference is " + minDifference(nums));
    }
}   

Output:

 
The minimum difference is 3

Time Complexity:

O(n⋅S), where S is the sum of the array.

Space Complexity:

O(n⋅S) due to the DP table.

Conclusion

Both the Recursion and Memoization method and the Dynamic Programming approach provide effective solutions for the Array Partition problem, each with its own strengths:

Recursion and Memoization: This method explores all possible partitions by recursively including or excluding elements from subsets. By utilizing memoization, it avoids redundant calculations, significantly improving efficiency over pure recursion.

This approach is particularly useful for smaller arrays or when a deep understanding of the problem's structure is required. However, the space complexity can become significant for large arrays due to the memoization table.

Dynamic Programming: The dynamic programming approach handles the problem efficiently by building a solution iteratively using a DP table. It avoids recomputation of subproblems, ensuring an optimal solution.

This method is well-suited for larger arrays, providing a clear and systematic approach to partitioning tasks. The space requirement, however, can still be a limitation for extremely large arrays.

Both methods are valuable for solving the Array Partition problem, with the choice of method depending on the specific constraints and requirements of the task. Recursion and Memoization offer an intuitive and detailed exploration of the problem, while Dynamic Programming provides a robust and scalable solution for larger inputs.

Understanding these techniques equips developers with the tools to handle partitioning tasks efficiently and effectively.

Next TopicAtomic-vs-volatile-in-java

← prev next →