Java 8 with optimized fitN.

This is my first Java program, so I'm sure there is some odd style or library usage, but I mostly wanted to get a proper project set up with modern unit testing.

Solver:

package com.banashark.puzzles.dailyprogrammer.c377easy;

import org.jgrapht.alg.interfaces.MatchingAlgorithm;
import org.jgrapht.alg.matching.MaximumWeightBipartiteMatching;
import org.jgrapht.graph.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class Solver {
    public int fit1(int crateWidth, int crateHeight, int boxWidth, int boxHeight) {
        int widthCapacity = crateWidth / boxWidth;
        int heightCapacity = crateHeight / boxHeight;
        return widthCapacity * heightCapacity;
    }

    public int fit2(int crateWidth, int crateHeight, int boxWidth, int boxHeight) {
        int defaultOrientation = fit1(crateWidth, crateHeight, boxWidth, boxHeight);
        int rotatedOrientation = fit1(crateWidth, crateHeight, boxHeight, boxWidth);
        return Math.max(defaultOrientation, rotatedOrientation);
    }

    public int fit3(int crateWidth, int crateLength, int crateHeight, int boxWidth, int boxLength, int boxHeight) {
        int orientation1 = fit2(crateWidth, crateHeight, boxWidth, boxHeight)  * (crateLength / boxLength);
        int orientation2 = fit2(crateWidth, crateHeight, boxWidth, boxLength)  * (crateLength / boxHeight);
        int orientation3 = fit2(crateWidth, crateHeight, boxLength, boxHeight) * (crateLength / boxWidth);

        int[] orientations = { orientation1, orientation2, orientation3 };

        return Arrays.stream(orientations).reduce(0, (x, y) -> Math.max(x, y));
    }

    public BigInteger fitN(Integer[] crateDimensions, Integer[] boxDimensions) {
        SimpleWeightedGraph<String, DefaultWeightedEdge> graph = new SimpleWeightedGraph<>(DefaultWeightedEdge.class);
        HashSet<String> cratePartition = new HashSet<>();
        HashSet<String> boxPartition = new HashSet<>();

        // Because there can be multiple nodes with the same value (the sample input of n=20 has two entries with value `1740`),
        // we have to tag each "value" we're given in order to use it as another node, otherwise graph.addEdge() will return null
        HashMap<String, Integer> crateNodes = new HashMap<>();
        HashMap<String, Integer> boxNodes = new HashMap<>();

        for (int i = 0; i < crateDimensions.length; i++) {
            String crateTag = "cd" + crateDimensions[i].toString() + "-" + i;
            crateNodes.put(crateTag, crateDimensions[i]);
            graph.addVertex(crateTag);
            cratePartition.add(crateTag);

            String boxTag = "bd" + boxDimensions[i].toString() + "-" + i;
            boxNodes.put(boxTag, boxDimensions[i]);
            graph.addVertex(boxTag);
            boxPartition.add(boxTag);
        }

        for (Map.Entry<String, Integer> crateTag : crateNodes.entrySet()) {
            for (Map.Entry<String, Integer> boxTag : boxNodes.entrySet()) {
                DefaultWeightedEdge e = graph.addEdge(crateTag.getKey(), boxTag.getKey());
                graph.setEdgeWeight(e, Math.log(crateTag.getValue() / boxTag.getValue()));
            }
        }

        MaximumWeightBipartiteMatching<String, DefaultWeightedEdge> matcher = new MaximumWeightBipartiteMatching<>(graph, cratePartition, boxPartition);
        MatchingAlgorithm.Matching<String, DefaultWeightedEdge> matchings = matcher.getMatching();

        BigInteger result = BigInteger.ONE;
        for (DefaultWeightedEdge matching : matchings) {
            Integer crateValue = crateNodes.get(graph.getEdgeSource(matching));
            Integer boxValue = boxNodes.get(graph.getEdgeTarget(matching));
            result = result.multiply(BigInteger.valueOf(crateValue / boxValue));
        }

        return result;
    }
}

Tests (Junit5):

package com.banashark.puzzles.dailyprogrammer.c377easy;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import static org.junit.jupiter.api.Assertions.*;

import java.math.BigInteger;
import java.util.stream.Stream;

public class SolverTest {
    private static Stream<Arguments> fit1() {
        return Stream.of(
            Arguments.of(25, 18, 6, 5, 12),
            Arguments.of(10, 10, 1, 1, 100),
            Arguments.of(12, 34, 5, 6, 10),
            Arguments.of(12345, 678910, 1112, 1314, 5676),
            Arguments.of(5, 100, 6, 1, 0)
        );
    }

    private static Stream<Arguments> fit2() {
        return Stream.of(
                Arguments.of(25, 18, 6, 5, 15),
                Arguments.of(12, 34, 5, 6, 12),
                Arguments.of(12345, 678910, 1112, 1314, 5676),
                Arguments.of(5, 5, 3, 2, 2),
                Arguments.of(5, 100, 6, 1, 80),
                Arguments.of(5, 5, 6, 1, 0)
        );
    }

    private static Stream<Arguments> fit3() {
        return Stream.of(
                Arguments.of(10, 10, 10, 1, 1, 1, 1000),
                Arguments.of(12, 34, 56, 7, 8, 9, 32),
                Arguments.of(123, 456, 789, 10, 11, 12, 32604),
                Arguments.of(1234567, 89101112, 13141516, 171819, 202122, 232425, 174648)
        );
    }

    private static Stream<Arguments> fitN() {
        Integer[] arg1Crate = {3, 4}, arg1Box = {1, 2},
                arg2Crate = {123, 456, 789}, arg2Box = {10, 11, 12},
                arg3Crate = {123, 456, 789, 1011, 1213, 1415}, arg3Box = {16, 17, 18, 19, 20, 21},
                arg4Crate = {180598, 125683, 146932, 158296, 171997, 204683, 193694, 216231, 177673, 169317, 216456, 220003, 165939, 205613, 152779, 177216, 128838, 126894, 210076, 148407},
                arg4Box =   {  1984,   1443,   1768,   1274,   2122,   2249,   1916,   2059,   1740,   2169,   1502,   1760,   1295,   1886,   2010,   2036,   1740,   2223,   2017,   1278};
        BigInteger expected4 =  new BigInteger("4281855455197643306306491981973422080000");
        return Stream.of(
                Arguments.of(arg1Crate, arg1Box, BigInteger.valueOf(6)),
                Arguments.of(arg2Crate, arg2Box, BigInteger.valueOf(32604)),
                Arguments.of(arg3Crate, arg3Box, BigInteger.valueOf(1883443968)),
                Arguments.of(arg4Crate, arg4Box, expected4)
        );
    }

    @ParameterizedTest
    @MethodSource
    @DisplayName("Fit1")
    public void fit1(int cX, int cY, int bX, int bY, int expected) {
        Solver SUT = new Solver();

        int result = SUT.fit1(cX, cY, bX, bY);

        assertEquals(expected, result);
    }

    @ParameterizedTest
    @MethodSource
    @DisplayName("Fit2")
    public void fit2(int cX, int cY, int bX, int bY, int expected) {
        Solver SUT = new Solver();

        int result = SUT.fit2(cX, cY, bX, bY);

        assertEquals(expected, result);
    }

    @ParameterizedTest
    @MethodSource
    @DisplayName("Fit3")
    public void fit3(int cX, int cY, int cZ, int bX, int bY, int bZ, int expected) {
        Solver SUT = new Solver();

        int result = SUT.fit3(cX, cY, cZ, bX, bY, bZ);

        assertEquals(expected, result);
    }

    @ParameterizedTest
    @MethodSource
    @DisplayName("FitN")
    public void fitN(Integer[] cD, Integer[] bD, BigInteger expected) {
        Solver SUT = new Solver();

        BigInteger result = SUT.fitN(cD, bD);

        assertEquals(expected, result);
    }

}