day 7

454.四数相加II

建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间 换时间， 工业开发也是这样。

题目链接/文章讲解/视频讲解：programmercarl.com/0454.%E5%9B…

个人思路： 暴力的解法，时间复杂度为o（n^4），比较复杂，如果采用哈希的办法则时间复杂度为o（n^2）。由于只需要记录元组的个数，因此可以将数组1和数组2进行合并，记录下里面每个元素搭配所对应的个数（哈希映射），同时也合并数组3和数组4，对其进行匹配，如果合并后数组中，存在和与上述哈希表中的数和为0，则那么匹配成功，元组数量增加。

代码：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> aplusb;
        for(auto num1:nums1)
        {
            for(auto num2:nums2)
            {
                int sum = num1+num2;
                if(aplusb.find(sum)!=aplusb.end())
                {
                    aplusb[sum]++;
                }
                else
                {
                    aplusb.insert(pair<int,int>{sum,1});
                }
            }
        }

        int result =0 ;
        for(auto num3:nums3)
        {
            for(auto num4:nums4)
            {
                int sum =num3+num4;
                int dec = 0 -sum;
                if(aplusb.find(dec)!=aplusb.end())
                {
                    result+=aplusb[dec];
                }
            }
        }
        return result;
    }
};

383. 赎金信

建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题

题目链接/文章讲解：programmercarl.com/0383.%E8%B5…

个人思路：

本题与上题比较类似，都是先通过哈希的方法将记录其中一个数组（字符），然后在另外一个数组中对哈希表中的内容进行快速匹配。

代码：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char,int> r_map;
        for(char a:magazine)
        {
            if(r_map.find(a)!=r_map.end()){
                r_map[a]++;
            }
            else{
                r_map.insert(pair<char,int>{a,1});
            }
        }
        for(char b:ransomNote)
        {
            if(r_map.find(b)==r_map.end()){
                return false;
            }
            else{
                if(r_map[b]==0) return false;
                else r_map[b]--;
            }
        }
        return true;
    }

15. 三数之和

建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。

题目链接/文章讲解/视频讲解：programmercarl.com/0015.%E4%B8…

个人思路：

本题采用双指针的办法，双指针首先需要进行排序，然后确定a，再在剩下的区间寻找b和c，左边界确定为a的右边一位，右边界确定为数组的最后一个元素，再通过不断缩小区间来寻找合适的组合，题目中要求不重复，因此对可能出现的重复元素先进行排除，a要求与他前面的元素不重合（注意是前面的，如果与后面的元素重合仍然是可以的比如{0，0，0}），而在找到相应的组合后，在缩小区间时也需要去重。

代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int n = nums.size();
        int L;
        int R;
        vector<vector<int>> result;
        for(int i =0;i<nums.size();i++)
        {
            if(nums[i]>0) return result;
            if(i>0&&nums[i]==nums[i-1]) continue;
            
            L=i+1;
            R=n-1;
            while(L<R)
            {
                if(nums[i]+nums[L]+nums[R]==0){
                result.push_back(vector<int>{nums[i],nums[L],nums[R]});
                while(L<R&&nums[L]==nums[L+1]) L++;
                while(L<R&&nums[R]==nums[R-1]) R--;
                L++;
                R--;
            }
            else if(nums[i]+nums[L]+nums[R]>0){
                R=R-1;
            }else{
                L=L+1;
            }
            }
           
        }
        return result;
    }
};

18. 四数之和

建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。

题目链接/文章讲解/视频讲解：programmercarl.com/0018.%E5%9B…

个人思路： 与上题类似，但这里将第一次求a+b的和，再在后面的区间寻找c和d，将o（n^4）缩短为o（n^3）。

代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
         sort(nums.begin(),nums.end());
         vector<vector<int>> result;
         int n = nums.size();
         for(int i=0;i<n;i++)
         {
            if(nums[i]>target&&nums[i]>=0) return result;
            if(i>0&&nums[i]==nums[i-1]) continue;
            for(int j=i+1;j<n;j++)
            {
                if (nums[j] + nums[i] > target && nums[j] + nums[i] >= 0) {
                    break; //注意不是return result,应该只是退出单层循环;
                }
                if(j>i+1&&nums[j]==nums[j-1]) continue;
            

                int L = j+1;
                int R = n-1;
                while(L<R)
                {
                    if((long) nums[i]+nums[j]+nums[L]+nums[R]>target)   //溢出
                    {
                        R--;
                    }
                    else if((long) nums[i]+nums[j]+nums[L]+nums[R] <target) L++;
                    else{
                        result.push_back(vector<int>{nums[i],nums[j],nums[L],nums[R]});
                        while(L<R&&nums[L]==nums[L+1]) L++;
                        while(L<R&&nums[R]==nums[R-1]) R--;
                        L++;
                        R--;
                    }
                }
            }
         }
         return result;
    }
};