代码随想录算法训练营Day7|第454题.四数相加II、383. 赎金信、第15题. 三数之和、第18题. 四数之和-CSDN博客

本题要从四个数组中分别取出一个数，满足和为0的条件，并统计满足条件元组的个数。由于本题没有要求四个数不能重复出现，因此可以利用unordered_map较为方便地实现，将四个数分为两组求和，利用map中的key记录一组数的和，用value记录和出现的次数，根据第一组和第二组求和为0的关系，利用第二组数据查找map中的第一组数据，不断累加元组个数。

算法实现：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        int result = 0;
        for (int a : nums1){
            for (int b : nums2){
                map[a + b]++; // 一步操作实现key和value地添加
            }
        }
        for (int c : nums3){
            for (int d : nums4){
                int target = 0 - (c + d);
                if (map.find(target) != map.end()){
                    result += map[target];
                }
            }
        }
        return result;
    }
};

算法分析：

先创建了一个映射map和记录元素个数的变脸result，两个for循环将nums1和nums2的和存放入map中，map(a + b)++一步操作就可以显示key和value的添加，不用在自己手动增加value的值。再利用两个for循环得到nums3和num4的各元素和，利用四元素和为0的关系，可以得到map中存放的目标值taget和nums3与num4和的关系。在map中查找目标值target，若存在则返回对应迭代器，不满足map.end()条件，result 可以增加map对应的value值。最后循环结束返回result。

注意点：

第二个for循环中result每次增加要加上map中存放key对应的value值，而不是简单+1。

383. 赎金信

题目链接

文章链接

前言：

本题与242.有效的字母异位词有些类似，不同的是242是两个字符串的组成相同，内部字符顺序不同，而本题两个字符串是交并集的关系，要满足一个字符串中的字符能够完全由另一个字符串组成，且对应的元素不能重复使用。本题使用暴力和哈希表（数组）分别进行实现。

方法一：暴力解法

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if (ransomNote.size() > magazine.size()) return false;
        for (int i = 0; i < magazine.size(); i++){
            for (int j = 0; j < ransomNote.size(); j++){
                if (ransomNote[j] == magazine[i]){
                    ransomNote.erase(ransomNote.begin() + j); // 删除ransonNote中与magazine相等的元素
                    break;
                }
            }
        }
        if (ransomNote.length() != 0){
            return false;
        }
        return true;
    }
};

使用暴力解法时，难点在于去重，比较简便的方法是控制for循环的先后顺序，先对magazine字符串进行遍历，这样之后就不用再讨论magazine元素重复的问题，再对ransomNote字符串进行遍历，满足相等条件后直接删除ransomNote中对应的字符。若最后ransomNote的长度不为0，表面该字符串中还有未删除完的字符，即表明ransomNote中的字符不能由magazin中的字符完全提供，因此返回false，反之则为true。值得一提的是，在一开始可以先进行两字符串长度的判断，想要满足题目条件，首先得满足magazine的大小比ransomNote大。

方法二：哈希法

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

本题哈希表的实现方式与有效字母异位词类似，不再过多介绍。、

第15题. 三数之和

题目链接

文章链接

前言：

在做了四数相加那题后，这道题很自然地联想到将三个数进行分组，再次利用哈希表map进行查询和记录，但是本题要求满足条件的三元组不能重复并且是在一个数组内进行操作，考虑去重操作本题使用哈希表实现较为复杂，利用双指针法进行实现。

算法实现：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++){
            if (nums[i] > 0) return result;
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 对i进行去重
            int left = i + 1;
            int 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]});
                    while (left < right && nums[right] == nums[right - 1]) right--; //对right进行去重
                    while (left < right && nums[left] == nums[left + 1]) left++; //对left进行去重
                    left++;
                    right--;//找到答案后，双指针同时收缩
                }
            }
        }
        return result;
    }
};

算法分析：

创建一个存放vector容器的vector容器result后，对数组进行排序，是重复的元素都能挨在一块，方便之后的处理。双指针的实现思路：设置一个遍历数组的i指针，left指针从i+1的位置开始向后移动，right从数组最后向前移动直到left和right相遇在这个过程中寻找满足nums[i] + nums[left] + nums[right] = 0的情况存入result中。要注意i指针、left、right的去重，在i去重后确定具体位置后再设置left指针，在去重前还要进行条件判断，不满足可以直接返回result值。

第18题. 四数之和

题目链接

文章链接

前言：

本题依然用双指针法进行实现，大体思路和三数之和类似，只是外面再靠一层循环，主要难点在于各指针的去重操作。

算法实现：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++){
            if (nums[i] > target && target > 0) break; //最后统一return
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            for (int j = i + 1; j < nums.size(); j++){
                if (nums[i] + nums[j] > target && target > 0) break;
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
                int left = j + 1;
                int right = nums.size() - 1;
                while (left < right){
                    if ((long)nums[i] + nums[j] + nums[left] + nums[right] > target) right--;
                    else if ((long)nums[i] + nums[j] + nums[left] + nums[right] < target) left++;
                    else{
                        result.push_back(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
        }
};

算法分析：

本题与三数之和不同的地方在于三数之和要求的和为0，而本题给的是一个变量target，可能存在负值的情况，因此在去重前的条件判断中，不能再简单的判断nums[i] > target的条件，还要满足target > 0的条件，内层循环j也相同，在满足nums[i]+nums[j]的条件时还要满足target > 0。