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

454.四数相加II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路：用哈希表map可以非常巧妙地解决。类比之前那道两数之和，可以让nums1和nums2为一组，设和为a，记录进map，键为a，值为a出现的次数，然后让nums3和nums4为一组，设和为b，寻找map里是否存在-b，如果存在则相当于找到了a+b=0即nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0，值的个数相加。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int sum = 0;
        unordered_map<int,int> map;
        for (int i = 0; i < nums1.size(); i++) {
            for (int j = 0; j < nums2.size(); j++) {
                auto iter = map.find(nums1[i] + nums2[j]);
                if (iter != map.end())
                    iter->second++;
                else
                    map.insert(pair<int,int>(nums1[i]+nums2[j], 1));
            }
        }

        for (int i = 0; i < nums3.size(); i++) {
            for (int j = 0; j < nums4.size(); j++) {
                auto iter = map.find(0 - (nums3[i] + nums4[j]));
                if (iter != map.end())
                    sum += iter->second;
            }
        }
        return sum;
    }
};

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

提示：
1 <= ransomNote.length, magazine.length <= 105
ransomNote 和 magazine 由小写英文字母组成

思路：用哈希法，哈希表的话可以用数组，创建一个大小为26的数组，用来存放每个小写字母出现的次数，也可以用map，由于之前 有效的字母异位词这题我用的是数组，这题我就用map写了。键存放字母，值存放出现的频率

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<int,int> map; 
        for (int i = 0; i < magazine.size(); i++) {
            auto iter = map.find(magazine[i]);
            if (iter != map.end()) {
                iter->second++;
            } else {
                map.insert(pair<int,int>(magazine[i], 1));
            }
        }

        for (int i = 0; i < ransomNote.size(); i++) {
            auto iter = map.find(ransomNote[i]);
            if (iter != map.end()) {
                iter->second--;
                if (iter->second < 0)
                    return false;
            } else {
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

思路：使用双指针法，如果用哈希法的话会比较麻烦，在传入了多个数组的情况下用哈希法方便一点。一共三个数，一个用于遍历数组，另外两个数用指针表示，指针left指向最左边，right指向最右边。注意去重的操作。

我这里专门解释一下为什么是三数之和小于0时left++，三数之和大于0时right–
初始时最右边的数加最左边的数如果大于0，说明最右边的数加所有左边的数都会大于0，那么此时只能让right--，即让最右边的数左移一位变小一点。 而最右边的数向左移动一位后，假如依旧和大于0，同上，只能移动right--，而假如和变成小于0了，说明最左边的数加上当前的右边界内的数都是小于0，如果让right++，那又会变成大于0的情况，所以只能移动left++，即最左边的数向右移一位，而此时如果和大于0，那么就只能right--，否则和又会小于0。 因此是大于0则right--，小于0则left++

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        if (nums[0] > 0)
            return {};
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i-1])
                continue;

            int left = i + 1;
            int right = nums.size()-1;
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] == 0) {
                    result.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 if (nums[i] + nums[left] + nums[right] > 0)
                    right--;
                else if (nums[i] + nums[left] + nums[right] < 0)
                    left++;
            }

        }
        return result;
    }
};

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

思路：同样用双指针法。传入了多个数组时再用哈希法，这里只是一个数组，用双指针方便。该题类似上题的解法，一共四个数，其中两个数用于遍历数组，另外两个数用于快慢指针。

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 && (nums[i] > 0 || target > 0))
                return result;

            if (i > 0 && nums[i] == nums[i-1])
                continue;
            for (int j = i+1; j < nums.size(); j++) {
                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) {
                        result.push_back(vector<int> {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--;
                    } else 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++;
                }
            }
        }
        return result;
    }
};