93 lines
2.7 KiB
Markdown
93 lines
2.7 KiB
Markdown
# 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 Two-Sum]]
|
|
|
|
|
|
|
|
##### 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;
|
|
}
|
|
};
|
|
``` |