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

454.四数相加II

454. 四数相加 II - 力扣（LeetCode）

有a,b,c,d四个数组，遍历a和b两个数组，得到a+b，将这个值存在unordered_map中（无序），其中key存a+b，value存出现的次数

再遍历c和d两个数组，若0-c-d在map中，则说明出现了a+b+c+d=0，value为这个值的个数

补充：

访问map的方式：

• 仿照数组map[i]=j（i为key值，j为value值）
• 设置迭代器auto iter= map.find(target - nums[i]);此时iter->first为key值，iter->second为value值

遍历vector的方式：

• for (int i = 0; i < nums1.size(); i++)
• for (int i : nums1)

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int>map;
        //求a+b并放入map中-无序且不重复
        for (int i = 0; i < nums1.size(); i++) {
            for (int j = 0; j < nums2.size(); j++) {
                map[nums1[i] + nums2[j]]++;
            }
        }
        int sum = 0;
        //遍历c+d，判断0-c-d是否在map中
        for (int i : nums3) {
            for (int j : nums4) {
                if (map.find(0 - i - j)!=map.end()) {
                    sum += map[0 - i - j];
                }
            }
        }
        return sum;
    }
};

383. 赎金信

383. 赎金信 - 力扣（LeetCode）

与242. 有效的字母异位词 - 力扣（LeetCode）相似

先把magzine出现的元素放入数组哈希表中，数组由26个小写字母组成，其值为元素个数，操作为++

再把ransomnote中的元素在哈希表中做--操作

遍历哈希表，如果出现负数则说明不能构成，如果没有负数则可以构成

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26] = { 0 };
        //把magazine存在hash中
        for (int i = 0; i < magazine.size(); i++) {
            hash[magazine[i] - 'a']++;
        }
        //ransomNote--
        for (int j = 0; j < ransomNote.size(); j++) {
            hash[ransomNote[j] - 'a']--;
        }
        for (int p = 0; p < 26; p++) {
            if (hash[p] < 0) {
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

15. 三数之和 - 力扣（LeetCode）

本题首先使用双指针法，将原有数组排序后用“i”遍历整个数组，i之后设置一个left指针，在数组最后设置一个right指针，求i+left+right，如果大于0则将right左移，如果小于0则将left右移，直到找到=0

此题的重点在于去重，即将i,left,right分别去重

• 去重i—是遍历整个数组的时候不要遍历同样的数字，由于整个数组是有序的，因此只需要比较“i”和前一个数字是否相同即可去重
• 去重left和right是在找到一组三元组之后，消除与这个三元组元素相同的重复项
• 去重left—如果left和left+1相同，则将left++
• 去重right—如果right和right-1相同，则将right--

注意：排序可以用sort(nums.begin(), nums.end());

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int left, right;
        vector<vector<int>> result;
        //给nums排序
        sort(nums.begin(), nums.end());
        //剪枝
        if (nums[0] > 0) {
            return {};
        }
        //遍历数组
        for (int i = 0; i < nums.size(); i++) {
            //将i去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            //初始化left,right
            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({ nums[i],nums[left],nums[right] });
                    //将left,right去重,注意是对找到的三元组去重
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

18. 四数之和 

18. 四数之和 - 力扣（LeetCode）

与三数之和不同的是，本题相加为target，可正可负，不可以延续三数之和的剪枝操作“if(nums[0]>0)continue”为“if(nums[0]>target)continue”，因为正数相加越来越大，如果nums[0]>target说明相加的数不可能出现等于target（target>0）的情况，但是负数相加可能会出现越来越小，比如nums[0]=-3,nums[1]=-1,target=-4，此时nums[0]>target但nums[0]+nums[1]=target

本题是三数之和的延申，在三数之和的基础上增加了一层循环k，注意剪枝和去重操作即可

这里有一个溢出错误：

//此处需要强制转换为long，才会避免溢出错误
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++;
                    }

完整代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result = {};
        long k, i, left, right;
        //对数组排序
        sort(nums.begin(), nums.end());
        //遍历k
        for (k = 0; k < nums.size(); k++) {
            //剪枝,正数才符合
            if (nums[0] >= 0 && target >= 0 && nums[0] > target) {
                return {};
            }
            //去重,当前的K和前一个相同
            if (k > 0 && nums[k] ==nums[k - 1]) {
                continue;
            }
            //三数之和的部分
            for (i = k + 1; i < nums.size(); i++) {
                //剪枝
                if (nums[0] + nums[1] > target && nums[0] >= 0 && nums[1] >= 0 && target >= 0) {
                    return {};
                }
                //去重
                if (i > k+1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                left = i + 1;
                right = nums.size() - 1;
                while (left <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({ nums[k],nums[i],nums[left],nums[right] });
                        //left和right去重
                        while (left<right&&left >0&& nums[left] == nums[left +1]) {
                            left++;
                        }
                        while (left<right&&right < nums.size() - 1 && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};