代码随想录训练营Day6:哈希表02

1.454四数相加

思路：用一个哈希表存储对应的前面两数之和，哈希表对应的每个分量分别为<累加和,频数>,对于后面来说虽然得到的效果是一样的，但是对应的是不同的（i,j）对应的下标，所以后面存的是频数，比如（-1,0）（-1，-2）得到的累加和为-2的有两种分别是（-1-1）和（0-2）。后面的第二个循环就是找到是否含有对应的一个累加和的值，因为a+b = 0 =>a = 0-b。所以我们在第二个双重循环就是寻找0-b即在前面的哈希表中找值。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> sumA;//a+b的和，对应的相加和的次数
        for(auto a:nums1){
            for(auto b:nums2){
                sumA[a+b]++;
            }
        }
        int ret = 0;//代表的是存在的次数
        for(auto c:nums3){
            for(auto d:nums4){
                if(sumA.find(0-c-d)!=sumA.end()){
                    ret += sumA[0-c-d];
                }
            }
        }
        return ret;
    }
};

2.赎金信

思路：由于题目规定了数据的范围只有小写字母，所以直接用一个辅助数组来进行统计即可。如果存在某一个字符对应的频数小于0，代表ransomNote的比magazine多，即不满足。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int numa = ransomNote.size();
        int numb = magazine.size();
        cout<<numa<<" "<<numb<<endl;
        if(numa>numb){
            return false;
        }
        int strs[26];
        for(char ch:magazine){
            strs[ch-'a']++;
        }
        for(char ch:ransomNote){
            strs[ch-'a']--;
        }
        for(int i=0;i<26;i++){
            if(strs[i]<0){
                return false;
            }
        }
        return true;
    }
};

3.三数之和

思路：题目说明了不需要考虑顺序，所以我们最开始就对数据进行排序，然后考虑使用一个双指针来进行操作。

注意事项：nums[i]代表最小的数，nums[left]代表的是中间那个数，nums[right]代表的是最大的数。

·如果nums[i]大于0，代表从这之后的所有数全大于0，累加和必大于0，不需要再判断了，直接返回即可。

·如果nums[i]==nums[i-1]代表的是就算生成了累加和为0的，也是和前面的一样，可以舍去这个，进行下一步操作。比如-2-1-1-1-000122233345,i=1和2所对应的结果其实是没啥区别的。

·双指针里面的操作，对于等于部分的一些注意事项，为什么要有两个判断条件呢，因为可能会存在nums[left]==nums[right]的情况出现，那么一直移动的过程中会出现left>=right,不满足条件。

 ·里面两个小的while循环的作用是移动重复的部分，因为我们在最后的结果中是没有重复的。

 ·最后两个left++,right--因为我们已经知道了前面的那些都是满足了累加和为0，我们在这个里面不一定只有一个累加和为0的情况。如果只移动left（会导致此时的累加和大于0）或者right（累加和小于0），所以需要同时移动，然后在进行判断，也可以只移动一个，但是就需要多进一次循环判断了。

另外一种哈希表的方法属于时间相对比较长，就不考虑了。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> ret;
        int n = nums.size();
        for(int i = 0;i<n;i++){
            if(nums[i]>0){
                return ret;//代表此时对应的值全部都大于0，那么后面一定不会出现可能出现的值了
            }
            if(i>0&&nums[i]==nums[i-1]){//代表这个和前面那个是重复的，不需要接下去了
                continue;
            }
            int left = i+1;
            int right = n-1;
            //双指针的方法
            while(left<right){
                int sum = nums[i]+nums[left]+nums[right];
                if(sum>0){
                    right--;
                }else if(sum == 0){//需要注意的是不止有一个，还可以接着找
                    ret.push_back(vector<int>{nums[i],nums[left],nums[right]});
                    while(left<right&&nums[left]==nums[left+1])left++;
                    while(left<right&&nums[right]==nums[right-1])right--;
                    left++;
                    right--;
                }else{
                    left++;
                }
            }
        }
        return ret;
    }
};

4.四数之和

思路：借鉴三数之和，但是会比三数之和稍微难点。

不同点：

        1.多加了一层for循环。

        2.由于这个里面的target不是0，而是一个任意数，所以不能沿袭前面的那种剪枝操作，需要添加新的约束，即确保这个前n个数之和要大于目标值且大于等于0，那么后面4-n个数之和一定是大于target的，可以进行剪枝操作。

        3.四个数的和得用long存储，因为可能会出现超出范围的情况。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ret;
        int n = nums.size();
        if(n<4){
            return ret;
        }
        sort(nums.begin(),nums.end());
        for(int k = 0;k<n;k++){
            if(nums[k]>target&&nums[k]>=0){
                break;//其实这里也可以用return，但是为了统一全部用reak，后面一起返回
            }
            if(k>0&&nums[k]==nums[k-1]){//代表的是有重合的，不需要再计算这一个了
                continue;
            }
            for(int i = k+1;i<n;i++){
                if(nums[k]+nums[i]>target&&nums[i]+nums[k]>=0){
                    break;//此时两数之和已经大于target且大于等于0了，那后面的数一定为正数，超过了
                }
                if(i>k+1&&nums[i]==nums[i-1]){//有重复的就不需要这个了
                    continue;
                }
                int left = i+1;
                int right = n-1;
                while(left<right){
                    long sum = nums[k]+nums[i];
                    sum += nums[left];
                    sum += nums[right];
                    if(sum>target){
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        ret.push_back(vector<int>{nums[k],nums[i],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 ret;
    }
};