第三章 哈希表part02

 今日任务 

•  454.四数相加II 

•  383. 赎金信 

•  15. 三数之和 

•  18. 四数之和 

•  总结  

 详细布置 

 454.四数相加II 

建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间 换时间， 工业开发也是这样。

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

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {

        // 因为最后求得是四个数字的和是否是0，所以可以在统计ab的遍历和
//，以及其重复次数后，找cd中能匹配为0，的数组，的交叉总数
        unordered_map<int,int> summap;
        for (int a : nums1){
            for(int b : nums2){
                summap[a + b]++;
            }
        }
        int count = 0;
        for(int c: nums3){
            for(int d:nums4){
                if(summap.find(0-(c + d)) != summap.end()){
                        count += summap[0-(c+d)];
                        // 要注意0-（c+d）对应的a+b不一定只有一次
                }
            }
        }
        return count;
    }
};

  383. 赎金信  

建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题 

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

 

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
         int record[26] = {};

         for(int i = 0; i<magazine.size();i++ ){
             record[magazine[i] - 'a']++;
         }
         for(int j = 0; j < ransomNote.size();j++){
             record[ransomNote[j]-'a']--;
         }
         for(int k = 0 ; k<26; k++){
             if(record[k]<0){
                 return false;
             }
         }
         return true;
    }
};

 

 15. 三数之和 

建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。 

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

 

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++){
            // 当最小数字都小于0的时候，那必然不成功，直接false
            if(nums[i]>0){
                return result;
            }

            if(i > 0 && nums[i] == nums[i - 1]){
                continue;
                // 也就是如果这个nums[i]和前边的nums[i-1]要是相同，我们就直接下个循环，不需要讨论这个
            }
            // 初始化left从剩下那一段左边开始，right从右边也就是结尾开始
            int left = i + 1; 
            int right = nums.size() - 1;
            // 循环到right和left指针碰面
            while (right > 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]});
                // result.push_back(...): 将上面创建的向量添加到 result 这个向量数组中
                // 然后循环掉所有重复的左右，然后继续下一循环。
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    right --;
                    left ++;
                } 
            }


        }
        return result;
    }
};

 

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++){
        // nums[k]>=0是为了缩小nums[k] > target的范围, 只有一部分nums[k] > target才会算不出target,
        // 只有一部分nums[k] > target才会算不出target
            if(nums[k]>target && nums[k] >= 0){
                break;
            }
            if(k>0 && nums[k] == nums[k-1]){
                continue;
            }//K》0因为第一个指针必然不重复
        // 第二个指针
            for(int i = k + 1; i < nums.size();i++){

                if(nums[k]+nums[i] > target && nums[k]+nums[i]>=0){
                    break;
                }
                if(i > k + 1 && nums[i] == nums[i - 1]){
                    continue;
                }
            // 区别不大
                int left = i+1;
                int right = nums.size()-1;
                while(right > left){
                    if((long)nums[k]+nums[i]+nums[right]+nums[left]>target){
                        right--;
                    }else if((long)nums[k]+nums[i]+nums[right]+nums[left]<target){
                        left++;
                    }else{
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对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. 四数之和  

建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。 

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