LeetCode 1570. Dot Product of Two Sparse Vectors

原题链接在这里：https://leetcode.com/problems/dot-product-of-two-sparse-vectors/description/

题目：

Given two sparse vectors, compute their dot product.

Implement class SparseVector:

• SparseVector(nums) Initializes the object with the vector nums
• dotProduct(vec) Compute the dot product between the instance of SparseVector and vec

A sparse vector is a vector that has mostly zero values, you should store the sparse vector efficiently and compute the dot product between two SparseVector.

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

Example 1:

Input: nums1 = [1,0,0,2,3], nums2 = [0,3,0,4,0]
Output: 8
Explanation: v1 = SparseVector(nums1) , v2 = SparseVector(nums2)
v1.dotProduct(v2) = 1*0 + 0*3 + 0*0 + 2*4 + 3*0 = 8

Example 2:

Input: nums1 = [0,1,0,0,0], nums2 = [0,0,0,0,2]
Output: 0
Explanation: v1 = SparseVector(nums1) , v2 = SparseVector(nums2)
v1.dotProduct(v2) = 0*0 + 1*0 + 0*0 + 0*0 + 0*2 = 0

Example 3:

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

Constraints:

• n == nums1.length == nums2.length
• 1 <= n <= 10^5
• 0 <= nums1[i], nums2[i] <= 100

题解：

Since the vector is sparce, it only make sense to store the indice of elements that are not 0.

We have a map to store the index, element if element != 0.

When multiply, go through the second vec's map and find if the corresponding index is in the first vec's map. If yes, then accumulate the results.

If only one of the vectors is sparse, taking advantage of map, we want to initialize with the non-sparce vector. And dotProduct with the sparce vector. Then j, n in vec.m.items() is a small map.

Time Complexity: constructor, O(m). m = nums.length. dotProduct, O(n). n = vec.length.

Space: O(m + n).

AC Java:

class SparseVector {
    Map<Integer, Integer> hm;

    SparseVector(int[] nums) {
        hm = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != 0){
                hm.put(i, nums[i]);
            }
        }    
    }
    
    // Return the dotProduct of two sparse vectors
    public int dotProduct(SparseVector vec) {
        if(this.hm.size() < vec.hm.size()){
            return vec.dotProduct(this);
        }
        
        int res = 0;
        for(Map.Entry<Integer, Integer> entry : vec.hm.entrySet()){
            if(this.hm.containsKey(entry.getKey())){
                res += this.hm.get(entry.getKey()) * entry.getValue();
            }
        }

        return res;
    }
}

// Your SparseVector object will be instantiated and called as such:
// SparseVector v1 = new SparseVector(nums1);
// SparseVector v2 = new SparseVector(nums2);
// int ans = v1.dotProduct(v2);

AC Python:

class SparseVector:
    def __init__(self, nums: List[int]):
        self.m = {}
        for i, n in enumerate(nums):
            if n != 0:
                self.m[i] = n

    # Return the dotProduct of two sparse vectors
    def dotProduct(self, vec: 'SparseVector') -> int:
        res = 0
        for j, n in vec.m.items():
            if j in self.m:
                res += self.m[j] * n
        return res

# Your SparseVector object will be instantiated and called as such:
# v1 = SparseVector(nums1)
# v2 = SparseVector(nums2)
# ans = v1.dotProduct(v2)

类似Sparse Matrix Multiplication.