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

发布时间:2024年01月17日

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

454.四数相加II

问题关键:

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

思路:

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

解题步骤:

  1. 首先定义 一个unordered_map,key放a和b两数之和,value 放a和b两数之和出现的次数。
  2. 遍历大A和大B数组,统计两个数组元素之和的相反数以及出现的次数,放到map中。
  3. 定义int变量result ,用来统计 a+b+c+d = 0出现的次数。
  4. 在遍历大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;
    }
};
文章来源:https://blog.csdn.net/heitong_fu/article/details/135657038
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。