Split array into two equal length subsets such that all repetitions of a number lies in a single subset

// Java program for the above approach
import java.io.*;
import java.util.*;

class GFG {

    // Function to create the frequency
    // array of the given array arr[]
    private static int[] findSubsets(int[] arr)
    {

        // Hashmap to store the frequencies
        HashMap<Integer, Integer> M
            = new HashMap<>();

        // Store freq for each element
        for (int i = 0; i < arr.length; i++) {
            M.put(arr[i],
                  M.getOrDefault(arr[i], 0) + 1);
        }

        // Get the total frequencies
        int[] subsets = new int[M.size()];
        int i = 0;

        // Store frequencies in subset[] array
        for (
            Map.Entry<Integer, Integer> playerEntry :
            M.entrySet()) {
            subsets[i++]
                = playerEntry.getValue();
        }

        // Return frequency array
        return subsets;
    }

    // Function to check is sum N/2 can be
    // formed using some subset
    private static boolean
    subsetSum(int[] subsets,
              int target)
    {

        // dp[i][j] store the answer to
        // form sum j using 1st i elements
        boolean[][] dp
            = new boolean[subsets.length
                          + 1][target + 1];

        // Initialize dp[][] with true
        for (int i = 0; i < dp.length; i++)
            dp[i][0] = true;

        // Fill the subset table in the
        // bottom up manner
        for (int i = 1;
             i <= subsets.length; i++) {

            for (int j = 1;
                 j <= target; j++) {
                dp[i][j] = dp[i - 1][j];

                // If current element is
                // less than j
                if (j >= subsets[i - 1]) {

                    // Update current state
                    dp[i][j]
                        |= dp[i - 1][j
                                     - subsets[i - 1]];
                }
            }
        }

        // Return the result
        return dp[subsets.length][target];
    }

    // Function to check if the given
    // array can be split into required sets
    public static void
    divideInto2Subset(int[] arr)
    {
        // Store frequencies of arr[]
        int[] subsets = findSubsets(arr);

        // If size of arr[] is odd then
        // print "Yes"
        if ((arr.length) % 2 == 1) {
            System.out.println("No");
            return;
        }

        // Check if answer is true or not
        boolean isPossible
            = subsetSum(subsets,
                        arr.length / 2);

        // Print the result
        if (isPossible) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        int[] arr = { 2, 1, 2, 3 };

        // Function Call
        divideInto2Subset(arr);
    }
}

// This code is contributed by divyesh072019

import java.util.*;

public class Main { // Function to create the frequency
    // array of the given array arr[]
    static List<Integer> findSubsets(List<Integer> arr,
                                     int N)
    {
        // Hashmap to store the
        // frequencies
        Map<Integer, Integer> M = new HashMap<>();

        // Store freq for each element
        for (int i = 0; i < N; i++) {
            int element = arr.get(i);
            if (M.containsKey(element)) {
                M.put(element, M.get(element) + 1);
            }
            else {
                M.put(element, 1);
            }
        }

        // Get the total frequencies
        List<Integer> subsets = new ArrayList<>();

        // Store frequencies in
        // subset[] array
        for (Map.Entry<Integer, Integer> entry :
             M.entrySet()) {
            subsets.add(entry.getValue());
        }

        // Return frequency array
        return subsets;
    }

    // Function to check is sum
    // N/2 can be formed using
    // some subset
    static boolean subsetSum(List<Integer> subsets, int N,
                             int target)
    {
        // dp[] store the answer to
        // form sum j using 1st i elements
        boolean[] dp = new boolean[target + 1];

        // Initialize dp[] with true
        Arrays.fill(dp, false);
        dp[0] = true;

        // Fill the subset table in the
        // bottom up manner
        for (int i = 1; i <= N; i++) {
            for (int j = target; j >= 1; j--) {
                // If current element is
                // less than j
                if (j >= subsets.get(i - 1)) {
                    // Update current state
                    dp[j] |= dp[j - subsets.get(i - 1)];
                }
            }
        }

        // Return the result
        return dp[target];
    }

    // Function to check if the given
    // array can be split into required sets
    static void divideInto2Subset(List<Integer> arr, int N)
    {
        // Store frequencies of arr[]
        List<Integer> subsets = findSubsets(arr, N);

        // If size of arr[] is odd then
        // print "No"
        if ((N) % 2 == 1) {
            System.out.println("No");
            return;
        }

        int subsets_size = subsets.size();

        // Check if answer is true or not
        boolean isPossible
            = subsetSum(subsets, subsets_size, N / 2);

        // Print the result
        if (isPossible) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }
    }

    public static void main(String[] args)
    {
        // Given array arr[]
        List<Integer> arr
            = new ArrayList<>(Arrays.asList(2, 1, 2, 3));

        int N = arr.size();

        // Function Call
        divideInto2Subset(arr, N);
    }
}