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

 一、四数相加II

题目链接/文章讲解/视频讲解： 代码随想录

1.将四个数组两两拆分（时间复杂度O(n^2)），并用有效的字母异位词的思路做就行了

2.不使用数组，因为数据的上线是2的28次方，太大了，不适合

    求和会出现相同项，unordered_set无法记录相同项次数

    map   key存储求和后的值   value 存储该值出现的次数

3.该语句的语法访问nums2的值，赋值给j

4.本题不需要去重。且返回的是次数

for(int j:nums2)
{
ab[i+j]++;
}

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int count=0;
        unordered_map<int,int> ab;
        for(int i:nums1)
        {
            for(int j:nums2)
            {
                ab[i+j]++;
            }
        }
        for(int i:nums3)
        {
            for(int j:nums4)
            {
                auto iter=ab.find(-(i+j));
                if(iter!=ab.end())
                {
                    count+=iter->second;
                }
            }
        }
        return count;

    }
};

二、赎金信

题目链接/文章讲解： 代码随想录

1.本题并不难，还是一个查找元素，采用哈希表的方式，提高时间效率，查找在magazine 中是否包含ransomNote里面的字符。本题的元素数量有限，所以采用数组，哈希函数和有效的字母异位词一样。

2.时间复杂度：时间复杂度: O(n)

3.找不到则返回false，有许多种逻辑，如下

 for(int i=0;i<ransomNote.size();i++)
{
  if(array[ransomNote[i]-'a']!=0)
  {
    array[ransomNote[i]-'a']--;
  }
   else
  {
     return false;
  }
}

for (int j = 0; j < ransomNote.length(); j++) {
// 遍历ransomNote，在record里对应的字符个数做--操作
record[ransomNote[j]-'a']--;
// 如果小于零说明ransomNote里出现的字符，magazine没有
if(record[ransomNote[j]-'a'] < 0) 
 {
return false;
 }
}

代码：

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

三、三数之和

题目链接/文章讲解/视频讲解： 代码随想录

1.本题要求：返回的值的组合，不是下标，且不可重复，即可先排序

2.重点：先给数组排序 ，使用双指针法，即固定一个，双指针搜索

              排序过后，有了大小顺序我们便可以从左到右，依次遍历，双指针有了移动方向

             首先，固定第一个数，再利用双指针首尾对剩下的数进行搜索，找出第一个数全部符合要求的剩下两个数

              再固定第二个数（需要去重），循环直至结束

3.细节：剪枝：正数的情况可以减去,

              去重：注意是nums[i-1];

if(i>0&&nums[i]==nums[i-1])
{
continue;
}

while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;

 nums[i+1]也可以，即在找到一组结果集后，找到不重复的nums[i],比较麻烦,你要保证i+1不越界，十分不方便，鸡肋

代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;  
        for(int i=0;i<nums.size()-2;i++)
        {
            int left=i+1;
            int right=nums.size()-1;
            if(nums[i]>0)
            {  
                return result;
            }
            //已经排序了，对第一个数去重
            if(i>0&&nums[i]==nums[i-1])
            {
                continue;
            }
            //把第一个数的，所有三数之和都找出来
            while(left<right)//边界条件，因为left==right的时候，是两个元素
            {
                if(nums[i]+nums[left]+nums[right]>0)
                {
                    right--;
                }
                else if(nums[i]+nums[left]+nums[right]<0)
                {
                    left++;
                }
                else
                {
                    vector<int> res{nums[i],nums[left],nums[right]};
                    result.push_back(res);
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

四、四数之和

1.思路和上题一样

2.就是要先固定两个，在进行双指针

3.剪枝有一点变化，，思路一样大于目标值，且大于零，说明之后的值都大于零，每次固定，都可以剪枝

 if (nums[i] > target && nums[i] >= 0)

if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0)

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;  
        for(int i=0;i<nums.size();i++)
        {
            if (nums[i] > target && nums[i] >= 0) {
            	break; // 这里使用break，统一通过最后的return返回
            }
            //已经排序了，对第一个数去重
            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;
                int right=nums.size()-1;
                while(left<right)//边界条件，因为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
                {
                    vector<int> res{nums[i],nums[j],nums[left],nums[right]};
                    result.push_back(res);
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;
                }
            }
            }
        }
        return result;
    }
};

总结：

哈希表，查找元素，好像一般是两个集合之间，或一个元素，一个集合，如有效字母异味词、二数之和、三数之和如果使用哈希表也是，固定一个，转化为二数之和。