Dot Product of Two Sparse Vectors - Practice Coding Problems

Dot Product of Two Sparse Vectors - Problem

Given two sparse vectors, compute their dot product. A sparse vector is a vector that has mostly zero values - think of it like a long list where only a few positions have meaningful data.

You need to implement a SparseVector class with:

SparseVector(nums) - Initializes the object with the vector nums
dotProduct(vec) - Computes the dot product between this instance and vec

The dot product is calculated by multiplying corresponding elements and summing the results: v1[0]*v2[0] + v1[1]*v2[1] + ... + v1[n]*v2[n]

Key Challenge: Store the sparse vector efficiently and compute the dot product optimally. Since most values are zero, we don't want to waste time or space on them!

Follow-up: What if only one of the vectors is sparse?

Input & Output

example_1.py — Basic sparse vectors

$ Input: nums1 = [1,0,0,2,3], nums2 = [0,3,0,4,0]

› Output: 8

💡 Note: v1 = [1,0,0,2,3], v2 = [0,3,0,4,0]. Dot product = 1×0 + 0×3 + 0×0 + 2×4 + 3×0 = 0 + 0 + 0 + 8 + 0 = 8

example_2.py — Highly sparse vectors

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

› Output: 0

💡 Note: No overlapping non-zero positions. All products are 0, so dot product = 0

example_3.py — Dense vectors

$ Input: nums1 = [0,1,0,0,2,0,0], nums2 = [1,0,0,0,3,0,4]

› Output: 6

💡 Note: Only position 4 has non-zero values in both: 2×3 = 6

Constraints

n == nums1.length == nums2.length
1 ≤ n ≤ 10⁵
-100 ≤ nums1[i], nums2[i] ≤ 100
At most 1000 calls will be made to dotProduct

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

Most vector elements are zero, wasting computation time

Store Smart

Use hash map to store only meaningful (non-zero) values

Compute Efficiently

Only process indices that have values in both vectors

Key Takeaway

🎯 Key Insight: For sparse data, only store and process the meaningful elements. This transforms an O(n) problem into O(k) where k << n, providing massive speedups for highly sparse vectors.

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a hash map to store only non-zero elements with their indices. During dot product computation, iterate through the smaller hash map and check for matching indices in the other vector. This achieves O(min(a,b)) time complexity where a and b are the number of non-zero elements, making it highly efficient for sparse data.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Pairs)	O(a + b)	O(k)	Store (index, value) pairs sorted by index, use two pointers to find matches
Brute Force (Check Every Element)	O(n)	O(n)	Store full arrays and multiply all corresponding elements
Hash Map (Optimal)	O(min(a, b))	O(k)	Store only non-zero elements in hash map for efficient sparse representation

Two Pointers (Sorted Pairs) — Algorithm Steps

Store non-zero elements as (index, value) pairs in sorted arrays
Initialize two pointers at start of both arrays
Compare indices: if equal, multiply values and advance both pointers
If indices different, advance pointer with smaller index

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Sorted Pairs

Store (index, value) for non-zero elements

Initialize Pointers

Start at beginning of both arrays

Compare and Advance

Move pointers based on index comparison

Code -

solution.c — C

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

typedef struct {
    int index;
    int value;
} Pair;

typedef struct {
    Pair* pairs;
    int size;
} SparseVector;

SparseVector* sparseVectorCreate(int* nums, int numsSize) {
    SparseVector* obj = (SparseVector*)malloc(sizeof(SparseVector));
    obj->pairs = (Pair*)malloc(numsSize * sizeof(Pair));
    obj->size = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] != 0) {
            obj->pairs[obj->size].index = i;
            obj->pairs[obj->size].value = nums[i];
            obj->size++;
        }
    }
    return obj;
}

int sparseVectorDotProduct(SparseVector* obj, SparseVector* vec) {
    int result = 0;
    int i = 0, j = 0;
    
    // Two pointers approach
    while (i < obj->size && j < vec->size) {
        if (obj->pairs[i].index == vec->pairs[j].index) {
            result += obj->pairs[i].value * vec->pairs[j].value;
            i++;
            j++;
        } else if (obj->pairs[i].index < vec->pairs[j].index) {
            i++;
        } else {
            j++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(a + b)

Where a and b are number of non-zero elements, single pass with two pointers

✓ Linear Growth

Space Complexity

O(k)

Where k is number of non-zero elements

✓ Linear Space

41.3K Views

Medium Frequency

~15 min Avg. Time

1.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 Pointers (Sorted Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler