Pairs with Certain Sum - Leetcode 1865

Author: kshitizsaini113

src/main/java/array/pairs_with_certian_sum/FrequencyMap.java

@@ -0,0 +1,85 @@
+package array.pairs_with_certian_sum;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implements a data structure to find pairs with a certain sum from two arrays.
+ *
+ * <p>This class is optimized for frequent {@code count} queries. It achieves this by
+ * pre-processing {@code nums2} into a frequency map. This allows the {@code count}
+ * operation to run in O(N) time (where N is the length of {@code nums1}), and the
+ * {@code add} operation to run in O(1) time.
+ */
+public class FrequencyMap {
+    private final int[] nums1;
+    private final int[] nums2;
+    private final Map<Integer, Integer> freqMap;
+
+    /**
+     * Initializes the data structure with two integer arrays.
+     *
+     * <p>The constructor stores references to the arrays and builds a frequency map
+     * from {@code nums2} to enable fast lookups.
+     *
+     * <p><b>Complexity:</b> O(M), where M is the length of {@code nums2}, due to
+     * building the frequency map.
+     *
+     * @param nums1 The first integer array, which remains static.
+     * @param nums2 The second integer array, which can be modified.
+     */
+    public FrequencyMap(int[] nums1, int[] nums2) {
+        this.nums1 = nums1;
+        this.nums2 = nums2;
+        this.freqMap = new HashMap<>();
+        for (int num : nums2) {
+            freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
+        }
+    }
+
+    /**
+     * Adds a value to an element in {@code nums2} and updates the frequency map.
+     *
+     * <p>This operation first decrements the frequency of the old value at the given
+     * index. If the frequency becomes zero, the entry is removed from the map. It then
+     * updates the array element and increments the frequency of the new value.
+     *
+     * <p><b>Complexity:</b> O(1) on average for HashMap operations.
+     *
+     * @param index The index in {@code nums2} to modify.
+     * @param val   The positive integer value to add.
+     */
+    public void add(int index, int val) {
+        // First, decrement the count of the old number.
+        int oldVal = nums2[index];
+        freqMap.computeIfPresent(oldVal, (key, count) -> (count == 1) ? null : count - 1);
+
+        // Update the number in the array.
+        nums2[index] += val;
+
+        // Then, increment the count of the new number.
+        int newVal = nums2[index];
+        freqMap.put(newVal, freqMap.getOrDefault(newVal, 0) + 1);
+    }
+
+    /**
+     * Counts the number of pairs (i, j) such that nums1[i] + nums2[j] == total.
+     *
+     * <p>This method iterates through the static {@code nums1} array. For each element
+     * {@code n1}, it calculates the required complement ({@code total - n1}) and looks
+     * up its frequency in the map of {@code nums2}.
+     *
+     * <p><b>Complexity:</b> O(N), where N is the length of {@code nums1}.
+     *
+     * @param total The target sum to find.
+     * @return The total number of pairs that sum to {@code total}.
+     */
+    public int count(int total) {
+        int result = 0;
+        for (int num : nums1) {
+            // For each number in nums1, find how many complements exist in nums2.
+            result += freqMap.getOrDefault(total - num, 0);
+        }
+        return result;
+    }
+}

src/main/java/array/pairs_with_certian_sum/package-info.java

@@ -0,0 +1,40 @@
+/**
+ * Provides an implementation for the "Find Pairs With a Certain Sum" problem.
+ *
+ * <p>The problem requires designing a data structure that manages two integer arrays,
+ * {@code nums1} and {@code nums2}, and supports two types of operations:
+ * <ol>
+ *   <li><b>Add:</b> Update an element in {@code nums2} by adding a positive value to it.</li>
+ *   <li><b>Count:</b> Count the number of pairs {@code (i, j)} such that
+ *       {@code nums1[i] + nums2[j]} equals a given total.</li>
+ * </ol>
+ *
+ * <h3>Core Implementation Strategy</h3>
+ *
+ * <p>A naive approach to the {@code count} operation would be to iterate through both
+ * arrays for every query, resulting in an O(N * M) time complexity, which is too slow.
+ *
+ * <p>A much more efficient strategy is to pre-process one of the arrays into a frequency
+ * map (e.g., a {@code HashMap}). Since {@code nums2} is the array that gets modified, it is
+ * the ideal candidate for this map. By storing the counts of each number in {@code nums2},
+ * the {@code count} operation can be optimized significantly.
+ *
+ * <p>The logic is as follows:
+ * <ul>
+ *   <li><b>Initialization:</b> Store {@code nums1} as is. Create a frequency map from
+ *       {@code nums2} to count occurrences of each number.</li>
+ *   <li><b>{@code count(total)}:</b> Iterate through the static {@code nums1} array. For each
+ *       number {@code n1} in {@code nums1}, calculate the required complement {@code target = total - n1}.
+ *       Look up how many times {@code target} appears in the {@code nums2} frequency map and
+ *       add that count to the total. This reduces the complexity of a count query to O(length of nums1).</li>
+ *   <li><b>{@code add(index, val)}:</b> When a value in {@code nums2} is updated, the frequency
+ *       map must also be updated. Decrement the count of the old value ({@code nums2[index]})
+ *       and increment the count of the new value ({@code nums2[index] + val}). This keeps the
+ *       map in sync with the array.</li>
+ * </ul>
+ *
+ * @version 1.0
+ * @see <a href="https://leetcode.com/problems/finding-pairs-with-a-certain-sum">LeetCode 1865: Find Pairs With a Certain Sum</a>
+ * @since 1.0
+ */
+package array.pairs_with_certian_sum;

src/test/java/array/pairs_with_certian_sum/FrequencyMapTest.java

@@ -0,0 +1,94 @@
+package array.pairs_with_certian_sum;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test suite for the {@link FrequencyMap} class.
+ */
+class FrequencyMapTest {
+
+    @Test
+    @DisplayName("Should correctly handle the provided LeetCode example scenario")
+    void shouldPassLeetCodeScenario() {
+        // Input:
+        // ["FindSumPairs", "count", "add", "count", "count", "add", "add", "count"]
+        // [[[1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]], [7], [3, 2], [8], [4], [0, 1], [1, 1], [7]]
+        // Expected Output:
+        // [null, 8, null, 2, 1, null, null, 11]
+
+        // Initialize the class
+        int[] nums1 = {1, 1, 2, 2, 2, 3};
+        int[] nums2 = {1, 4, 5, 2, 5, 4};
+        FrequencyMap findSumPairs = new FrequencyMap(nums1, nums2);
+
+        // count(7) -> Expected: 8
+        // Pairs: (2,5), (2,5), (2,5), (2,5), (2,5), (2,5) from nums1[2,3,4] and nums2[2,4] -> 3*2=6
+        // Pairs: (3,4), (3,4) from nums1[5] and nums2[1,5] -> 1*2=2. Total = 8.
+        assertEquals(8, findSumPairs.count(7), "Initial count for total 7 should be 8");
+
+        // add(3, 2) -> nums2 becomes [1, 4, 5, 4, 5, 4]
+        findSumPairs.add(3, 2);
+
+        // count(8) -> Expected: 2
+        // Pairs: (3,5), (3,5) from nums1[5] and nums2[2,4] -> 1*2=2. Total = 2.
+        assertEquals(2, findSumPairs.count(8), "Count for total 8 after first add should be 2");
+
+        // count(4) -> Expected: 1
+        // Pair: (3,1) from nums1[5] and nums2[0]. Total = 1.
+        assertEquals(1, findSumPairs.count(4), "Count for total 4 should be 1");
+
+        // add(0, 1) -> nums2 becomes [2, 4, 5, 4, 5, 4]
+        findSumPairs.add(0, 1);
+        // add(1, 1) -> nums2 becomes [2, 5, 5, 4, 5, 4]
+        findSumPairs.add(1, 1);
+
+        // count(7) -> Expected: 11
+        // Pairs: (2,5), (2,5), (2,5) from nums1[2,3,4] and nums2[1,2,4] -> 3*3=9
+        // Pairs: (3,4), (3,4) from nums1[5] and nums2[3,5] -> 1*2=2. Total = 11.
+        assertEquals(11, findSumPairs.count(7), "Count for total 7 after final adds should be 11");
+    }
+
+    @Test
+    @DisplayName("Should return 0 when no pairs sum to the target")
+    void shouldReturnZeroWhenNoPairsMatch() {
+        int[] nums1 = {10, 20, 30};
+        int[] nums2 = {1, 2, 3};
+        FrequencyMap findSumPairs = new FrequencyMap(nums1, nums2);
+
+        assertEquals(0, findSumPairs.count(100), "Should return 0 for a total that cannot be formed");
+        assertEquals(0, findSumPairs.count(5), "Should return 0 for a total that is too small");
+    }
+
+    @Test
+    @DisplayName("Should correctly update counts after an add operation")
+    void shouldUpdateCountsAfterAdd() {
+        int[] nums1 = {1, 2, 3};
+        int[] nums2 = {1, 1, 1};
+        FrequencyMap findSumPairs = new FrequencyMap(nums1, nums2);
+
+        // Initially, 3 pairs sum to 2: (1,1), (1,1), (1,1)
+        assertEquals(3, findSumPairs.count(2), "Initial count for total 2 should be 3");
+
+        // Add 1 to nums2[0], making it [2, 1, 1]
+        findSumPairs.add(0, 1);
+
+        // Now, 2 pairs sum to 2: (1,1), (1,1)
+        assertEquals(2, findSumPairs.count(2), "Count for total 2 should decrease to 2 after add");
+        // And 1 pair sums to 4: (2,2), (3, 1), (3, 1)
+        assertEquals(3, findSumPairs.count(4), "Count for total 4 should become 1 after add");
+    }
+
+    @Test
+    @DisplayName("Should handle arrays with duplicate numbers correctly")
+    void shouldHandleDuplicatesInBothArrays() {
+        int[] nums1 = {2, 2, 2};
+        int[] nums2 = {3, 3};
+        FrequencyMap findSumPairs = new FrequencyMap(nums1, nums2);
+
+        // Each of the 3 '2's in nums1 can be paired with each of the 2 '3's in nums2
+        assertEquals(6, findSumPairs.count(5), "Should be 3 * 2 = 6 pairs that sum to 5");
+    }
+}