Codestin Search App

4Sum II - Problem

You're given four integer arrays nums1, nums2, nums3, and nums4, each containing n integers. Your mission is to find how many different ways you can pick one number from each array such that their sum equals zero.

More formally, return the number of tuples (i, j, k, l) where:

0 ≤ i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

Example:
If nums1 = [1, 2], nums2 = [-2, -1], nums3 = [-1, 2], nums4 = [0, 2]
We can form: 1 + (-2) + (-1) + 2 = 0 and 2 + (-1) + (-1) + 0 = 0
So the answer is 2.

This problem tests your ability to optimize from a naive O(n⁴) solution to an efficient O(n²) approach using hash tables and the "meet in the middle" technique.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]

› Output: 2

💡 Note: Two valid combinations: 1 + (-2) + (-1) + 2 = 0 and 2 + (-1) + (-1) + 0 = 0

example_2.py — No Solutions

$ Input: nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]

› Output: 1

💡 Note: Only one combination possible: 0 + 0 + 0 + 0 = 0

example_3.py — Multiple Duplicates

$ Input: nums1 = [1,1], nums2 = [-1,-1], nums3 = [1,1], nums4 = [-1,-1]

› Output: 16

💡 Note: All 16 combinations sum to zero: 1 + (-1) + 1 + (-1) = 0 for every (i,j,k,l) pair

Constraints

n == nums1.length == nums2.length == nums3.length == nums4.length
1 ≤ n ≤ 200
-2²⁸ ≤ nums1[i], nums2[i], nums3[i], nums4[i] ≤ 2²⁸
All arrays have the same length
Large integer values require careful overflow handling

Visualization

Tap to expand

Understanding the Visualization

Split Problem

Divide 4-array problem into two 2-array problems: (nums1, nums2) and (nums3, nums4)

Build Hash Map

Calculate all sums from nums1[i] + nums2[j] and store frequencies in hash table

Find Complements

For each nums3[k] + nums4[l], look up -(nums3[k] + nums4[l]) in hash table

Count Solutions

Sum up all frequencies of found complements to get total count

Key Takeaway

🎯 Key Insight: By splitting the 4-array problem into two 2-array subproblems, we reduce the complexity from O(n⁴) to O(n²), making it efficient enough for the given constraints while using the complementary sum property.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a two-pass hash table approach with the meet in the middle technique. First, compute all possible sums from the first two arrays and store their frequencies in a hash table. Then, for each sum from the last two arrays, look up its negative complement in the hash table. This reduces complexity from O(n⁴) to O(n²) time with O(n²) space trade-off.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Optimal)	O(n²)	O(n²)	Use hash table to store sums of first two arrays, then find complements
Brute Force (Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of four elements using nested loops

Two-Pass Hash Table (Optimal) — Algorithm Steps

Create a hash table to store sums and their frequencies
First pass: Calculate all sums of nums1[i] + nums2[j] and store frequencies
Second pass: For each sum of nums3[k] + nums4[l], look up -(nums3[k] + nums4[l]) in hash table
Add the frequency of the complement to the result count

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Table

Store all sums from nums1 + nums2 with frequencies

Find Complements

For each nums3 + nums4 sum, lookup its negative in hash table

Count Results

Add frequency of found complements to total count

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#define HASH_SIZE 100003

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size) {
    Node* table[HASH_SIZE] = {NULL};
    
    // First pass: store all sums
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            int sum = nums1[i] + nums2[j];
            int idx = hash(sum);
            
            Node* curr = table[idx];
            while (curr && curr->key != sum) {
                curr = curr->next;
            }
            
            if (curr) {
                curr->value++;
            } else {
                Node* newNode = malloc(sizeof(Node));
                newNode->key = sum;
                newNode->value = 1;
                newNode->next = table[idx];
                table[idx] = newNode;
            }
        }
    }
    
    int count = 0;
    // Second pass: find complements
    for (int k = 0; k < nums3Size; k++) {
        for (int l = 0; l < nums4Size; l++) {
            int target = -(nums3[k] + nums4[l]);
            int idx = hash(target);
            
            Node* curr = table[idx];
            while (curr && curr->key != target) {
                curr = curr->next;
            }
            
            if (curr) {
                count += curr->value;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* curr = table[i];
        while (curr) {
            Node* temp = curr;
            curr = curr->next;
            free(temp);
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two passes of O(n²) each - first to populate hash table, second to find complements

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash table can store up to n² different sums from first two arrays

⚠ Quadratic Space

89.7K Views

High Frequency

~18 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler