Day06|● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和

454.四数相加II

我们采用分组的方法来减小时间复杂度，把这四个数组分成两组来进行遍历，把第一组的结果放在unordered_map里，采用哈希的想法来提高效率进行查找。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
     
     unordered_map<int,int> umap;
     int n=nums1.size();
     int count=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            umap[nums1[i]+nums2[j]]++;
        }
    

    }
    for(int a:nums3)
    {
        for(int b:nums4)
        {
            if(umap.find(0-a-b)!=umap.end())
            count+=umap[0-a-b];
        }
    

    }
    return count;
    }

};

383. 赎金信

这道题同样的我们也可以用暴力的方法来遍历。但是也可以以空间换取时间的法，用一个数组作为哈希表，26个英文字母所以我们只需要26个下标空间或者下标映射。然后统计在magazine里字母出现的次数再和ransomeNote比较就好了。这里不用unordered_map或者map是因为需要哈希表或者红黑树作为支持可能需要额外的时间空间负担。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> result(26,0);
        if(ransomNote.size()>magazine.size())
        return false;
        
        for(char a:magazine)
        result[a-'a']++;
        for(char a:ransomNote)
        { 
            result[a-'a']--;
            if(result[a-'a']<0)
            return false;


        }
        return true;


    }
};

15. 三数之和

这道题还是比较难的！这道题和四数相加不同的是要考虑去重的问题，如果使用哈希，去重的工作会十分复杂，所以我们可以考虑用双指针法进行一遍遍历。要注意的是，在去重的阶段，应该判断的是本位和前一位而不应该是后一位，否则就可能少统计了nums[left]和nums[i]相同的情况。在left和right去重复的时候要注意用while去除所有可能情况而不是if。

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;

            else 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  if (nums[i]+nums[left]+nums[right]==0)
               {
                  vector<int> temp;
                  temp.push_back(nums[i]);
                  temp.push_back(nums[left]);
                  temp.push_back(nums[right]);
                  result.push_back(temp);
                  while(right>left&&nums[left]==nums[left+1]) left++;
                  while(right>left&&nums[right]==nums[right-1]) right--;

                  left++;
                  right--;
                  
               }
               
               
            }

        }
        return result;




    }
};

18. 四数之和

这道题的基本思路其实和三数之和是一样的。对于n数之和的类型，我们用双指针法都可以减少一层的时间复杂度。要做的事是一样的。对于本题来说，首先对最外层循环进行剪枝和去重复，这和三数之和是一样的。然后对内层进行剪枝和去重复，这时候我们只要把内外层看成一个整体就好了。其余操作就和三数之和一样了，需要细心一点！注意可能会有元素溢出所以我们需要longlong。

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&&nums[k]>target)
            break;

            if(k>0&&nums[k]==nums[k-1])
            continue;

            for(int i=k+1;i<nums.size();i++)
            {
                if(nums[i]+nums[k]>=0&&nums[i]+nums[k]>target)
                break;

                if(i>k+1&&nums[i]==nums[i-1])
                continue;

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

                while(left<right)
                {
                    long long temp=(long long)nums[i]+nums[k]+nums[right]+nums[left];
                    if(temp>target)
                    right--;
                    if(temp<target)
                    left++;
                    if(temp==target)
                    {
                        vector<int> a;
                        a.push_back(nums[k]);
                        a.push_back(nums[i]);
                        a.push_back(nums[left]);
                        a.push_back(nums[right]);
                        result.push_back(a);
                        while(left<right&&nums[left]==nums[left+1]) left++;
                        while(left<right&&nums[right]==nums[right-1]) right--;
                        left++;
                        right--;

                    }
                }

            }



        }
        return result;


    }
};