# Leetcode Intersection-of-Two-Arrays-II

#### 2022-06-11

##### First revision 2022-06-27

---

##### Data structures:

#DS #unordered_map

##### Algorithms:

#algorithm #two_pointers #sort

##### Difficulty:

#leetcode #coding_problems #difficulty_easy

##### Related topics:

##### Links:

- [Link to problem](https://leetcode.com/problems/intersection-of-two-arrays-ii/)
- [Solution 2(two pointers method)](https://leetcode.com/problems/intersection-of-two-arrays-ii/discuss/846181/C%2B%2B-Solutions-or-1-%3A-Map-or-2-%3A-Two-Pointer-with-sort)
- [Solution 3 and 4](https://leetcode.com/problems/intersection-of-two-arrays-ii/discuss/82243/Solution-to-3rd-follow-up-question)

  ***

### Problem

Given two integer arrays `nums1` and `nums2`, return _an array of their intersection_. Each element in the result must appear as many times as it shows in both arrays and you may return the result in **any order**.

**Follow up:**

- What if the given array is already sorted? How would you optimize your algorithm?
- What if `nums1`'s size is small compared to `nums2`'s size? Which algorithm is better?
- What if elements of `nums2` are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

#### Examples

**Example 1:**

```
**Input:** nums1 = [1,2,2,1], nums2 = [2,2]
**Output:** [2,2]
```

**Example 2:**

```
**Input:** nums1 = [4,9,5], nums2 = [9,4,9,8,4]
**Output:** [4,9]
**Explanation:** [9,4] is also accepted.
```

#### Constraints

- 1 <= nums1.length, nums2.length <= 1000
- 0 <= nums1[i], nums2[i] <= 1000

### Thoughts

For the original problem, I thought up an O(m + n) algo, that uses C++'s [[cpp_std_unordered_map]], and for the second one, I use double pointer method.

> [!tip]
> Because elements can be duplicated and we need to know how many, we should use unordered map to store the item's appereance times, (Maybe multiset can work too.)

> [!tip] Use [[cpp_std_unordered_map]] for a O(1) hash table when not sorted #tip

> [!tip] Use [[cpp_std_sort]] to sort anything. #tip

### Solution

Unordered map way O(m + n)

```cpp
class Solution {
public:
  vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
    vector<int> answer;
    unordered_map<int, int> umap;
    for (int i = 0; i < nums1.size(); i++) {
      umap[nums1[i]]++;
    }

    for (int i = 0; i < nums2.size(); i++) {
      if (umap[nums2[i]] != 0) {
        answer.push_back(nums2[i]);
        umap[nums2[i]]--;
      }
    }
    return answer;
  }
};
```
