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

第454题.四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/

看到题目的第一时间想法：因为只用输出出现的次数，而且不用输出下标所以我决定用哈希表来存储第一个数组和第二个数组的和与和出现的次数，然后再用两个for循环对count进行叠加。最终输出的就是出现的次数

看到代码随想录的想法：基本上一致

实现中遇到的困难：在第一次插入value的时候，key值应该设置为1，我设置成0了，幸好bugfree了

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
// 给你四个整数数组 nums1、nums2、nums3 和 nums4 ，
// 数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) 
    {
            unordered_map<int,int>map;//value值来存储和的大小，key值来存储出现的次数
            for(int i=0;i<nums1.size();i++)
            {
                for(int j=0;j++;j<nums2.size();j++)
                {
                    auto find=map.find(nums1[i]+nums2[j])
                    if(find!=map.end())
                    {
                        find->secound++;
                    }else{
                        map.insert(nums1[i]+nums2[j]);
                    }
                }
            }
            int count=0;
            for(int n3:nums3)
            {
                for(int n4:nums4)
                {
                    if(map.find((-nums3-nums4))!=map.end())
                    {
                        count+=map.find((-nums3-nums4))->second;
                    }
                }
            }
        return count;
    }  
};

383. 赎金信

题目链接：https://leetcode.cn/problems/ransom-note/

看到题目的第一时间想法：用哈希表去收集magazine的所有字符，然后key设置为1，如果再次出现key+=1，然后再用ransnote的去遍历哈希表，如果所需要的value的key小于等于0，失败。否则能走到循环最后就成功了

看到代码随想录的想法：基本上一致

实现中遇到的困难：没有

class Solution {

public:

bool canConstruct(string ransomNote, string magazine) {

unordered_map<char,int>map;

for(int i=0;i<magazine.size();i++)

{

auto find=map.find(magazine[i]);

if(find!=map.end())

{

find->second++;

}else{

map.insert(pair<char,int>(magazine[i],1));

}

for(int i=0;i<ransomNote.size();i++)

{

auto find=map.find(ransomNote[i]);

if(find!=map.end())

{

if(find->second==0)

{

return false;

}else{

find->second--;

}

}else{

return false;

}

return true;

}

};

第15题. 三数之和

题目链接：https://leetcode.cn/problems/3sum/

看到题目的第一时间想法：说实话并没有想法。

看到代码随想录的想法：用双指针法，感觉很妙，第一次做根本想不到。去重操作很精妙，不过看一遍演示以后也能明白

去重的操作，num[i]==nums[i-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;
            // 对A的去重
            if (i > 0 && nums[i] == nums[i - 1])
            {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left)
            {
                if (nums[i] + nums[left] + nums[right] < 0)
                    left++;
                else if (nums[i] + nums[left] + nums[right] > 0)
                    right--;
                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题. 四数之和

题目链接：https://leetcode.cn/problems/4sum/

看到题目的第一时间想法：说实话并没有想法，类比了三数之和但是没有想出来。

看到代码随想录的想法：用双指针法，感觉很妙，第一次做根本想不到。去重操作很精妙，不过看一遍演示以后也能明白

去重的操作，num[i]==nums[i-1],这样的去重操作，是前面已经把这个结果给保存了，所以这样的话就成功去重。

然后还有修枝操作，这里修枝叫加上nums[k]>0,nums[k]+nums[i]>target&&nums[k]+nums[i]>0 因为你不知道是否

后面还有负数，加上去之后target会减小

实现中遇到的困难：基本上是对着随想录抄的，后面自己思考也能实现。

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[i]+nums[k]>target&&nums[i]+nums[k]>=0) break;
                //去重操作
                if(i>k+1&&nums[i]==nums[i-1]) continue;
                int right=nums.size()-1;
                int left=i+1;
                while(left<right)
                {
                  if((long) nums[k] + nums[i] + nums[left] + nums[right] > target) right--;
                  else if((long) nums[k] + nums[i] + nums[left] + nums[right] <target) left++;
                  else{
                       result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                    while(left<right&&nums[right]==nums[right-1])right-- ;
                    while(left<right&&nums[left]==nums[left+1]) left++;
                    
                    left++;
                    right--;
                  }
                }
            }
        }
        return result;
    }
};