2248. 多个数组求交集 ●

2248. 多个数组求交集 ●

描述

给你一个二维整数数组 nums ，其中 nums[i] 是由 不同 正整数组成的一个非空数组，按 升序排列 返回一个数组，数组中的每个元素在 nums 所有数组 中都出现过。

$1<=nums.length<=1000$
$1<=sum(nums[i].length)<=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({\sum }_i{n}_i+k)$，其中 $n_i$ 为 $\text{nums}[i]$ 的长度。即为遍历统计每个整数出现次数，遍历计数数组统计结果的时间复杂度。

• 空间复杂度：$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({\sum }_i{n}_i+\min (n_i)\log \min (n_i))$，其中 $n_i$为 $\text{nums}[i]$ 的长度。即为遍历统计每个整数出现次数，遍历哈希表统计结果以及排序的时间复杂度。
• 空间复杂度：$O({\max }_i{n}_i)$，即为辅助哈希表的时间复杂度。

此外，用 map 数据结构作为哈希映射可以省去最后的排序过程，但是每次统计时对红黑树的操作复杂度为$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({\sum }_i{n}_i+\min (n_i)\log \min (n_i))$，其中 $n_i$为 $\text{nums}[i]$ 的长度。即为遍历统计每个整数出现次数，遍历哈希表统计结果以及排序的时间复杂度。
• 空间复杂度：$O({\max }_i{n}_i)$，即为辅助哈希表的时间复杂度。

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({\sum }_i{n}_i+\min (n_i)\log \min (n_i))$，其中 $n_i$为 $\text{nums}[i]$ 的长度。即为遍历统计每个整数出现次数，遍历哈希表统计结果以及排序的时间复杂度。
• 空间复杂度：$O({\max }_i{n}_i)$，即为辅助哈希表的时间复杂度。

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