day7 第454题.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

第454题.四数相加II

思路：

• 在本题中需要使用map，key存放A和B的元素和，value存放相同的和出现的次数
• 将A和B的元素相加放在map中，还有元素和出现的次数
• 在遍历C和D时，在map中寻找0-（c+d）是否出现，如果出现过，count加上map中相应的次数
• 最后返回count

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> umap;
        //遍历A和B将每一个元素和都放在map中
        for(int a:nums1){
            for(int b:nums2){
                //key存放a+b value存放出现的次数
                //表示对值为a+b的进行计数
                umap[a+b]++;
            }
        }
         统计a+b+c+d = 0 出现的次数
        int count =0;
        //遍历nums3和nums4中的元素和  在map中是否找到和为0的元素
        for(int c:nums3){
            for(int d:nums4){
                //如果找到count就加上等于0-(c+d)的次数
                if(umap.find(0-(c+d)) !=umap.end()){
                    count+=umap[0-(c+d)];
                }
            }
        }
        return count;
    }
};

383. 赎金信

本题和前面写过的242.有效的字母异位词相似，把magazine中的字母出现次数，存放在哈希表（数组）中，在遍历ransomNote时，出现字母在哈希表中–操作，最后如果哈希表中出现<0，说明ransomNote存在的字母在magazine不存在

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26]={0};
        //题目中只说ransomNote 能不能由 magazine 里面的字符构成。
        //如果ransomNote大  且每一个字母不可重复使用 那就说明不能构成
        if(ransomNote.size()>magazine.size()){
            return false;
        }
        for(int i=0;i<magazine.size();i++){
            //将magazine出现的26个字母加计数
            record[magazine[i]-'a']++;
        }
        for(int j=0;j<ransomNote.size();j++){
            //将ransomNote出现的26个字母减计数
            record[ransomNote[j]-'a']--;
        }
        //如果哈希表中存在小于0的元素  就说明ransomNote里出现的字符，magazine没有
        for(int k=0;k<size(record);k++){
            if(record[k]<0){
                return false;
            }
        }
        return true;
    }
};

第15题. 三数之和

使用哈希表，去重比较难，采用双指针的方法，一个for遍历整个数组，left指针指向i+，right指向数组的最末端
关键：数组排序，去重时直接跟前面一个元素进行比较，如果相等就直接跳过

• 如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
• 如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result; //用来存放最后的结果数组
        sort(nums.begin(),nums.end());  //将数组排序
        int left;
        int right=nums.size()-1;
        for(int i=0;i<nums.size();i++){
            //如果第一个元素>0 就不会存在和=0的情况
            if(nums[i]>0){
                break;
            }
            //a去重 出现和前面元素相同的就跳过这次循环
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }
            left=i+1;
            right=nums.size()-1;
            while(left<right){
                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]});
                    //b和c进行去重 出现和前面或者后面相同的  就持续的++或者--
                    while(right>left && nums[right]==nums[right-1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    //找到答案时 双指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

第18题 四数之和

本题和三数之和相似

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

• 四数之和两层for循环nums[k] +
  nums[i]为确定值（相当于三数中的第一个for循环），依然是循环内有left和right下标作为双指针，找出nums[k] +nums[i] + nums[left] + nums[right] == target的情况

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(target>0 && nums[k]>0 && nums[k]>target){    //一级剪枝
                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){
                    //相加过大 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 {
                        result.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--;
                        }

                        right--;
                        left++;
                    }
                }
            }
        }
        return result;

    }
};