代码随想录||Day7 454.四数相加 383.赎金信 15.三数之和 18，四数之和

454.四数相加

题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

代码：哈希法

class Solution 
{
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) 
    {
        map<int,int> map;
        for(int a:nums1)
        {
            for(int b:nums2)
            {
              //每种和的结果的个数都记录下来
              map[a+b]++;
            }
        }
        int count=0;
        for(int c:nums3)
        {
            for(int d:nums4)
            {
                //通过map键找到对应的值
                if(map.find(0-(c+d))!=map.end())
                {
                    //一旦找到，就加到count里
                    count+=map[0-(c+d)];
                }
            }
        }
     return count;
    }
};

步骤总结

1，定义一个map，key放a和b两数之和，value 放a和b两数之和出现的次数。

map<key,value> key用来查找value

2，遍历A和B数组，统计两个数组元素之和，和出现的次数，放到map中。

3，定义int变量count，用来统计 a+b+c+d = 0 出现的次数。

4，再遍历C和D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。

5，最后返回统计值 count 就可以了

383.赎金信

力扣题目链接

题目描述：

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

跟异位字符很像

代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine)
    {
        //定义一个大小为26，元素全为0的数组
        vector<int> charCount(26, 0);

        // 统计 magazine 中每个字符的数量
        for (char c : magazine) {
            charCount[c - 'a']++;
        }

        // 遍历 ransomNote，减少对应字符的数量
        for (char c : ransomNote) {
            charCount[c - 'a']--;
            // 如果当前字符数量不足，则无法构建 ransomNote
            if (charCount[c - 'a'] < 0) {
                return false;
            }
        }

        // 所有字符数量都足够，返回 true
        return true;
    }
    

};

这题没什么好说的，关键就是把字母映射在数组中！

15.三数之和

力扣题目链接、

题目描述：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

代码：

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();i++)
      {
        //一级剪枝
        if(nums[i]>0)
        {
            return result;
        }
       //去重，相同的a不在放入
        if(i>0&&nums[i]==nums[i-1])
        {
            continue;
        }
       //定义双指针，一个左边一个右边（都在i右边）
        int left=i+1;
        int right=nums.size()-1;
        while(left<right)
        {
          //三个数相加大于零，说明是nums[right]的问题，所以right--
          if (nums[i] + nums[left] + nums[right] > 0) right--;

          //同理
          else if(nums[i] + nums[left] + nums[right] < 0) left++;
          
           else
            {      
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
            
            }
        }
       }
        return result;
    }    
    
};

这题中重要的地方是去重，剪枝，还有双指针的思想

做了这么多题，发现双指针的作用就是去掉一重循环，降低时间复杂度

/*依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。*/

18，四数之和

力扣题目链接

题目描述：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案

代码：

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++)
     {
    //换成了target，如果是[-4,-3,-2,-1]target=-10,这样则会跳过，所以要额外加上条件
    //nums[i]>=0
    //这里是一级剪枝
        if(nums[i]>target&&nums[i]>=0)
        {
            break;
        }
    //a去重
        if(i>0&&nums[i]==nums[i-1])
        {
            continue;
        }
        for(int j=i+1;j<nums.size();j++)
        {
            //二级剪枝
            if(nums[j] + nums[i] > target && nums[j] + nums[i] >= 0)
            {
                break;
            }
            //b去重
            if(j>i+1&&nums[j]==nums[j-1])
            {
            continue;
            }
            //定义双指针
            int left=j+1;
            int right=nums.size()-1;
            //这点与三数相加一摸一样
            while(right>left)
            {
           
            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{
                result.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                while(right>left&&nums[right]==nums[right-1]){right--;}
                while(right>left&&nums[left]==nums[left+1]){left++;}
                left++;
                right--;
            }
            }
        }
     }
     return result;
    }
};

注意：例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

双指针复习汇总！

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：

链表相关双指针题目：