代码随想录算法训练营第七天｜454.四数相加II、383.赎金信、15.三数之和、18.四数之和

454.四数相加II

454.四数相加II

代码随想录(programmercral.com)

学透哈希表，map使用有技巧！LeetCode：454.四数相加II

方法一：暴力实现

暴力解 四层for  并不是一个很好的选择

代码实现

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int count=0;
        for(int i=0;i<nums1.size();i++){
            for(int j=0;j<nums2.size();j++){
                for(int k=0;j<nums3.size();k++){
                    for(int l=0;l<nums4.size();l++){
                        int sum=nums1[i]+nums2[j]+nums3[k]+nums4[l];
                        if(sum==0) count++;
                    }
                }
            }
        }
        return count;
    }
};

方法二：哈希表map

使用哈希表map，1为什么考虑到用哈希表？因为这种题也可以归结为在某个集合中找某个元素是否出现过，关键在于考虑到如何降低运算量，四个数组运算量太大，所以这个题可以归结为两个数组的操作，即nums1和nums2是一种，把他俩相加所有的可能存入哈希表，然后nums3和nums4是一种，他俩相加所有的可能的相反数就是需要在哈希表中寻找的元素，为什么是相反数，因为设nums1数组元素是a，nums2的元素为b，以此类推，有c和d，那么哈希表中存放的元素为a+b，那么要满足a+b+c+d=0，即要找的元素是0-c-d，即c+d的相反数。2map中的value和key分别存放什么？value存放a+b出现的次数，key存放a+b的值。

代码实现：

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;
    }
};

时间复杂度o(n^2)空间复杂度o（n^2） 最坏的情况nums1和nums2的元素 各不相同，相加产生的数字个数为n^2个

383.赎金信

383.赎金信

代码随想录(programmercral.com)

思路

与有效字母异位词是一个类型，只有26个字母，所以数组长度有限，可以使用数组哈希表，不同之处在于判断条件不同，本题只要求ransom Note能不能有magazine组成，magazine的字母个数可以比ransom note大，但是不能少，所以如果哈希表中有小于零的就说明不行返回false，否则就可以。

代码实现：

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

时间复杂度o(n)空间复杂度o(1)

15.三数之和

15.三数之和

代码随想录(programmercral.com)

梦破碎的地方！| LeetCode：15.三数之和

思路：

双指针法，假设有一个数组[2,-1,2,-1,4],首先对数组进行排序，然后外面有层for循环，定义三个指针，i，left，right，假设排序完的数组为[-1,-1,2,2,4]，则一开始i指向元素-1，那么这时候首先判断此元素比0大还是小，如果大，那就不用做了，因为是排过序的，所以此元素后面的肯定都比0大，不可能加出来比0小的，如果小于0，那么让left指向i的下一个位置，right指向数组尾，如果三个数的和比0小，则让left向后移动（因为排过序，所以要让整体增加，就让left向后移动）如果大于0，就让right向前移动（原因同left），如果等于0，则可以收获结果集，直到left=right，第一个元素处理结束，然后i向后移，重复上述逻辑。
        去重操作，怎么去重？有两个地方需要去重，第一个地方，就是移动i的时候，如果i和i-1的值一样，说明这个值收获的结果集肯定也一样，所以不做处理直接跳过，（注意i和i+1一样不可以判断，因为会漏掉结果集例如[-1,-1,2]，如果按i=i+1判断这种就漏掉了，i=i+1是保证结果三元组里面没有重复元素）
        第二个地方，就是i固定，移动left和 right的时候，如果right和right-1一样，说明收获的结果集肯定一样，没必要处理了，直接跳过，如果left和left+1一样同理，直接跳过。

代码实现：

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){//不能等于，否则就处理成同一个元素了
                //这里不可以先去重，因为先去重就会把结果集pass掉
                if(nums[i]+nums[left]+nums[right]<0) left++;
                else if(nums[i]+nums[right]+nums[left]>0) right--;
                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;
    }

时间复杂度o(n^2)空间复杂度o(1)

18.四数之和 

18.四数之和

代码随想录(programmercral.com)

难在去重和剪枝！| LeetCode：18. 四数之和

思路

  延续了三数之和的思路，只不过要在三数之和的基础上多加一层for循环，同时结果去重有一些差异，四数之和不可用nums[k]>targrt然后就把结果剪掉，因为nums数组里可能有负数，两数相加可能会变小，所以如果nums[k]>target&&nums[i]>=0,只要保证当前元素大于零了，那么后面的元素肯定也都大于0了，相加一定会变大，所以就可以吧结果剪掉了。

代码实现：

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

时间复杂度o(n^3)空间复杂度o(1)

总结

   454题，暴力解法明显是不合理的，可以使用哈希法来降低计算复杂度，可以把四数之和转换为两数之和，即把第一个和第二个可以合并成一个集合，把第三个和第四个可以合并成一个集合，这样就转化为了两个数组。383题算是对有效字母异位词的一个小扩展，增加了一个小的限制条件，也是对数组哈希表的复习。15题使用哈希法不是很好算，对双指针法进行了一个补充，关键在于去重操作。18题是15题的扩展，即在15题的基础上又增加了一个for来进行遍历，同时去重条件有所变化，即两数相加不一定会增加，也可能减小，要对此做出调整。