(7/60)四数相加、赎金信、三数之和、四数之和

四数相加

leetcode：454. 四数相加 II

map法

思路

1. 遍历A、B数组，建立a+b数值->该数值出现次数的map映射。
2. 再遍历C、D数组，寻找map[0 - (c + d)]是否存在，计算count。

注意点

1. 四个不同数组，不用考虑去重；只求组数，不要求下标。
2. map[a+b]++自动insert并value++。

复杂度分析

时间复杂度：O(N^2)。

空间复杂度：O(N^2)。最坏情况下，A、B数组相加结果全不相同（N*M）。

代码实现

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        // 键值对a+b  ->  出现次数
        // 遍历A、B得到a+b的出现次数
        // 遍历C、D寻找map[0-(c+d)]是否存在，计算count
        unordered_map<int,int> map;
        int count = 0;
        for(int a : nums1){
            for(int b : nums2){
                map[a+b]++;
            }
        }

        for(int c : nums3){
            for(int d : nums4){
                // 如果存在map[0-(c+d)]
                if(map.find(0 - (c + d) ) != map.end()){  
                    count += map[0 - ( c + d )]; 
                }
            }
        }

        return count;
    }
};

---

赎金信

数组哈希

思路

和有效异位词类似，只是有效异位词两个字母集必须完全相等，而赎金信只需满足包含关系即可。

1. 遍历magazine映射到数组里，value++。
2. 遍历ransomNote映射到数组里，value--。
3. 遍历hash数组，若有<0的元素则不满足；否则可满足。

复杂度分析

时间复杂度：O(N)。

空间复杂度：O(1)。常数大小数组。

注意点

略

代码实现

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        // 检测magazine里的字母能否构成ransomNote
        // magazine里的字母集包含ransomNote的字母集
        int hash[26] = {0};
        for(char c : magazine){
            hash[c - 'a']++;
        }

        for(char c : ransomNote){
            hash[c - 'a']--;
        } 

        for(int num : hash){
            if(num < 0){
                return false;
            }
        }

        return true;
    }
};

---

三数之和

leetcode：15. 三数之和

双指针法

思路

由于三元组不可重复，关键问题在于：剪枝、去重。

1. 首先排序数组，方便后续剪枝、去重操作。

2. for遍历数组，剪枝、去重，确定元组第一个元素，然后进入内层循环，双指针代表第二、三个元素，剪枝，并对比累和与0，向内靠拢。

3. 找到符合目标三元组后，收录当前三元组，然后进行去重操作。

4. 重复2、3直到遍历结束。

复杂度分析

时间复杂度：O(N^2)。遍历数组O(N)*双指针移动遍历部分数组O(N)。

空间复杂度：O(1)。

注意点

1. vector{ }用元素构造数组。
2. 先收录三元组，再去重、收缩。
3. 剪枝主要是为了减少时间复杂度。

代码实现

class Solution {
public:
    // 双指针法
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        // 排序
        sort(nums.begin(),nums.end());
        // 找a+b+c = 0
        for(int i = 0;i < nums.size();i++){
            // 如果去重后的三元组第一个元素就>0，
            // 那么之后元素不可能使三数之和为0了，直接返回
            if(nums[i] > 0)
                return result;
            // 去重a
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right){
                if(nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else if(nums[i] + nums[left] + nums[right] > 0){
                    right--;
                }else{  // 找到三元组
                    // 放入数组
                    result.push_back(vector<int>{nums[i],nums[left],nums[right]});
                    // b、c去重（在找到一个三元组之后去重）
                    while(left < right && nums[left] == nums[left + 1]){ left++; }
                    while(left < right && nums[right] == nums[right - 1]){ right--; }
                    // 找到结果后，l和r向中间收缩
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

---

四数之和

双指针法

leetcode：18. 四数之和

思路

在三数之和基础上再加一层for循环，核心依旧是剪枝、去重。

剪枝时需要注意，要确保当前元素，或累和>0，再保证>target。