Count of Subsets that can be partitioned into two non empty sets with equal Sum

using System;
using System.Collections.Generic;
using System.Linq;

namespace GFG
{
    class Program
    {
        // Boolean array to check if elements
        // represented by a bitmask(subset)
        // can be split into two non-empty groups
        // having equal sum.
        public static Boolean[] canSplit = new Boolean[1 << 20];

        // Map to store sum of subsets
        // and find if there is a subset
        // with the current sum.
        public static SortedDictionary<int, int> mp = new SortedDictionary<int, int>();

        // Vector of vector to store
        // all the bitmasks having the
        // same sum together.
        public static List<List<int>> subsets = new List<List<int>>();

        // Variable to count subsets
        // having unique sums.
        public static int ID;

        // Function to generate all possible
        // subsets from first half
        // of the array.
        public static void makeSubsets1(int i, int N, int sum, int mask, int[] Arr)
        {

            // If first half of the array
            // is traversed.
            if (i == N)
            {

                // If none of the previously formed
                // subsets have the same sum
                // as the current subset.
                if (!mp.ContainsKey(sum))
                {

                    // Increase ID by 1 as the
                    // subsets having a unique
                    // sum value has increased by 1.
                    ++ID;

                    // Assign the value of sum to ID.
                    mp.Add(sum, ID);
                }

                // Retrieve the subset number
                // having this sum.
                int id = mp[sum];

                // Add the bitmask to the vector
                // of this particular subset id.
                subsets[id].Add(mask);
                return;
            }

            // Exclude the current element
            // from the subset
            makeSubsets1(i + 1, N, sum, mask, Arr);

            // Include the current element
            // to the first group of the subset.
            makeSubsets1(i + 1, N, sum + Arr[i], mask | (1 << i), Arr);

            // Include the current element
            // to the second group of the subset.
            makeSubsets1(i + 1, N, sum - Arr[i], mask | (1 << i), Arr);
        }

        // Function to generate all possible
        // subsets from second half of array.
        public static void makeSubsets2(int i, int N, int sum, int mask, int[] Arr)
        {

            // If the second half
            // of the array is traversed.
            if (i == N)
            {

                // If the current subset sum has
                // occurred before in the
                // first part of the array, then the
                // combined subset from both halves
                // of the array forms a valid subset
                if (mp.ContainsKey(sum))
                {

                    // Iterate through all the bitmasks
                    // from the first part of the array
                    // having the same current sum.
                    foreach (var num in subsets[mp[sum]])
                    {

                        // Mark the bitwise OR
                        // of both subsets as TRUE.
                        canSplit[num | mask] = true;
                    }
                }
                return;
            }

            // Exclude the current element
            // from the subset.
            makeSubsets2(i + 1, N, sum, mask, Arr);

            // Include the current element
            // to the second group of the subset.
            makeSubsets2(i + 1, N, sum + Arr[i], mask | (1 << i), Arr);

            // Include the current element
            // to the first group of the subset.
            makeSubsets2(i + 1, N, sum - Arr[i], mask | (1 << i), Arr);
        }

        // Utility function to find all subsets from both halves of
        // the array.
        public static int UtilCountOfSubsets(int N, int[] Arr)
        {
            // Split the array into two parts.
            int mid = N / 2;

            // Function calls
            makeSubsets1(0, mid, 0, 0, Arr);
            makeSubsets2(mid, N, 0, 0, Arr);

            int ans = 0;

            // Iterate through all bitmasks
            // from 1 to 2^N - 1.
            for (int i = 1; i < (1 << N); ++i)
            {

                // If canSplit[i] is true,
                // increase the answer by 1.
                if (canSplit[i])
                {
                    ans++;
                }
            }

            // Return the answer.
            return ans;
        }

        // Driver code
        public static void Main(string[] args)
        {
            int[] Arr = { 2, 3, 4, 5 };
            int N = Arr.Length;
            for (int i = 0; i < (1 << 20); i++)
            {
                subsets.Add(new List<int>());
                canSplit[i] = false;
            }

            Console.WriteLine(UtilCountOfSubsets(N, Arr));
        }
    }
}