Matchsticks to Square

import java.util.HashMap;

class MatchstickSquare {

    // Hash map for storing results of recursive checks
    public HashMap<Pair<Integer, Integer>, Boolean> dpCache;

    // List of all matchsticks
    public int[] matchstickLengths;

    // The length of one side of the square given total length of sticks
    public int targetSideLength;

    // Constructor to initialize the memoization
    public MatchstickSquare() {
        this.dpCache = new HashMap<>();
    }

    // Method to perform dynamic programming recursion
    public boolean dp(Integer currentMask, Integer completedSides) {
        int accumulatedLength = 0;
        int N = this.matchstickLengths.length;

        // Computing hash map key from current state
        Pair<Integer, Integer> dpKey = new Pair(currentMask, completedSides);

        // Calculate total length of used matchsticks
        for(int index = 0; index < N; index++) {
            if ((currentMask & (1 << index)) == 0) {
                accumulatedLength += this.matchstickLengths[N - 1 - index];
            }
        }

        // Check if a full side of the square has formed
        if (accumulatedLength > 0 && accumulatedLength % this.targetSideLength == 0) {
            completedSides++;
        }

        // Successful condition: three complete sides
        if (completedSides == 3) {
            return true;
        }

        // Fetch cached results
        if (this.dpCache.containsKey(dpKey)) {
            return this.dpCache.get(dpKey);
        }

        boolean result = false;
        int currentSideMultiplier = accumulatedLength / this.targetSideLength;

        // Remaining length that can be added to current forming side
        int remainingSideLength = this.targetSideLength * (currentSideMultiplier + 1) - accumulatedLength;

        // Iterate to find next possible matchstick to use
        for(int index = 0; index < N; index++) {
            if (this.matchstickLengths[N - 1 - index] <= remainingSideLength && (currentMask & (1 << index)) > 0) {
                if (dp(currentMask ^ (1 << index), completedSides)) {
                    result = true;
                    break;
                }
            }
        }

        // Store result in cache
        this.dpCache.put(dpKey, result);
        return result;
    }

    // Wrapper function to initiate the matching process
    public boolean canFormSquare(int[] matchsticks) {

        // Handle the scenario of empty input
        if (matchsticks == null || matchsticks.length == 0) {
            return false;
        }

        // Calculate total length and possible side length
        int N = matchsticks.length;
        int totalLength = 0;
        for(int i = 0; i < N; i++) {
            totalLength += matchsticks[i];
        }

        int side = totalLength / 4;
        if (side * 4 != totalLength) {
            return false;
        }

        this.matchstickLengths = matchsticks;
        this.targetSideLength = side;
        return this.dp((1 << N) - 1, 0);
    }
}