代码随想录算法训练营第七天| 454.四数相加II 、 383. 赎金信、 15. 三数之和 、18. 四数之和

map(映射)、双指针、三数之和、四数之和、剪枝去重
最重要的收获是如何适当的去重

454.四数相加II

问题关键：

1. 四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况
2. 只需要统计 a+b+c+d = 0 出现的次数，不用保存四个数的下标

思路：

3. 用unordered_map保存前两数之和的相反数以及出现的次数
4. 然后在unordered_map查找后两数之和，累加得到四个元素相加等于0情况出现次数

解题步骤：

5. 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
6. 遍历大A和大B数组，统计两个数组元素之和的相反数以及出现的次数，放到map中。
7. 定义int变量result ，用来统计 a+b+c+d = 0出现的次数。
8. 在遍历大C和大D数组，如果c+d在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。 最后返回统计值 count 就可以了

代码实现

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,  int>map_sum1;
        int result = 0;
        int sum;
        for(int i = 0; i < nums1.size(); i++){
            for(int j = 0; j < nums1.size(); j++){
                sum = nums1[i]+nums2[j];
                if(map_sum1.find(-sum) != map_sum1.end()){
                    ++map_sum1[-sum];
                }
                else{
                    map_sum1.insert(pair<int,int>(-sum,1));
                }
            }
        }
        for(int i = 0; i < nums1.size(); i++){
            for(int j = 0; j < nums1.size(); j++){
                sum = nums3[i]+nums4[j];
                if(map_sum1.find(sum) != map_sum1.end()){
                    result += map_sum1[sum];
                }
            }
        }
        return result;
    }
};

383. 赎金信

问题关键：

1. 记录类别固定，用固定大小的数组充当映射
2. 原料字符数组必须大于等于目标字符数组，否则不可能写出信

二、思路：和242.有效的字母异位词相似
1、先用一个固定大小的数组V保存目标字符数组的元素出现次数（加）
2、遍历原料字符数组的元素，若存在于V，则减少相应次数（相当于原料字符数组的元素被消耗用于写信）
3、最后遍历固定大小的数组V，若存在元素小于0，则说明写信用的该字符未能足量提供

unordered_set

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if(ransomNote.size() > magazine.size()) return false;
        vector<int> V(26,0);

        for(int i = 0; i < magazine.size(); i++){
            if(i < ransomNote.size()) V[ransomNote[i]-'a']--;
            V[magazine[i]-'a']++;
        }

        for(int i = 0; i < V.size(); i++){
            if(V[i] < 0) return false;
        }

        return true;
    }
};

15. 三数之和

问题关键信息：

1. 在同一数组内取三个元素组成三元组
2. 三元组不重复（不能有重复的三元组，但三元组内的元素是可以重复的，例如{1,1,-2}）
3. 只需要得到三元组的值，而不是下标

二、双指针法思路：
1、先对数组排序，有序的数组是使用双指针的基础（因为只需要得到三元组的值，而不是下标）
2、第一个数通过依次遍历数组，得到a=nums[i]；左右指针从后面的序列的首尾两端向中间遍历，left = i-1、right = nums.size()-1;
3、如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，所以right下标就应该向左移动，使三数之和减小；如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，使三数之和增大，直到left与right相遇为止。
剪枝去重：
1、a去重——if(i > 0 && nums[i] == nums[i-1]){continue;}。不能有重复的三元组，但三元组内的元素是可以重复的。所以不能使用nums[i] == nums[i+1],这会直接去除了元素是可以重复的情况，与题意不符。
2、只有找到一个新的三元组，去重b c才有意义，因为未找到一个新的三元组，与b、c重复的元素也会不满足找到一个新的三元组的条件，已经实现去重
3、b、c去重
while(left < right && nums[left] == nums[left+1]) left++; //去重b
while(left < right && nums[right] == nums[right-1]) right–; //去重

双指针法代码实现

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > 0) break;

            if(i > 0 && nums[i] == nums[i-1]){//去重a，为啥不用while
                continue;
            }

            int left = i+1, 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++; //去重b
                    while(left < right && nums[right] == nums[right-1]) right--; //去重c

                    left++;
                    right--;
                }
            }
        }

        return result;
    }
};

18. 四数之和

问题关键信息：

1. 与15. 三数之和相似，再套一层循环
2. 四数之和要等于目标值，而不再是固定的0

二、双指针法思路：
1、先对数组排序，有序的数组是使用双指针的基础（因为只需要得到三元组的值，而不是下标）
2、第一个数通过依次遍历数组，得到a=nums[i]；左右指针从后面的序列的首尾两端向中间遍历，left = i-1、right = nums.size()-1;
3、如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，所以right下标就应该向左移动，使三数之和减小；如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，使三数之和增大，直到left与right相遇为止。
剪枝去重：
1、a去重——
if(nums[i] > target && nums[i] >= 0) break; //target, nums[i] >= 0否则其后的元素可能为负数，相加后会变小
2、b去重——
if(j > i+1 && nums[j] == nums[j-1]){continue; }//j > i+1：遍历的第一个元素不用去重
if(nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) break; //nums[i] + nums[j] >= 0否则其后的元素可能为负数，相加后会变小

双指针法代码实现

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        int left, right;
        for(int i = 0; i < nums.size();i++){
            if(nums[i] > target && nums[i] >= 0) break; //target, nums[i] >= 0否则其后的元素可能为负数，相加后会变小

            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }

            for(int j = i+1; j < nums.size(); j++){
                if(nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) break; //nums[i] + nums[j] >= 0否则其后的元素可能为负数，相加后会变小

                if(j > i+1 && nums[j] == nums[j-1]){//j > i+1：遍历的第一个元素不用去重
                    continue;
                }

                left = j+1; right = nums.size()-1;

                while(left < right){
                    if((long)nums[i] + nums[j] + nums[left] + nums[right] < target){
                        left++;
                    }
                    else if((long)nums[i] + nums[j] + nums[left] + nums[right] > target){
                        right--;
                    }
                    else{
                        result.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        while(left < right && nums[left] == nums[left+1]) left++;
                        while(left < right && nums[right] == nums[right-1]) right--;

                        left++;
                        right--;
                    }
                }
            }
        }

        return result;
    }
};