【代码随想录】算法训练营 第七天 第三章 哈希表 Part 2

454. 四数相加

题目

思路

这道题相当于是两数相加的加强版，其实大体思路是一致的，只不过这道题里先把四个数组中的数两两相加，把和作为map的key值，把和出现的次数作为value，这样先遍历完前两个数组，后面再遍历剩余数组时，也是将数组两两相加，不过这次的和就需要用来被0减了，这样就可以知道前两个数组和中有哪些可以和这两个的数组和相加为0，将所有符合条件的value累加，最后就能得到答案了。

代码

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for (int a : nums1) {
            for (int b : nums2) {
                umap[a + b]++;
            }
        }
        int count = 0;
        for (int c : nums3) {
            for (int d : nums4) {
                if (umap.find (0 - (c + d)) != umap.end()) {
                    count += umap[0 - (c + d)];
                }
            }
        }
        return count;
    }
};

383. 赎金信

题目

思路

难得又一道自己AC出来的题，虽然只是简单题，但说明我有学以致用！

这道题似曾相识，和之前做过的有效异位词相似，其实就是给出字符串A和B，判断A是不是包含于B，注意要用B中的字母组成A，而且字母的数量也得够，所以这里我就先将B里字母对应的数字作为map的key，字母的数量作为map的value，遍历完B后就得到map，接下来再遍历一下A，如果A中出现了某个map中的key，就将对应的value减一，到最后如果减得一个不剩，那就说明B包含A。

代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magzine) {
        unordered_map<int, int> umap;
        for (int i = 0; i < ransomNote.size(); i++) {
            umap[ransomNote[i] - 'a']++;
        }
        for (int i = 0; i < magzine.size(); i++) {
            if (umap.find(magzine[i] - 'a') != umap.end() && umap[magzine[i] - 'a'] > 0) {
                umap[magzine[i] - 'a']--;
            }
        }
        for (int i = 0; i < 26; i++) {
            if (umap[i] != 0) {
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

题目

思路

这道题的思路就是双指针法，因为在一个数组里找三个元素相加等于0，这就需要先用一个循环遍历，在这个循环里，再设置两个指针，一个外指针和两个内指针这三个指针指向的元素之和为0时，将三个元素组成的数组加入一个二维数组中，最后返回的就是这个二维数组；

那具体是怎么做的呢？其实很简单，首先要将提供的数组做一下排序，接下来，外指针是从数组的第一个数开始遍历的，内指针包括一个左指针和一个右指针，左指针从外指针的下一个开始向后搜索，右指针从最后一个元素开始向前搜索，在一次循环中，如果三个指针的值加起来大于0，说明右指针指向的数太大了，右指针向左移动一位，如果三个指针的值加起来小于0，说明左指针指向的数太小了，左指针向右移动一位，如果指针值之和等于0，说明符合条件，就将三个值存入一个一维数组中，再将这个一维数组存入二维数组里。

在遍历的过程中，还要注意三个元素的去重，因为题目要求最后的三元组是不能重复的，去重要分别进行，首先是外指针，也就是遍历全数组的指针，这个指针指向的数如果和前一个相等的话，那就向后移动，在代码中就是用continue跳过这次循环，如果这个指针指向的数已经大于0了，那说明之后的所有数都大于0，再循环下去也是徒劳，所以用break直接跳出循环；接着是左指针，如果左指针指向的值和下一个值相等，那就必须跳过下一个值，这里就是向右移动左指针，右指针也类似，不过它是要和右边的值相等时往左移。

理解了去重，这道题的精髓就掌握了，其实就是双指针 + 去重，还涉及到一些简单的STL操作，要注意的是STL函数的格式，具体代码在下面。

代码

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)
                break;
            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(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--;
                }
            }
        }
        return 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 k = 0; k < nums.size(); k++) {
            if (nums[k] > target && nums[k] >= 0) {
                break;
            }
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1, right = nums.size() - 1;
                while (right > left) {
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] >target) 
                        right--;
                    else if ((long) nums[k] + nums[i] + nums[left] + nums[right] < target) 
                        left++;
                    else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        while (right > left && nums[right] ==nums[right - 1])
                            right--;
                        while (right > left && nums[left] == nums[left + 1])
                            left++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
};