day07补卡|哈希表专题02|Leetcode454、383、15、18|四数之和、三数之和、赎金信、四数相加II

Leetcode454:四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/description/

题目分析：使用哈希map

ABCD四个数组 ；map1: A+B ; 查询0-(c+d)是否在map1内出现；O（n^2）

key:和(a+b;c+d) value 出现次数

如果对应c+d 能找到对应的map1的值；它的count应该加对应的value值

Java代码：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        HashMap map12sum = new HashMap<>();
        for (int n1 : nums1) {
            for (int n2 : nums2) {
                int sum = n1+n2;
                if(map12sum.containsKey(sum)){
                    map12sum.put(sum,map12sum.get(sum)+1);
                }else {
                    map12sum.put(sum,1);
                }
            }
        }
        HashMap mapCD = new HashMap<>();
        for (int n3 : nums3) {
            for (int n4 : nums4) {
                //也可以用map.getOrDefault()
                if (map12sum.containsKey(-n3-n4)){
                    count += map12sum.get(-n3-n4);
                }
            }
        }
        return count;
        

    }
}

---

Leetcode383:赎金信

题目链接：https://leetcode.cn/problems/ransom-note/description/

题目解析：原理和:有效的字母异位词相似，依旧是哈希数组实现

magzine字符串遍历字符，出现对应位置+1；ransomNote遍历字符，对应位置-1，同时判断更改位置字符value是否为负，如遇到负，直接false;

还有无序判断具体字符就可以得到答案的情况：

1.magzine

Java实现代码：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length()==0){
            return true;
        }
        if (magazine.length()==0  || ransomNote.length() > magazine.length()) {
            return false;
        }
        int[] record = new int[26];
        for(int i = 0;i

---

Leetcode15:三数之和（逻辑比较复杂，需要细心）

题目链接:https://leetcode.cn/problems/3sum/description/

 题目分析：

1. 要求结果集不重复，且元素不能重复使用，故需要对获取结果时进行去重处理，使用哈希很难考虑全面
2. 因为无需返回对应的下标，所以可以对数组先做排序，然后进行双指针left、right套for循环用i遍历数组；
3. 排序的原因：这样在判断时会提供便利
   1. 如果i 对应的nums[i]>0直接就退出，因为后续一定比>nums[i]>0,所以不会存在和为0的情况
   2. left---i+1;right--size-1  ;在 num[i]+num[left]+num[right]>0时 依次移动right 使和趋近于0；在 num[i]+num[left]+num[right]<0时 依次移动left使和趋近于0；
4. 去重机制
   1. 对 nums[i]去重：nums[i]  与nums[i-1] 的关系
   2. 对nums[left] nums[right]去重 ：在nums[i] 得到一个结果后，对left,right的移动机制很重要，具体代码内的实现逻辑如下
      • 得到一个结果集后，没有退出while(left
      • 如果下一个与前一个相等，就需要对其进行while ++、--；
      • 如果不等退出while，再进行++，--，进行下一次循环判断

Java实现代码:双指针+for

class Solution {
    public List> threeSum(int[] nums) {
        //创建空结果集
        List> result = new ArrayList<>();
        if (nums.length<2){
            return result;
        }
        //1.排序sort
        Arrays.sort(nums);
        //for遍历
        for (int i =0;i0，后面没有可能，直接退出
            if(nums[i]>0){
                return result;
            }
            //nums[i] 部分去重处理
            //容易遗忘细节：i>0,放置在i=0时i-1越界,且此条件要放在&&之前
            if((i>0)&&(nums[i] == nums[i-1])){
                continue;
            }
            //以上都满足了，开始此轮双指针判断
            int left = i+1;
            int right = nums.length -1;
            while (left0){
                    right--;
                }else if(nums[i]+nums[left]+nums[right]<0){
                    left++;
                }else{
                    //和为0，添加进结果集
                    List theadd = new ArrayList<>();
                    theadd.add(nums[i]);
                    theadd.add(nums[left]);
                    theadd.add(nums[right]);
                    result.add(theadd);
                    //当下一个left与lef相等时，且left

---

Leetcode18:四数之和

题目链接：https://leetcode.cn/problems/4sum/description/

与Leetcode454:四数相加II 比较 ：

1. 四数之和与三数之和类似，都是不能重复，只需要返回结果集，不需要对应索引
2. 而四数相加II是对四个数组中的元素进行和的判断，不存在元素重合问题，且要返回总数而不是具体值；

我们此题解题是在三数之和的求解思路的基础上进行解题：那么要注意的点有：

1. 四数之和，相当于在三数基础上套一个nums[k]:  nums[k] nums[i] nums[left] nums[right]
2. 主要细节点是剪枝与去重

• for(k) 剪枝  nums[k] > target && nums[k] > 0 && target >0   break;
• for(k) 去重  if（k>0 && nums[k] == nums[k-1] ） 进入下一层
• for(i)   剪枝要把 nums[k]+nums[i] 作为整体判断
• for(i) 去重  与三数之和逻辑相同 +   i>k+1
• left\right移动逻辑相同
• 取结果集需要  对其进行四个数相加

Java实现：

class Solution {
    public List> fourSum(int[] nums, int target) {
        List> result = new ArrayList<>();
        if(nums.length < 3){
            return result;
        } 
        Arrays.sort(nums);
        for(int k = 0;ktarget时进行取舍
            //需要转换为nums[k] > target && (nums[k] >=0 || target >= 0)
            if(nums[k]>target && (nums[k] >=0 || target >= 0)){
                break;
            }
            if(k>0 && nums[k] == nums[k-1]){
                continue;
            }
            for(int i = k+1;itarget && nums[i]>=0){
                    break;
                }
                //这里i>0 -> i>k+1(初始值)
                if(i>k+1 && nums[i] == nums[i-1]){
                    continue;
                }
                int left = i+1;
                int right = nums.length-1;
                while(lefttarget){
                        right--;
                    }else if(sum theadd = new ArrayList<>();
                        theadd.add(nums[k]);
                        theadd.add(nums[i]);
                        theadd.add(nums[left]);
                        theadd.add(nums[right]);
                        result.add(theadd);
                        while(left

此题，视频讲解基本听懂了，但是给出的java 实现代码，有剪枝并未实现，具体原因会进一步探究。