代码随想录|day7|哈希表篇--454.四数相加II ●383. 赎金信 ● 15. 三数之和 ● 18. 四数之和

总链接：7 第三章 哈希表

454.四数相加II

链接：代码随想录

 第一版：自己想出来的，想到了做过的两数之和，想到了拆分和递归。但是仍有优化的空间，并不需要两个map

class Solution {
public:
/*
哈希表，昨天做了两数相加 ，两数相加只需要对一个数组进行遍历，看看temp-nums[i]是否在另一个数组的哈希表中存在。能否转换成两数相加问题？想法：把前两个数组合成哈希表，后两个数组合成哈希表

注：计算的是个数！不是index
*/
    int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
        int n=nums1.size();
        unordered_mapm1,m2;
        int temp1=0,temp2=0;
        for(int i=0;isecond);
          }
        }
        return k;

        
        

    }
};

 第二版：优化版，这版只需要计算一个map就可以了，毕竟第二个map有些多余，根本不需要去重，注在自己实现过程中用到map.count()，用法还用错了

class Solution {
public:
/*
哈希表，昨天做了两数相加 ，两数相加只需要对一个数组进行遍历，看看temp-nums[i]是否在另一个数组的哈希表中存在。能否转换成两数相加问题？想法：把前两个数组合成哈希表，后两个数组合成哈希表

注：计算的是个数！不是index
*/
    int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
        int n=nums1.size();
        unordered_mapm1;//改进：只用一个哈希表
        int temp1=0,temp2=0;
        for(int i=0;i

383. 赎金信

链接：代码随想录

 

注：先遍历ransomNote还是magzine考虑了半天，最后选择了先遍历ransomNote，理由

ransomNote是要检查的字符串，可能很短。实际代码随想录先遍历的magzine，两种都可以，只是这种我更容易想到。

class Solution {
public:
// 这不就是字母异位词
    bool canConstruct(string ransomNote, string magazine) {
        vectorv(26,0);
         for(auto ch:ransomNote)//先遍历需要检查的、可能很短的数组
        {
            v[ch-'a']++;
        }
         for(auto ch:magazine)
        {
            if(v[ch-'a']>0)
            {
              v[ch-'a']--;
            }
        }
       
       //如果v数组中还有v[index]>0，说明magzine数组中此元素的个数不够用
       for(int i=0;i<26;i++)
       {
           if(v[i]>0)
           {
               return false;
           }
       }
       return true;
    }
};

15. 三数之和

//这道题做了很多遍了，常看常不会

链接：代码随想录

注： 回忆起来的代码，这道题的难点在于，不重复的三元组，但是三元组中本身的元素又是可以重复的。比如数组[-4,-1,-1,-1,0,1,2,2,2],[-1,-1,2]这组满足要求。因为第一个-1要单独拿出来看,对于第一个元素，去找他之后无重复的两个数满足要求。

双指针是重点。如何去重是难点。

这个代码是错的！！！

class Solution {
public:
/*
大明湖畔出现了无数次的三数之和

答案中不可以包含重复的三元组。
*/

    vector> threeSum(vector& nums) {
        int n=nums.size();
        vector>v;
        sort(nums.begin(),nums.end());
        for(int i=0;i0 && nums[i]==nums[i-1])
            {
                continue;
            }
            int temp=0-nums[i];
            //双指针
            int left=i+1;
            int right=n-1;
            while(left

 

正确代码：

class Solution {
public:
    vector> threeSum(vector& nums) {
        vector> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return result;
            }
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                if (nums[i] + nums[left] + nums[right] > 0) right--;
                else if (nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector{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;
    }
};

 总结：总结一下我犯的错误。首先是死记硬背，可以看到两版代码里，我基本理解了去重这件事，但是细节都是模糊的，

比如在什么时候去重？要在nums[left]+nums[right]==temp时对nums[left]、nums[right]进行去重；

比如双指针到底怎么用？归根到底是下面这些代码，可以看到我用的稀巴烂。完全是抓了重点忘了细节；

//有那么一个需要比较的target
int target=temp;

while(left

18. 四数之和

题解链接：代码随想录

 

 

注：这道题可以转换成三数之和，但是同时要记得，对于重复的数，只计算第一个数，然后套用三数之和

class Solution {
public:
/*
类三数之和，我哭死
*/
     vector> v;
    vector> fourSum(vector& nums, int target) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        for(int i=0;i0 && nums[i]==nums[i-1])
            {
                continue;
            }

            //计算三数之和
             ThreeSum(nums,temp,i);
        }
        return v;

    }
   void ThreeSum(vectornums,long long target,int start_index)
   {
       //写三数之和
      
       for(int i=start_index+1;istart_index+1 && nums[i]==nums[i-1])
            {
                continue;
            }

            int left=i+1;
            int right=nums.size()-1;
            while(lefttemp)
                {
                    right--;
                }
                else
                {
                    left++;
                }
            }
       }

   }
};

 注：一开始这里直接写的>0,照抄的三数之和，不对，改成了i>start_index+1；

同时target和temp涉及负数，所以直接写成long long 比较好

 

代码随想录的答案太乱了。不想看。改成函数方式不好吗？