代码随想录 day07

454.四数相加II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        // key 存放 a + b 的结果 value 存放 a + b 出现的次数
        unordered_map<int, int> umap;

        // 遍历前两个数组，统计元素之和，与其出现的次数
        for (int a : nums1) {
            for (int b : nums2) {
                umap[a + b]++;
            }
        }

        /*
         * a + b + c + d = 0
         * 例：2 + 2 + (-1) + (-3) = 0
         * 则:a + b = 4
         *   c + d = -4 ==> -(c + d) = 4
         */
        int ans = 0;
        for (int c : nums3) {
            for (int d : nums4) {
                // 使用 find 函数来定位数据出现位置
                // 返回的一个迭代器，当数据出现时，返回数据所在位置的迭代器
                // 如果 map 中没有要查找的数据，返回的迭代器等于 end 函数返回的迭代器
                if (umap.find(0 - (c + d)) != umap.end()) {
                    ans += umap[0 - (c + d)];
                }
            }
        }
        return ans;
    }
};

383.赎金信

// 思路：
// 1. 统计 magazine 中的字符及出现的次数
// 2. 在 magazine 统计的基础上，减去 ransomNote 中的字符及出现的次数
// 3. 判断 map 中是否出现负数，若出现，说明 ransomNote 没有 magazine 中所需字符，或所需字符个数不足
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        map<int, int> m;
        // 1. 统计 magazine 中的字符及出现的次数
        for (int i = 0; i < magazine.size(); i++) {
            m[magazine[i] - 'a']++;
        }

        // 2. 在 magazine 统计的基础上，减去 ransomNote 中的字符及出现的次数
        for (int i = 0; i < ransomNote.size(); i++) {
            m[ransomNote[i] - 'a']--;

            // 3. 判断 map 中是否出现负数，若出现，说明 ransomNote 没有 magazine 中所需字符，或所需字符个数不足
            if ((m[ransomNote[i] - 'a']) < 0) {
                return false;
            }
        }
        return true;
    }
};

15.三数之和

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

        // 先进行排序
        sort(nums.begin(), nums.end());

        // 从数组的第一个元素开始
        for (int i = 0; i < nums.size(); i++) {

            // 剪枝
            // 经过排序后的数组如果第一个元素都大于 0 则说明后续的所有元素都大于 0 即没有符合要求的答案
            if (nums[i] > 0) {
                return ans;
            }

            // 错误去重方式：
            // 该去重方式将会遗漏 -1 -1 2 的结果
            // 原因：此时下标才到过 i 的位置，i + 1 位置的数值还没有使用过
            // 而正确去重中，i - 1 已经使用过
            // if (nums[i] == nums[i + 1]) {
                // continue;
            // }

            // 去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int left = i + 1;
            int right = nums.size() - 1;
            while (left < right) {
                
                // 注意：对 left 与 right 的去重逻辑不能放在此处，否则 0 0 0 的结果将会遗漏 

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

18.四数之和

// 总体思路与三数之和相同
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;

        // 先进行排序
        sort(nums.begin(), nums.end());

        for (int i = 0; i < nums.size(); i++) {
            // 剪枝
            // 注意：此处的剪枝逻辑与三数之和有所不同
            // 三数之和中 target 为具体的数值 0
            // 而在此处 target 可能为 正负零
            if (nums[i] > target && target >= 0) {
                continue;
            }

            // 去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            for (int j = i + 1; j < nums.size(); j++) {
                // 剪枝
                if (target > 0 && nums[i] + nums[j] > target) {
                    break;
                }

                // 去重
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }

                int left = j + 1;
                int right = nums.size() - 1;

                // 三数之和的逻辑
                while (left < right) {
                    long long sum = (long long)nums[i] + nums[j] + nums[left] + nums[right];

                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        ans.push_back(vector<int>{nums[i], nums[j], 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 ans;
    }
};