代码随想录第7天|LeetCode454.四数相加2，LeetCode383.赎金信，LeetCode15.三数之和，LeetCode18.四数之和

LeetCode454.四数相加2

题目链接：454. 四数相加 II - 力扣（LeetCode）

思路：

本题是使用哈希法的经典题目，跟三数之和，四数之和不一样（他们不适合用哈希法）：三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的。

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。（难度提升：不包含重复的四元组）

总结一下：多数相加都可以用map，就是分为两个部分，相加等于多少找对应的键值就行。

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

LeetCode383.赎金信

题目链接：383. 赎金信 - 力扣（LeetCode）

思路：

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

• 第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思”  这里说明杂志里面的字母不可重复使用。

• 第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要。

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

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int r[26] = {0};
        if(ransomNote.size() > magazine.size()) return false;
        //统计magazine杂志上的字符数量，放入r数组中
        for(int i = 0;i < magazine.size();i++) {
            r[magazine[i] - 'a']++;
        }
        //将ransomNOTE中出现字符依次在数组r中减去，如果数组有小于0就代表ransomNote和magazine不匹配
        for(int i = 0;i < ransomNote.size();i++) {
            r[ransomNote[i] - 'a']--;
        }
        for(int i = 0;i < 26;i++) {
            if(r[i] < 0) return false;
        }
        return true;
    }
};

总结一下，当我们要求什么在什么里面用哈希，怎么用呢，如果是次数类的可以先加后减判断其小于0就不在，反之则在。

LeetCode15.三数之和

题目链接：Loading Question... - 力扣（LeetCode）

思路：

这题在前文提到过并不适合用哈希法来解决，因为去重操作很多。

应该用双指针法：

拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        //排序后可以用双指针法来依次寻找a+b+c=0的情况
        sort(nums.begin(),nums.end());
        //a = nums[i].b=nums[j],c=nums[k]
        for(int i = 0;i < nums.size();i++) {
            //排序后如果第一个元素>0那么找不出a+b+c=0的数了
            if(nums[i] > 0) {
                return result;
            }
            if(i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left) {
                if(nums[i] + nums[left] + nums[right] > 0) right--;
                else if(nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i],nums[left],nums[right]});
                    //去重逻辑应该放在找到1个三元组之后，对b，c去重
                    while(right > left && nums[right] == nums[right - 1]) right--;
                    while(right > left && nums[left] == nums[left+1]) left++;
                    //找到答案时双指针同时收缩
                    right--;
                    left++;   
               }
            }
        }
         return result;
    }
};
    

LeetCode18.四数之和

题目链接：18. 四数之和 - 力扣（LeetCode）

思路：

四数之和，和三数之和是一个思路，都是使用双指针法, 基本解法就是在三数之和的基础上再套一层for循环。

但是有一些细节需要注意，例如： 不要判断nums[k] > target 就返回了，三数之和 可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

三数之和的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

对于三数之和双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。

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 && nums[k] >= 0) {
                break;//最后用return统一返回
            }
            //对nums[k]去重
            if(k > 0 && nums[k] == nums[k-1]) {
                continue;
            }
            for(int i = k + 1;i < nums.size();i++) {
                //2级剪枝处理
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >=0) {
                    break;
                }
                //对nums[i]去重
                if(i > k + 1 && nums[i] == nums[i-1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while(right > left) {
                    //nums[k] + nums[i] + nums[left] + nums[right] >target会溢出
                    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 {
                        result.push_back(vector<int>{nums[k], 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;
    }
};