代码随想录算法训练营第七天｜leetcode454.四数相加2️⃣、leetcode383.赎金信、leetcode15.三数之和、leetcode18.四数之和

1.454. 四数相加 II - 力扣（LeetCode）

思路（本题较为简单）：首先将前两个数组的元素相加，并存入map中<a+b，出现的次数>，然后遍历后两个数组的时候，求出0和c+d的差值，然后看在map中是否可以找见，如果可以找见，cnt+=map->Second

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

2.383. 赎金信 - 力扣（LeetCode）

思路：这道题很基础，就说把magazine的字符构成存入哈希表中，然后用ransom中的字符对应去减，出现一个就减一个，直到遍历结束。但是这道题用map的空间复杂度要比用数组要大。下面是map写法：

    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> map;
        for (int i = 0;i<magazine.size();i++){
            map[magazine[i]]++;
        }
        for (int i = 0; i < ransomNote.size();i++){
            if(map.find(ransomNote[i])!=map.end()){
                map[ransomNote[i]]--;
                if(map[ransomNote[i]]<0)
                    return false;
            }else{
                return false;
            }
        }
        return true;
    }

以下是数组写法：magazine[i]-'a'

 bool canConstruct(string ransomNote, string magazine)
    {
        int record[26] = {0};
        if (ransomNote.size() > magazine.size())
            return false;
        for (int i = 0; i < magazine.size(); i++)
        {
            record[magazine[i] - 'a']++;
        }
        for (int i = 0; i < ransomNote.size(); i++)
        {
            record[ransomNote[i] - 'a']--;
            if (record[ransomNote[i] - 'a'] < 0)
                return false;
        }
        return true;
    }

3.15. 三数之和 - 力扣（LeetCode）

思路1：哈希表。这道题主要就难在去重这个问题上！！！并且思路类似于滑动窗口。最开始我想的是：“涉及到是否有重复元素的时候，我想用哈希表来解决这个问题，见“leetcode1.两数之和”，就是说首先通过两个for循环定位两个元素，然后第三个元素是：0-(a+b) 或者 0 - (a + c) ，然后去判断它是否在数组当中。但有个棘手的问题，也就是说去重的问题。。。也就是说：把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。

 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)
                return result;
            if(i>0 && nums[i] == nums[i-1])
                continue;//去重a；
            unordered_set<int> set;//存储b
            for (int j = i + 1; j < nums.size(); j++){
                if(j>i+2&&nums[j]==nums[j-1]&&nums[j-1]==nums[j-2])
                    continue;//去重b；
                //c = 0-(a+b)
                int target = 0-nums[i]-nums[j];
                if(set.find(target)!=set.end()){//遇到过这个元素
                    result.push_back({nums[i], nums[j], target});
                    set.erase(target);
                }
                else
                {
                    set.insert(nums[j]);
                }
            }
        }return result;
    }

思路2:双指针法（推荐）
首先定位a的位置，也就是for循环的i，然后下面分别将指针指向i+1和最后一个元素，如果a+b+c>0,那么c--；如果a+b+c<0,那么c++；，这个阶段是保持a不变了，然后当b,c两指针重合，a就移动到下一个位置。

    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) {
                return result;
            }
            if(i>0 && nums[i] == nums[i-1]){
                continue;
            }//去重，因为是在结果集里去重，如果nums[i] == nums[i-1]，那么就会漏掉[-1,-1,2]这种情况
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left){
                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(right>left&&nums[right]==nums[right-1])
                        right--;
                    while(right>left&&nums[left]==nums[left+1])
                        left++;//b,c的去重
                    right--;
                    left++;
                }
            }
        }
        return result;
    }

4.18. 四数之和 - 力扣（LeetCode）

这道题大体思路和上面的三数之和差不多，只不过再外面再加一层for循环而已。其次不要判断nums[k] > target 就返回了，三数之和 可以通过 nums[i] > 0 就返回了，因为0已经是确定的数了，四数之和这道题目 target是任意值。这个错误我第一次敲的时候就犯了，当时还以为是后面的判断逻辑出错了呢。【-5，-4，-3，-2，1，3，3，5】target = -11。当时-5>-11，就直接返回空了....

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：

• 27.移除元素(opens new window)
• 15.三数之和(opens new window)
• 18.四数之和(opens new window)

链表相关双指针题目：

• 206.反转链表(opens new window)
• 19.删除链表的倒数第N个节点(opens new window)
• 面试题 02.07. 链表相交(opens new window)
• 142题.环形链表II(opens new window)

    vector<vector<int>> fourSum(vector<int> &nums, int target)
    {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        /*if (nums[0] > target)
            return {};*/
        for (int i = 0; i < nums.size(); i++)
        {
            if(nums[i]>target &&nums[i]>=0)
                break;
            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(vector<int>{nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        while (left < right && nums[left] == nums[left + 1])
                            left++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }

哈希表小结

一般来说哈希表都是用来快速判断一个元素是否出现集合里。

对于哈希表，要知道哈希函数和哈希碰撞在哈希表中的作用。

• 哈希函数是把传入的key映射到符号表的索引上。
• 哈希碰撞处理有多个key映射到相同索引上时的情景，处理碰撞的普遍方式是拉链法和线性探测法。

哈希表经典题目

A.数组作为哈希表

1.242.有效的字母异位词 (opens new window)：数组就是最基本的哈希表，只不过大小受限制，并且题目中提到小写字母，所以 int result[26]={0};
2.383.赎金信 (opens new window):同样要求只有小写字母
虽然这两道题用map也可以做，但使用map的空间消耗要比数组大一些，因为map要维护红黑树或者符号表，而且还要做哈希函数的运算。所以数组更加简单直接有效！

B.set作为哈希表

1.349. 两个数组的交集 (opens new window)：这道题目没有限制数值的大小，就无法使用数组来做哈希表了。
2.202.快乐数 (opens new window)：我们再次使用unordered_set来判断一个数是否重复出现过。

C.map作为哈希表

map是一种<key, value>的结构，本题可以用key保存数值，用value在保存数值所在的下标。所以使用map最为合适。前面的四道题只是存了数值，然后比如通过find(val)函数去判断是否存过，从而使用set更好，并没有要存键值对，但使用数组当作哈希表的时候，也可以存次数。

1.1.两数之和 (opens new window)
2. 454. 四数相加 II - 力扣（LeetCode）本题为四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑重复问题
3.18. 四数之和 - 力扣（LeetCode）双指针
4.15.三数之和 (opens new window) 双指针