代码随想录第7天|Leetcode454 四数相加|| 、Leetcode383 赎金信、Leetcode15 三数之和、Leetcode18 四数之和

Leetcode454 四数相加||

题目链接：四数相加||

文章链接：代码随想录-四数相加

代码：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int res = 0;
        unordered_map<int,int> map;
        int s1 = nums1.size(),s2 = nums2.size(), s3 = nums3.size(), s4 = nums4.size();
        for(int i = 0; i< s1; i++)
            for(int j = 0; j < s2; j++)
                map[nums1[i] + nums2[j]]++;
        for(int i = 0; i< s3; i++)
            for(int j = 0; j < s4; j++)
                if(map.find(0-nums3[i]-nums4[j]) != map.end())
                    res += map[0-nums3[i]-nums4[j]];
        
        return res;
    }
};

思路分析

一旦涉及多个数值同时放在一起，要考虑哈希表，可以使用map数据结构。

四组数值可以分成两两一组，哈希表不能做到算法上的减法，最多只能做到优势的遍历！！

a 和b组的数全部两两加在一起放进map里，同理，c和d组两两相加，去查找map里有没有相配的即可。

Leetcode383 赎金信

题目链接：赎金信

文章链接：代码随想录-赎金信

代码：

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

思路分析

最为经典的哈希思想，就是“存储”遍历过的元素。使用空间换时间，去记录遍历过何种元素。

Leetcode15 三数之和

题目链接：三数之和

文章链接：代码随想录-三数之和

代码：

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

};

思路分析

本题难点在于“去重”，要求三元组不重合。如果使用哈希表，去重非常困难，难以掌握。

此处使用“双指针法”。

首先，将数组从小到大，排序双指针指向后面的两个元素。一次遍历数组，i指向第一个元素，后面的两个元素用双指针指向，left指向i+1，right指向len-1，根据和与0的大小关系，决定left和right的移动。

关于去重：nums【i】 == nums[i -1] && i >0 时，这个i必然是要跳过的，因为如果这个i可以的话，一定就在前一个元素就可以了；

指针的去重，只需要考虑当left、right、i相加为0时，left右移时相同的就跳过，right同理。

Leetcode18 四数之和

题目链接：四数想和

文章链接：代码随想录-四数之和

代码：

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

整体思路与三数之和，只不过是设置两层循环。去重效果差不多。