代码随想录算法训练营第七天|454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

454.四数相加II

暴力算法就是4层for循环遍历4个数组中每个元素，找到和为0的元组，时间复杂度为$O(n^4)$.
可以利用哈希法，用两层for循环遍历出两个数组中元素和的情况，key为和，value为和出现的个数，使得时间复杂度降为$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;
        int result = 0;
        for (int n1 : nums1) {
            for (int n2 : nums2) 
                map[n1 + n2]++;
        }

        for (int n3 : nums3) {
            for (int n4 : nums4) {
                auto iter = map.find(-n3 - n4);
                if (iter != map.end())
                    result += iter->second; 
            }
        }
        return result;
    }
};

383. 赎金信

1. 用数组形式的哈希表来记录magazine当中字母的个数
2. 将ransomNote中的字母与哈希表比对，如果少于要求，返回false。

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

        for (char c : ransomNote) {
            if ((--map[c - 'a']) < 0)
                return false;
        }
        return true;
    }
};

15. 三数之和

输出的是值，不是下标，同时值对应的下标不能相同。也就是说有去重的要求。
首先对数组进行排序，方便之后的去重操作。

哈希法

两层for循环来遍历a和b，并在a和b之间查找所需要的c是否存在。
首选考虑a的去重，是向前去重还是向后去重？向前去重的意思是这个元素之前已经判断过了，因此要去重，向后去重会把b的元素给挤掉，因此这里肯定使用向前去重。
然后考虑b的去重，也是向前去重，但是和b相同的元素可以出现两次，这是考虑到c是在a和b之间找出来的，c可能出现和b相同的情况。
最后还要对找到的c进行去重，将其从set中剔除。(这一点非常难记得）。

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) {
            unordered_set<int> set;
            // 对a进行剪枝
            if (nums[i] > 0)
                return result;
            // 对a去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            for (int j = i + 1; j < nums.size(); ++j) {
                // 对b去重
                if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]) 
                    continue;
                int c = -nums[i] - nums[j];
                // 对c剪枝
                if (c < nums[i])
                    continue;
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c); // 对c进行去重
                }                    
                else 
                    set.insert(nums[j]);
            }
        }
        return result;
    }
};

双指针法

一层for循环遍历元素a，在剩余集合首尾设置双指针，当三数之和大于0，尾指针收缩，当三数之和小于0，首指针收缩。
a的去重考虑和哈希法一样，选择向前去重，以免挤掉b。
b和c的去重和哈希法不一样，逻辑是当找到三数之和等于0的时候向后去重。

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) {
            // 对a进行剪枝
            if (nums[i] > 0)
                return result;
            // 对a去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int 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]});
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

18. 四数之和
两层for循环遍历a+b的值，然后用和三数之和相同的双指针。
但是要注意剪枝操作有区别。

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) {
            // 对a进行剪枝
            if (nums[i] > target && nums[i] >= 0)
                break;
            // 对a去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            for (int j = i + 1; j < nums.size(); ++j) {
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0)
                    break;
                if (j > i + 1 && nums[j] == nums[j - 1])
                    continue;
                int left = j + 1, 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({nums[i], nums[j],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 result;
    }
};