Finding Pairs With a Certain Sum

Finding Pairs With a Certain Sum - Problem

You are given two integer arrays nums1 and nums2. You need to implement a data structure that supports queries of two types:

Add: Add a positive integer to an element at a given index in the array nums2.

Count: Count the number of pairs (i, j) such that nums1[i] + nums2[j] equals a given value (where 0 <= i < nums1.length and 0 <= j < nums2.length).

Implement the FindSumPairs class:

FindSumPairs(int[] nums1, int[] nums2) - Initializes the object with two integer arrays
void add(int index, int val) - Adds val to nums2[index]
int count(int tot) - Returns the number of pairs (i, j) such that nums1[i] + nums2[j] == tot

Input & Output

Example 1 — Basic Operations

$ Input: nums1 = [1,1,2,2,2,3], nums2 = [1,4,5,2,5,4], operations = [["count",7],["add",1,2],["count",8],["count",4],["add",2,1],["count",5]]

› Output: [8,2,1,1]

💡 Note: count(7): pairs (0,2),(0,4),(1,2),(1,4),(2,1),(2,3),(4,1),(4,3) = 8 pairs. add(1,2): nums2[1] = 4+2 = 6. count(8): pairs (2,1),(4,1) = 2 pairs. count(4): pair (2,0) = 1 pair.

Example 2 — Simple Case

$ Input: nums1 = [1,2], nums2 = [3,4], operations = [["count",5],["add",0,1],["count",6]]

› Output: [2,2]

💡 Note: count(5): pairs (0,1) and (1,0) where 1+4=5 and 2+3=5. add(0,1): nums2[0] = 3+1 = 4. count(6): pairs (0,1) and (1,0) where 1+5=6 and 2+4=6.

Example 3 — No Pairs Found

$ Input: nums1 = [1,2], nums2 = [5,6], operations = [["count",3],["add",0,2],["count",5]]

› Output: [0,0]

💡 Note: count(3): no pairs sum to 3. add(0,2): nums2[0] = 5+2 = 7. count(5): still no pairs sum to 5.

Constraints

1 ≤ nums1.length ≤ 1000
1 ≤ nums2.length ≤ 10⁵
1 ≤ nums1[i] ≤ 10⁹
1 ≤ nums2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use frequency maps to avoid recounting identical elements. Store nums1 frequencies once, maintain nums2 frequencies that update on add operations. Best approach uses frequency counting for O(unique nums1 elements) count queries. Time: O(n) per count, Space: O(n+m)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Pairs Every Time

⏱️ Time: O(n×m) Space: O(1)

Store both arrays and for each count operation, check every element in nums1 against every element in nums2. Simple but inefficient for frequent queries.

Frequency Count Optimization

⏱️ Time: O(n) Space: O(n+m)

Store frequency count of nums1 elements once. For nums2, maintain a frequency map that updates on add operations. For count queries, iterate through nums1 frequencies and lookup complements.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int** board, int m, int n) {
    if (board == NULL || m == 0 || n == 0) return;
    
    int directions[8][2] = {{-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,1}, {1,-1}, {1,0}, {1,1}};
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int liveNeighbors = 0;
            
            // Count live neighbors (current state is board[ni][nj] & 1)
            for (int k = 0; k < 8; k++) {
                int ni = i + directions[k][0], nj = j + directions[k][1];
                if (ni >= 0 && ni < m && nj >= 0 && nj < n && (board[ni][nj] & 1) == 1) {
                    liveNeighbors++;
                }
            }
            
            // Apply Conway's rules with state encoding
            if ((board[i][j] & 1) == 1) {  // Currently alive
                if (liveNeighbors == 2 || liveNeighbors == 3) {
                    board[i][j] = 3;  // Alive -> Alive
                }
            } else {  // Currently dead
                if (liveNeighbors == 3) {
                    board[i][j] = 2;  // Dead -> Alive
                }
            }
        }
    }
    
    // Convert to final state
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            board[i][j] >>= 1;
        }
    }
}

int** parseBoard(char* input, int* m, int* n) {
    // Simple JSON parser for 2D array
    int len = strlen(input);
    if (len < 2) return NULL;
    
    // Count rows
    *m = 0;
    for (int i = 0; i < len; i++) {
        if (input[i] == '[' && i > 0) (*m)++;
    }
    if (*m == 0) return NULL;
    
    int** board = (int**)malloc(*m * sizeof(int*));
    
    // Parse each row
    int row = 0;
    int i = 1; // Skip first '['
    while (i < len - 1 && row < *m) {
        if (input[i] == '[') {
            i++; // Skip '['
            
            // Count elements in this row
            int col_count = 0;
            int j = i;
            while (j < len && input[j] != ']') {
                if (input[j] == '0' || input[j] == '1') col_count++;
                j++;
            }
            
            if (row == 0) *n = col_count;
            board[row] = (int*)malloc(col_count * sizeof(int));
            
            // Parse numbers
            int col = 0;
            while (i < len && input[i] != ']' && col < col_count) {
                if (input[i] == '0' || input[i] == '1') {
                    board[row][col++] = input[i] - '0';
                }
                i++;
            }
            row++;
        }
        i++;
    }
    
    return board;
}

int main() {
    char input[1000];
    if (fgets(input, sizeof(input), stdin) == NULL) return 1;
    
    // Remove newline
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') input[len-1] = '\0';
    
    int m, n;
    int** board = parseBoard(input, &m, &n);
    
    if (board == NULL) {
        printf("[]\n");
        return 0;
    }
    
    solution(board, m, n);
    
    // Print result
    printf("[");
    for (int i = 0; i < m; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", board[i][j]);
            if (j < n - 1) printf(",");
        }
        printf("]");
        if (i < m - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(board[i]);
    }
    free(board);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

18.6K Views

Medium Frequency

~25 min Avg. Time

485 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