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

第454题.四数相加II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0

将ab放在一块儿，cd放在一块儿，降低时间复杂度为O(n^2)。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> mp;
        int count = 0;
        for(int a:nums1){
            for(int b:nums2){
                mp[a+b]++;
            }
        }
        for(int c:nums3){
            for(int d:nums4){
                int target = 0-(c+d);
                if(mp.find(target)!=mp.end()){
                    count+=mp[target];
                }
            }
        }
        return count;
    }
};

思路：mp的key放的是a+b的值，value放的是这个值出现的次数。遍历c+d，并储存target值为0-（c+d)，当这个target等于a+b时，寻找到这个key值对应的value，添加到count里面。

• 时间复杂度: O(n^2)
• 空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2。

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a.

因为题目说只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int arr[26];
        for(char c:magazine){
            arr[c-'a']++;
        }
        for(char r:ransomNote){
            arr[r-'a']--;
        }
        for(int i=0; i<26; i++){
            if(arr[i]<0){
                return false;
            }
        }
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

第15题. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

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) return res;
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            // unordered_set<int> st;
            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{
                    res.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    //为了去重，如数组[-2,-1,-1,-1,1,1,1]这种，left和right需要持续向中间移动。
                    while(left<right && nums[right]==nums[right-1]) right--;
                    while(left<right && nums[left]==nums[left+1]) left++;
                    left++;
                    right--; //注意这两行不能省去，否则导致时间超过
                }
            }
        }
        return res;
    }
};

• 时间复杂度: O(n^2)
• 空间复杂度: O(1)

a的去重

说到去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]

a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。

但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同？为了防止i把left的值替代，所以要对比nums[i] 与 nums[i-1]。

b与c的去重

while(left<right && nums[right]==nums[right-1]) right--;
while(left<right && nums[left]==nums[left+1]) left++;

两数之和 就不能使用双指针法，因为1.两数之和 (opens new window)要求返回的是索引下标， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。

如果1.两数之和 (opens new window)要求返回的是数值的话，就可以使用双指针法了。

第18题. 四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        for(int k=0; k<nums.size(); k++){
            if(nums[k]>target && nums[k]>=0) break;
            if(k>0 && nums[k]==nums[k-1]) continue;
            for(int i=k+1; i<nums.size(); i++){
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) break;
                if(i>k+1 && nums[i]==nums[i-1]) continue;
                int left = i+1;
                int right = nums.size()-1;
                while(left<right){
                    if((long) nums[k]+nums[i]+nums[left]+nums[right] > target){
                        right--;
                    }else if((long) nums[k]+nums[i]+nums[left]+nums[right] < target){
                        left++;
                    }else{
                        res.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        while(left<right && nums[right]==nums[right-1]) right--;
                        while(left<right && nums[left]==nums[left+1]) left++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
    }
};

• 时间复杂度: O(n^3)
• 空间复杂度: O(1)

与前一道题对比，需要注意的是：

1. 需要添加long，对比target

2. 由于负数会越加越小，所以不可以用第一个数与target对比。但是如果target和第一个数都大于0，则可以对比。

3. 当前两个数都大于target（且都大于0）时，则可以直接continue该循环。