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

第一题主要是在四个数组里找数，这样简单了很多，与在一个数组里找四个数的难度差异很大，这题应该算简单题

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,
                     vector<int>& nums4) {

        unordered_map<int, int> map;
        int sum = 0;

        for (int a : nums1) {
            for (int b : nums2) {
                map[a + b]++;
            }
        }
        for (int c : nums3) {
            for (int d : nums4) {
                int target = -(c + d);
                if (map.find(target) != map.end()) {
                    sum += map[target];
                }
            }
        }
        return sum;
    }
};

第二题典型的哈希用法，过，

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> m(26, 0);

        for (char c : magazine) {
            m[c - 'a']++;
        }
        for (char c : ransomNote) {

            if (--m[c - 'a'] < 0) {
                return false;
            }
        }

        return true;
    }
};

第三题==寄，啥啊，自己尝试了切分数组，切成三段，每一个段取一个值，但是有一个很大的问题，就是一段取一个值，万一满足条件的是在一个段里呢？寄！，后来又想那能不能动态的划分这个区间，这和双指针的做法不谋而合，因为双指针我认为就是一种动态的划分区间的做法，固定i，然后滑动left和right。
另外一个注意点是要把left放里面，因为每次内循环都要用使得right在最右边开始，因为循环里的操作改变了size的大小。
 

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> re;

        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++)

        {
            int right = nums.size() - 1;
            int left = i + 1;
            if (i > 0 && nums[i] == nums[i - 1])
                continue; // 跳过重复的数字
            if (nums[i] > 0)
                break;

            while (left < right) {

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

最后一题我做的时候可以说信心满满啊，因为和3本来就算一个题，就多一层循环，首先要注意的就是，去重操作，第3题的traget为0，所以最左边的数大于零的话，总和肯定大于0，所有我就信誓旦旦写了if（num[i]>target）continue....大寄特寄，假设target是个负数，即使最左边大于大，万一四个数全是负的，那不一样满足啊，
另外一个点是变态测试用例，sum必须为long，仅仅定义long sum，nums[i] + nums[left] + nums[right]也不对，因为nums[i]为整型，加上nums[left]j就返回一个整形然后overflow，需要这样

sum = long(nums[i]) + long(nums[j]) + long(nums[left]) +long(nums[right])或者

sum = long(nums[i]) + nums[j] +nums[left]+nums[right];

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> re;
        sort(nums.begin(), nums.end());

        for (int i = 0; i < nums.size(); i++) {

            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;
                long long sum;

                while (left < right) {
                    sum = long(nums[i]) + long(nums[j]) + long(nums[left]) +
                          long(nums[right]);
                    if (sum > target)
                        right--;
                    else if (sum < target)
                        left++;
                    else {
                        re.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 re;
    }
};