notes/OJ notes/pages/Leetcode Intersection-of-Two-Arrays-II.md

# 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_problem #difficulty-easy
##### Related topics:
```expander
tag:#unordered_map OR tag:#two_pointers OR tag:#sort
```
 
- [[cpp_std_sort]]
- [[cpp_std_unordered_map]]
- [[Leetcode Merge-Sorted-Array]]
- [[Leetcode Merge-Two-Sorted-Lists]]
- [[Leetcode Squares-of-a-Sorted-Array]]
- [[Leetcode Two-Sum]]
- [[Two pointers approach]]
 


##### 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;
    }
};
```