算法训练day7|454. 四数相加 II|383. 赎金信|15. 三数之和|18. 四数之和

一、454. 四数相加 II

1. 暴力解（力扣上超时ac不了）

时间复杂度O(n^4)，还是非常大的

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //暴力解
        int result = 0;
        int n = nums1.size();
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    for(int l=0;l<n;l++){
                        if(nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0){
                            result++;
                        }
        }
        }
        }
        }
        return result;
    }
};

2. 哈希法

四个变为两个加两个，时间复杂度为O(n^2)，小了很多

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //用哈希法
        unordered_map<int,int>map;//map的初始化应该也是0
        for(int a : nums1){
            for(int b : nums2){
                map[a+b]++;
            }
        }
        int count = 0;
        for(int c : nums3){
            for(int d : nums4){
                if(map.find(-(c+d)) != map.end()){
                    // count++;//不是count++是因为前面的map的value不一定只为1
                    count += map[-(c+d)];
                }
            }
        }
        return count;
    }
};

二、383. 赎金信

简单题不多说了，时间复杂度O(m+n)，如果不用map，直接用数组，因为都是小写字母，和前面242. 有效的字母异位词 这一题很类似

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

三、15. 三数之和

1. 哈希法

并不是哈希法不能做，而是因为这题是需要去重的，三元组只要数相同，顺序是可以不同的，这个去重的逻辑在于，得到未去重的三元组集合时，去重并不是很好实现。

2. 排序、双指针

很乱，主要还是去重的逻辑很重要

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>>result;
        int size = nums.size();
        for(int i=0;i<size;i++){
            int L=i+1,R=size-1;
            //i去重
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }
            if (nums[i] > 0) {//这一句是剪枝，无伤大雅，稍微减少一些开销
                return result;
            }
            while(L<R){
                if(nums[i] + nums[L] + nums[R] > 0){
                    R--;
                }
                else if(nums[i] + nums[L] + nums[R] < 0){
                    L++;
                }
                else{
                    result.push_back(vector<int>{nums[i],nums[L],nums[R]});
                    L++;
                    R--;
                    //在进入下一个循环前，对R和L进行去重，如果相等则可以收缩一次
                    while(L<R && nums[R] == nums[R+1]){
                    R--;
                }
                    while(L<R && nums[L] == nums[L-1]){
                    L++;
                }
                }                
            }
        }
        return result;
    }
};

四、18. 四数之和

整体逻辑和前面三数之和是一样的，外面多接一层循环，把i和j相加作为同一个，时间复杂度O(n^2)。

同时在提交的时候有一些测试用例过不了，需要用if判断来剪枝，还有就是int相加会溢出但是target并不会溢出，于是在判断是讲相加的数强制转换为long即可

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>result;
        int size = nums.size();
        //还是要有序数组
        sort(nums.begin(),nums.end());
        if(target <=0 && nums[0]>0){//剪枝
            return result;
        }
        for(int i=0;i<size-3;i++){
            //剪枝
            if(i>0 && nums[i] == nums[i-1]){
                continue;
            }
            for(int j=i+1;j<size-2;j++){
                if(j>i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                int tmp = nums[i] + nums[j];//转化为三数之和
                int L=j+1, R=size-1;
                while(L<R){
                    if((long)nums[L]+nums[R]+tmp > target){
//(long)先将nums[L]转为long类型，后面相加的时候，剩余的int类型数会自动转化为long，防止溢出
    
                        R--;
                    }else if((long)nums[L]+nums[R]+tmp < target){
                        L++;
                    }else{//相等时 添加答案并去重
                        result.push_back(vector<int>{nums[i],nums[j],nums[L],nums[R]});
                        L++;
                        R--;
                        //去重
                        while(L<R && nums[R] == nums[R+1]){
                            R--;
                        }
                        while(L<R && nums[L] == nums[L-1]){
                            L++;
                        }
                    }
                }
            }
        }
        return result;
    }
};

五、总结

对于三数之和、四数之和这两个题的双指针用法很关键，for循环用来遍历，双指针在有序数组中根据L后移增大和，R左移减小和，从而达到目的。同时，去重的操作很有技巧，找到目标后，下一个数如果与当前数相同，是应该跳过的。

（5小时）