代码随想录第六天|哈希-续

454.四数相加2

自写：
把前两个数组的组合出的和，用map1记录对应的出现次数，同理，后两个数组的组合出的和也记录出现次数。首先遍历map1，则和为0的情况总数为:map1[key]*map2[-key].

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> mp1,mp2;
        for(int i = 0; i< nums1.size(); i++){
            for(int j = 0; j < nums2.size(); j++){
                mp1[nums1[i]+nums2[j]]++;
            }
        }
        for(int i = 0; i< nums1.size(); i++){
            for(int j = 0; j < nums2.size(); j++){
                mp2[nums3[i]+nums4[j]]++;
            }
        }
        int sum = 0;
        for(const pair<int,int>& p: mp1){
            int value = p.first;
            sum += (p.second * mp2[-value]);
        }
        return sum;
    }
};

383.赎金信

简单哈希

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

15.三数之和

(没想出来）

哈希法

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        for(int i = 0; i < nums.size(); i++){
            // 如果最小的左端点都大于0，那么三元组不可能=0
            if(nums[i] > 0) break;
            // i是枚举的第一个数，所以当有连续相同的第一个数时，则跳过
            if(i > 0 && nums[i] == nums[i-1]) continue;
            unordered_set<int> s;
            for(int j = i+1;j<nums.size(); j++){
                // 假设有三个连续的数，如果枚举的j为连续的第一个数时，则右端点还可以为连续的第二个数
                // 如果枚举的j为连续的第二个数，那么右端点可以为连续的第三个数
                // 如果只使用nums[j]==nums[j-1]这种情况，那么[0,0,0]过不去，因为那种条件只会让0充当第一个数
                if(j > i + 2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2]) continue;
                int d = -(nums[i]+nums[j]);
                if(s.find(d)!=s.end()){
                    res.push_back(vector<int>{nums[i],nums[j],d});
                    s.erase(d);
                }
                else{
                    s.insert(nums[j]);
                }
            }
        }
        return res;
    }
};

双指针
解释在注释中

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] > 0) break;
            if(i > 0 && nums[i] == nums[i-1]) continue;
            int left = i + 1, right = nums.size() - 1;
            int target = -nums[i];
            // left不能等于right，因为两个数不能重复
            while(left < right){
                // n[i]+n[left]+n[right] < 0 -> n[left]+n[right] < -n[i] = target
                if(nums[left]+nums[right] < target) left++;
                else if(nums[left]+nums[right] > target) right--;
                else{
                    res.push_back(vector<int>{nums[i],nums[left],nums[right]});
                    // 到此条件的时候，如果有多个相同的nums[left],那么当前left肯定是第一个，所以判断的时候必然是判断left+1是否和当前的相同，相同则跳过，同理，右边是设置right-1（去重）
                    while(left < right && nums[left] == nums[left+1]) left++;
                    while(left < right && nums[right] == nums[right-1]) right--;
                    // 上面两个循环结束后，left和right会停在连续相同数的边界点,left为最后一个,right为第一个，所以要继续让指针移动
                    left++, right--;
                }
            }
        }
        return res;
    }
};

18.四数之和(难)

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;
        for (int i = 0; i < nums.size(); i++) {
            // 如果nums[i]
            // 大于target,但是两者都为负数，那么还是可以满足条件的，所以需要前者不为复数
            if (nums[i] > target && nums[i] >= 0)
                break;
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            for (int j = i + 1; j < nums.size(); j++) {
                // 这里注意，如果前两个数都为负数，且target也为负数，那么之后的两个数为负数的情况下也是可能和为target的，所以必须前两个数的和不为负才可以直接跳过
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0)
                    break;
                if (j > i + 1 && nums[j] == nums[j - 1])
                    continue;
                int 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 {
                        res.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 res;
    }
};