代码随想录算法训练营 Day6，454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

第454题.四数相加II

题干

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

解题思路,

1. 以两个数组为一组，分别进行遍历求和，新建一个unordered_map，存储A和B两个数组的元素和a+b，以a+b的值为key，其出现的次数为value，每出现一次value+1，
2. 遍历C和D两个数组，以0-(a+b)为目标在map中搜索，如果map中存在目标值，那就将count+=value，最后返回count

代码如下

注意点：

1. 新建的map并未赋初值，为什么可以直接进行map[a+b]++的操作？
   当执行 map[a+b]++ 时，如果 a+b 这个键已经存在于 map 中，那么直接返回这个键对应的值。如果 a+b 这个键不存在于 map 中，那么会自动插入这个键，并将其对应的值初始化为 int 类型的默认值，即 0。

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

    }
};

注意点

1. 对map中某个key的value操作，value = map[key]
2. 如果检索到map中存在目标值，将count加上对应目标值的value，而不是+1

383. 赎金信

题干

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
可以假设两个字符串均只含有小写字母。

解题思路

只有小写字母，就可以使用数组哈希表的形式，

1. 创建一个大小为26的数组
2. 判断ransom和magazine的字符串长度，如果ransom.size > magazine.size，那就直接返回false
3. 进入第一个for循环，进行magazine的字符遍历，每一个字符与’a’作差，其差值作为数组索引，一个字符出现一次对应的数组元素+1，
4. 进入第二个for循环，在上面创建的数组中进行ransom的字符遍历，一个字符出现一次，对应索引的数组元素-1
5. 在循环中判断数组元素的值是否<0，如果小于0 ，那就说明magazine存在一个字符，而ransom中不存在，返回false

注意点

1. 先对magazine字符串处理，将其中的元素映射为哈希表，存储在新建的数组中，用ransom里的字符去减数组中的元素，这两个数组的处理顺序不要弄乱了
2. str.size()和str.length()这两种表达都是返回字符串中的字符数，这两种表达完全等价，没有区别

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int arr[26] = {0};
        if(ransomNote.size()>magazine.size())
        {
            return false;
        }
        for(int i =0;i<magazine.length();i++)
        {
            arr[magazine[i]-'a']++;
        }

        for(int j=0;j<ransomNote.length();j++)
        {
            arr[ransomNote[j]-'a']--;
            if(arr[ransomNote[j]-'a'] < 0)
            {
                return false;
            }

        }
        return true;
    }
};

15. 三数之和

题干

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。

解题思路

双指针法

1. 新建一个二维vector = result，用来存储结果
2. 将nums数组的元素排序，使用sort方法，升序排序
3. 进入nums遍历循环，首先判断第一个元素，如果>0，直接返回 result
4. 对第一个指针i 去重，if (i > 0 && nums[i] == nums[i - 1])，这里必须是i-1，因为i起始位置是数组的第一个元素，在循环中依次向后移动，i的后面跟着就是一个指针left，另一个指针在数组的末尾，随着遍历两个指针向内靠拢，如果条件成立，continue，跳出本次循环
5. left和right指针移动，
6. 进入第二个子循环 while (right > left)，根据三个指针指向的元素的和与0的关系，移动left指针和right指针，如果三个指针指向的元素的和等于0 ，那么就将此三个元素存在result，
7. 对left和right指针的元素去重
8. 指针移动到最后一个重复位置后，去重结束，此时还需要再向内收缩一个位置，将指针指向新的元素

剪枝操作 指的是在算法中去掉一些不符合题目要求的或是浪费时间而没有作用的答案，‌从而使得算法能够更快得到正确答案。‌这一概念常用于深度优先搜索中，‌因为在搜索树中去掉答案形似剪掉树的枝叶，‌所以这一方法被称为剪枝。‌

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)		//剪枝操作，
            {
                return result;
            } 
            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)
                {
                    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++;
                    
                    right--;
                    left++;
                    
                }
            }


        }
        return result;
    }
};

18. 四数之和

题干

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

解题思路

同样使用双指针法，只不过外层再加了一层循环，

1. 新建一个二维vector = result，用来存储结果
2. 将nums数组的元素排序，使用sort方法，升序排序
3. 进入第一层循环，以k为第一层循环索引
4. 一级剪枝，if (nums[k] > target && nums[k] >= 0); break;
5. 对k去重，if (k > 0 && nums[k] == nums[k - 1]) {continue;}
6. 进入第二层循环，以i为循环索引
7. 二级剪枝，if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {break;}
8. 对i去重，if (i > k + 1 && nums[i] == nums[i - 1]) {continue;}
9. 初始化left和right，进入第三层循环，while (right > left)
10. 根据现有四个指针指向的四个元素的和与target进行比较，确定left和right的移动方向，如果相同，就将这四个数作为一个结果插入到result中，然后对left和right进行去重，
11. 指针移动到最后一个重复位置后，去重结束，此时还需要再向内收缩一个位置，将指针指向新的元素
12. 最外侧大循环结束，返回result

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]>=0 && target<nums[k])
            break;
            //一级去重
            if(k>0 && nums[k]==nums[k-1])
            continue;
            //进入第二层循环
            for(int i = k+1;i<nums.size();i++)
            {
                //二级剪枝
                if(nums[i]>=0 && nums[k]>=0 && nums[i]+nums[k]>target)
                break;
                //二级去重
                if(i>k+1 && nums[i]==nums[i-1])
                {
                    continue;
                }
                //初始化left和right
                int left = i+1;
                int right = nums.size()-1;
                //进入第三层循环
                while(left<right)
                {
                    //进行数据判断
                    if((long)nums[i]+nums[k]+nums[left]+nums[right]>target)
                    {
                        right--;
                    }
                    else if((long)nums[i]+nums[k]+nums[left]+nums[right]<target)
                    {
                        left++;
                    }
                    else
                    {
                        result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        while(right>left && nums[left]==nums[left+1])
                        {
                            left++;
                        }
                        while(right>left && nums[right]==nums[right-1])
                        {
                            right--;
                        }
                        left++;
                        right--;
                    }

                }
                
            }

        }
        return result;

    }
};