2248. 多个数组求交集 ●
描述
给你一个二维整数数组 nums ,其中 nums[i] 是由 不同 正整数组成的一个非空数组,按 升序排列 返回一个数组,数组中的每个元素在 nums 所有数组 中都出现过。
1
<
=
n
u
m
s
.
l
e
n
g
t
h
<
=
1000
1 <= nums.length <= 1000
1<=nums.length<=1000
1
<
=
s
u
m
(
n
u
m
s
[
i
]
.
l
e
n
g
t
h
)
<
=
1000
1 <= sum(nums[i].length) <= 1000
1<=sum(nums[i].length)<=1000
1
<
=
n
u
m
s
[
i
]
[
j
]
<
=
1000
1 <= nums[i][j] <= 1000
1<=nums[i][j]<=1000
nums[i] 中的所有值 互不相同
示例
输入:nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
输出:[3,4]
解释:
nums[0] = [3,1,2,4,5],nums[1] = [1,2,3,4],nums[2] = [3,4,5,6],在 nums 中每个数组中都出现的数字是 3 和 4 ,所以返回 [3,4] 。
题解
1. 数组计数(统计每个数出现的次数)
因为题目限定了数组的大小和元素值都在1000内,因此可以用一个数组来统计 1000 内的数字出现的频次,最终遍历判断频次是否为数组的长度即可,不需要排序。
-
时间复杂度: O ( ∑ i n i + k ) O(\sum_i n_i + k) O(∑ini+k),其中 n i n_i ni 为 nums [ i ] \textit{nums}[i] nums[i] 的长度。即为遍历统计每个整数出现次数,遍历计数数组统计结果的时间复杂度。
-
空间复杂度: O ( k ) O(k) O(k),k = 1001,用来存放计数数组。
class Solution {
public:
vector<int> intersection(vector<vector<int>>& nums) {
int count[1001] = {0};
vector<int> ans;
for(int i = 0; i < nums.size(); ++i){
for(int num : nums[i]){
++count[num];
}
}
for(int i = 1; i <= 1000; ++i){
if(count[i] == nums.size()){
ans.emplace_back(i);
}
}
return ans;
}
};
2. 哈希表计数
用一个哈希表映射 unordered_map
来统计所有数字出现的频次,然后遍历哈希表,判断频次是否为数组的长度即可,最后对返回数组进行排序。
- 时间复杂度: O ( ∑ i n i + min ( n i ) log min ( n i ) ) O(\sum_i n_i + \min(n_i)\log\min(n_i)) O(∑ini+min(ni)logmin(ni)),其中 n i n_i ni为 nums [ i ] \textit{nums}[i] nums[i] 的长度。即为遍历统计每个整数出现次数,遍历哈希表统计结果以及排序的时间复杂度。
- 空间复杂度: O ( max i n i ) O(\max_i n_i) O(maxini),即为辅助哈希表的时间复杂度。
此外,用 map
数据结构作为哈希映射可以省去最后的排序过程,但是每次统计时对红黑树的操作复杂度为
O
(
l
o
g
n
)
O(logn)
O(logn)。
class Solution {
public:
vector<int> intersection(vector<vector<int>>& nums) {
unordered_map<int, int> hashMap;
vector<int> ans;
for(int i = 0; i < nums.size(); ++i){
for(int num : nums[i]) ++hashMap[num];
}
for(auto iter : hashMap){
if(iter.second == nums.size()) ans.emplace_back(iter.first);
}
sort(ans.begin(), ans.end());
return ans;
}
};
3. 哈希表 set 记录交集
- 时间复杂度: O ( ∑ i n i + min ( n i ) log min ( n i ) ) O(\sum_i n_i + \min(n_i)\log\min(n_i)) O(∑ini+min(ni)logmin(ni)),其中 n i n_i ni为 nums [ i ] \textit{nums}[i] nums[i] 的长度。即为遍历统计每个整数出现次数,遍历哈希表统计结果以及排序的时间复杂度。
- 空间复杂度: O ( max i n i ) O(\max_i n_i) O(maxini),即为辅助哈希表的时间复杂度。
class Solution {
public:
vector<int> intersection(vector<vector<int>>& nums) {
unordered_set<int> hash(nums[0].begin(), nums[0].end()); // 最终的交集
unordered_set<int> temp; // 临时存放循环迭代的交集
for(int i = 1; i < nums.size(); ++i){
for(int num : nums[i]){
if(hash.count(num)){
temp.insert(num); // 循环迭代中的交集
}
}
hash = temp; // 更新交集
temp.clear();
}
vector<int> ans(hash.begin(), hash.end());
sort(ans.begin(), ans.end()); // 排序,unordered_set无序
return ans;
}
};
- 时间复杂度: O ( ∑ i n i + min ( n i ) log min ( n i ) ) O(\sum_i n_i + \min(n_i)\log\min(n_i)) O(∑ini+min(ni)logmin(ni)),其中 n i n_i ni为 nums [ i ] \textit{nums}[i] nums[i] 的长度。即为遍历统计每个整数出现次数,遍历哈希表统计结果以及排序的时间复杂度。
- 空间复杂度: O ( max i n i ) O(\max_i n_i) O(maxini),即为辅助哈希表的时间复杂度。
class Solution {
public:
vector<int> intersection(vector<vector<int>>& nums) {
int min = 1001, minIndex = -1;
for(int i = 0; i < nums.size(); ++i){
sort(nums[i].begin(), nums[i].end()); // 对所有数组排序,并找到长度最小的那个数组,作为hash初始
if(nums[i].size() < min){
min = nums[i].size();
minIndex = i;
}
}
unordered_set<int> hash(nums[minIndex].begin(), nums[minIndex].end()); // 最终的交集
unordered_set<int> temp; // 临时存放循环迭代的交集
int Max = nums[minIndex][min-1]; // 放最大值
for(int i = 0; i < nums.size(); ++i){
if(i != minIndex){
int maxtemp = 0;
for(int num : nums[i]){
if(num > Max) break; // 超过哈希表中存在的最大值则停止
if(hash.count(num)){
temp.insert(num); // 循环迭代中的交集
maxtemp = num;
}
}
Max = maxtemp;
hash = temp; // 更新交集
temp.clear();
}
}
vector<int> ans(hash.begin(), hash.end());
sort(ans.begin(), ans.end()); // 排序,unordered_set无序,即使是从小到大插入的
return ans;
}
};