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

最新推荐文章于 2024-07-19 23:15:41 发布

isabelightL

最新推荐文章于 2024-07-19 23:15:41 发布

阅读量183

点赞数 1

分类专栏：代码随想录文章标签：散列表数据结构哈希算法

本文链接：https://blog.csdn.net/isabelightL/article/details/129377277

版权

代码随想录专栏收录该内容

42 篇文章 1 订阅

订阅专栏

总链接：7 第三章哈希表

454.四数相加II

链接：代码随想录

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

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

注：计算的是个数！不是index
*/
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n=nums1.size();
        unordered_map<int,int>m1,m2;
        int temp1=0,temp2=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                temp1=nums1[i]+nums2[j];
                temp2=nums3[i]+nums4[j];
                m1[temp1]++;
                m2[temp2]++;
            }
        }
        int k=0;
        for(auto p1:m1)
        {
          int temp=0-p1.first;
          auto p2=m2.find(temp);
          if(p2!=m2.end())
          {
              k+=(p1.second)*(p2->second);
          }
        }
        return k;

        
        

    }
};

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

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

注：计算的是个数！不是index
*/
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n=nums1.size();
        unordered_map<int,int>m1;//改进：只用一个哈希表
        int temp1=0,temp2=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                temp1=nums1[i]+nums2[j];
                m1[temp1]++;
            }
        }
        int k=0;
         for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                temp2=nums3[i]+nums4[j];
                if(m1.find(0-temp2)!=m1.end())
                {
                   k+=m1[0-temp2]; 
                }
                //k+=m1.count((0-temp2));//因为不考虑重复的情况，而是一个个计算,count不是计算value值而是计算有几个key，所以不对
            }
        }

        return k;

        
        

    }
};

383. 赎金信

链接：代码随想录

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

ransomNote是要检查的字符串，可能很短。实际代码随想录先遍历的magzine，两种都可以，只是这种我更容易想到。
class Solution {
public:
// 这不就是字母异位词
    bool canConstruct(string ransomNote, string magazine) {
        vector<int>v(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<vector<int>> threeSum(vector<int>& nums) {
        int n=nums.size();
        vector<vector<int>>v;
        sort(nums.begin(),nums.end());
        for(int i=0;i<n;i++)
        {
            if(i-1>0 && nums[i]==nums[i-1])
            {
                continue;
            }
            int temp=0-nums[i];
            //双指针
            int left=i+1;
            int right=n-1;
            while(left<right)
            {
                while(left<right && nums[left]==nums[left+1])
                {
                    left++;
                }

                while(left<right && nums[right]==nums[right-1])
                {
                    right--;
                }
                if(nums[left]+nums[right]==temp)
                {
                     v.push_back({i,left,right});
                }

            }
            
        }
        return v;



    }
};

正确代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> 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<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;
    }
};

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

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

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

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

while(left<right)
{

   if(nums[left]+nums[right]==target)
   {
       left++;
       right--;
   }
  else if(nums[left]+nums[right]<target)
  {
       left++;
       
  }
  else
 {
       right--;
 }

}

18. 四数之和

题解链接：代码随想录

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

class Solution {
public:
/*
类三数之和，我哭死
*/
     vector<vector<int>> v;
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        for(int i=0;i<n;i++)
        {
            long long temp=target-nums[i];//转换成三数之和！，但是应该也有去重问题，只计算第一个？
            if(i>0 && nums[i]==nums[i-1])
            {
                continue;
            }

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

    }
   void ThreeSum(vector<int>nums,long long target,int start_index)
   {
       //写三数之和
      
       for(int i=start_index+1;i<nums.size();i++)
       {
           long long temp=target-nums[i];
            if(i>start_index+1 && nums[i]==nums[i-1])
            {
                continue;
            }

            int left=i+1;
            int right=nums.size()-1;
            while(left<right)
            {
                if(nums[left]+nums[right]==temp)
                {
                    v.push_back({nums[start_index],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--;

                }
                else if(nums[left]+nums[right]>temp)
                {
                    right--;
                }
                else
                {
                    left++;
                }
            }
       }

   }
};

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

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

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