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

题目链接：454. 四数相加 II

思路

首先将a数组和b数组进行组合即（a+b），存入map容器中，让target = 0-（c+d），再在容器中遍历是否含有target，若含有，计数器就会增加（a+b）出现的次数【注意：不是+1，因为a+b不同组合可能会出现相同数值】，最后返回count的值。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
    std::unordered_map<int,int>map;
    int count = 0;
    for(int num11:nums1){
        for(int num22:nums2){
            map[num11 + num22]++;
        }
    }
    for(int num33:nums3){
        for(int num44:nums4){
            int target = 0-(num33+num44);
            if(map.find(target)!=map.end()){
                count += map[target];
            }
        }
    }
    return count;
    }
};

题目链接：383. 赎金信

思路

注意在最后判断哈希表中的元素时，一定是判断<0，返回false，而不能判断>=0，因为一旦是判断>=0，在执行第一次循环时，若出现重复字符，则会直接返回true，不会再继续遍历下去。

。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26] = {0};
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        for(int i =0 ;i<magazine.size();i++){
            hash[magazine[i]-'a'] ++;
        }
        for(int i =0 ;i<ransomNote.size();i++){
            hash[ransomNote[i]-'a'] -= 1;
            if(hash[ransomNote[i]-'a'] < 0){
                return false;
            }
        }
        return true;
    }
};

题目链接：15. 三数之和

思路

步骤一：将数组进行排序，若每个元素均大于0。则直接返回result；
步骤二：将结果去重，判断数组前一个元素是否和当前元素值相同，若相同则continue（保证不会取到相同结果）；
步骤三：将三数相加，若小于0，则指针“left”前移，若大于0，则指针“right”后移；
步骤四：若结果为0，则仍然需要对left和right进行去重操作，最终将结果push_back到容器中返回结果。

continue：中止本次循环，开始下一次循环。

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){
                return result;
            }
            if(i>0&&nums[i] ==nums[i-1]){  //num[0]=-1时，结果已经包含了{-1，-1,2}这组结果了，因此遍历到第二个-1时，结果重复
                continue;
            }
            int left = i+1;
            int right = nums.size()-1;
            while(right > left){
                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]});
                   
                    while(right > left&&nums[right]==nums[right-1])right--;
                    while(right > left&&nums[left]==nums[left+1])left++;

                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

题目链接：18. 四数之和

思路

与三数之和不同的地方之处在于多了一个新的指针，要对新指针进行剪枝和去重，第一重剪枝，只要k>target/4，那么数组后面元素肯定不符合条件，直接break。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>result;
        sort(nums.begin(),nums.end());
        for(int k = 0;k<nums.size();k++){
            if(nums[k] >target/4){    // 剪枝处理
                break;
            }
            if(k>0&&nums[k]==nums[k-1]){    // 对nums[k]去重
                continue;
            }    
            for(int i =k+1;i<nums.size();i++){
                if(nums[i]+nums[k]>target&&nums[i]+nums[k]>=0){  // 2级剪枝处理
                    break;
                }
                if(i>k+1&&nums[i]==nums[i-1]){    // 对nums[i]去重
                    continue;
                }
                int left = i+1;
                int right = nums.size()-1;
                while(right>left){
                    if(nums[i]+nums[k]+nums[left]+nums[right]>target){
                        right--;
                    }
                    else if(nums[i]+nums[k]+nums[left]+nums[right]<target){
                        left++;
                    }
                    else {
                        result.push_back(vector<int>{nums[i],nums[k],nums[left],nums[right]});
                        while(right>left&&nums[left]==nums[left+1]) left++;
                        while(right>left&&nums[right]==nums[right-1]) right--;
                        left++;
                        right--;
                    }
                }
            }
            
        }
        return result;
    }
};