Day6|454.四数相加II/383. 赎金信/15. 三数之和/18. 四数之和

454.四数相加II 
 

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

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

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

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

思路:
        选择遍历数组nums1和nums2中的元素相加, 存在哈希表中, Key值为元素和, Value值为出现的次数, 每出现一次就加1.
        然后再遍历nums3和nums4数组, 由满足四个元素相加为 0 可知数组nums3和数组nums4的相反数一定出现在哈希表中, 如果没有出现就说明哈希表中不存在满足条件的值, 即数组nums1和数组nums2一定不能满足条件.
        最后通过返回哈希表里Value的值判断到底有几个元组能满足条件.

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> sum_ab;
        //构建哈希表
        for(int i : nums1){
            for(int j : nums2){
                sum_ab[i+j]++;
            }
        }
        
        //查找
        int count = 0;
        for(int i : nums3){
            for(int j : nums4){
                int  k = - i - j;
                // find函数返回的是指针
                if( sum_ab.find(k) != sum_ab.end() )
                    count += sum_ab[k];
            }
        }
        return count;
    }
};

 383. 赎金信  

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

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

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

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

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

思路:
        有效的字母异位词, 创建一个result[26] = {0};来存储内容, 需要注意的是通过某个字符作为索引取值时, 格式应该是result(char - 'a'), 这里的char不需要使用 ' ' 号!

        如果做了有效的字母异位词, 那么这道题的思路很简单, 就是创建一个哈希表来存取magazine里的字符和字符出现的次数,  然后遍历ransomNote的时候每遍历到一个英文字母, 对应的Value就减少1, 如果出现有Value为负值的就直接返回false, 否则返回true.

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int result[26] = {0};
        for(char i : magazine){
            result[i - 'a']++;
        } 

        for(char i : ransomNote){
            --result[i - 'a'];
            if(result[i - 'a'] < 0) return false;
        }
        return true;
    }
};

 15. 三数之和 

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

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

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

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

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

思路:

        这道题真的是梦破碎的地方. 理解了思路之后也不能很容易的做出来, 剪枝去重真的很难以考虑周全.

        先对初始数组进行排序.

        首先使用 i 循环遍历整个数组,这里就需要考虑到剪枝问题:

• 如果 nums[i] > 0, 直接就返回 result 三元结果数组.
• 如果 i > 0 的时候, nums[i] == nums[i-1], 在for循环里 continue 直接 i++.

在循环中使用双指针法, left和right分别从 i + 1 和 nums.size - 1开始遍历. 通过判断条件nums[i] + nums[left] + nums[right] 与 0 的关系来决定移动哪个指针:

• 如果nums[i] + nums[left] + nums[right] > 0,说明right指针对应的值较大,right--
• 如果nums[i] + nums[left] + nums[right] < 0,说明left指针对应的值较小,left++
• 如果nums[i] + nums[left] + nums[right] = 0,要考虑去重
  • 如果 left < right && nums[right] == nums[right - 1]; right --
  • 如果 left < right && nums[left] == nums[left + 1]; left ++
  • 去重后, 也就是找到了目标三元结果数组, 压入结果数组:
    result.push_back(vector<int>(nums[i],nums[left],nums[right]));
  • 找到了目标三元结果数组, 双指针都向内进:
    right--;
    left++;

        

代码:

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;

            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i + 1 ;
            int right = nums.size() - 1;

            while(left < 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]});
                        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 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。 

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

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

思路:

        原本以为理解了三数之和后再去做这道题会变得简单一点, 结果真的就只简单了一点.

难就难在剪枝和去重.. 感觉真的很难:

        在原来的基础上再加上一层循环, 只不过就多了一层剪枝, 这个剪枝也有点回溯的感觉?

一层递归老样子:

• 如果 nums[i] > target > 0, 直接就返回 result 三元结果数组.
• 如果 i > 0 的时候, nums[i] == nums[i-1], 在for循环里 continue 直接 i++.

第二层递归就需要注意了:

• 如果 nums[i] + nums[j] > target > 0 && num[j] > 0, 就返回一层 i++.
• 如果 j > 0 的时候, nums[i] == nums[i-1], 在for循环里 continue 直接 j++.

比之三数之和, 本题的测试案例会给数据

在计算num[i] + nums[j] + nums[left] + nums[right] 与 target 的关系时, 记将左边转换为long型

        (long)num[i] + nums[j] + nums[left] + nums[right] > target;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++){
            // 一层剪枝 
            if(nums[i] > 0 && nums[i] > target && target > 0) return result;
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            
            for(int j = i + 1; j < nums.size(); j++){
                // 二层剪枝
                if(nums[i] + nums[j] > target && nums[j] > 0) break;
                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{
                        while(left < right && nums[left] == nums[left + 1]) left++;
                        while(left < right && nums[right] == nums[right - 1]) right--;
                        result.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});

                        left++;
                        right--;
                    }
                }

            }
            
        }
        return result;
    }
};

        10.17的任务拖到了10.18来写, 主要还是昨天在总结哈希表结构的map容器和set容器的一些用法和逻辑, 今天还有任务, 继续加油. 

        三数之和和四数之和的剪枝去重以及双指针法真是令人拍案叫绝, 非常震撼.