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<Integer,Integer> 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<Integer,Integer> 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<ransomNote,false 2.magzine==0 false; 3.ransomNote==0 true

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<magazine.length();i++){
            record[(int)(magazine.charAt(i)-'a')] +=1;
        }
        for(int i = 0;i<ransomNote.length();i++){
            record[(int)(ransomNote.charAt(i)-'a')] -=1; 
            if(record[(int)(ransomNote.charAt(i)-'a')]<0){
                return false;
            }
        }
        return true;
    }
}

---

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<right) 时，移动left,right前要对下一个left\right与刚提交的结果集中的两个指针进行重复性判断，
      • 如果下一个与前一个相等，就需要对其进行while ++、--；
      • 如果不等退出while，再进行++，--，进行下一次循环判断

Java实现代码:双指针+for

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //创建空结果集
        List<List<Integer>> result = new ArrayList<>();
        if (nums.length<2){
            return result;
        }
        //1.排序sort
        Arrays.sort(nums);
        //for遍历
        for (int i =0;i<nums.length-2;i++){
            //如果nums[i]>0，后面没有可能，直接退出
            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 (left<right){
                if(nums[i]+nums[left]+nums[right]>0){
                    right--;
                }else if(nums[i]+nums[left]+nums[right]<0){
                    left++;
                }else{
                    //和为0，添加进结果集
                    List<Integer> theadd = new ArrayList<>();
                    theadd.add(nums[i]);
                    theadd.add(nums[left]);
                    theadd.add(nums[right]);
                    result.add(theadd);
                    //当下一个left与lef相等时，且left<right不越界时，进行继续左移
                    while((left<right)&&(nums[right] == nums[right-1])){
                        right--;
                    }
                    //当下一个right与right相等时，且left<right不越界时，进行继续右移
                    while((left<right)&&(nums[left] == nums[left+1])){
                        left++;
                    }
                    //left与right均与上一个结果集不重复时，进行移动，进入下一轮循环；
                    right--;
                    left++;
                } 
            }
        }
        return result;
    }
}

---

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<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        if(nums.length < 3){
            return result;
        } 
        Arrays.sort(nums);
        for(int k = 0;k<nums.length-3;k++){
            //当nums[k] 为负，target也为负，就不能在nums[k]>target时进行取舍
            //需要转换为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;i<nums.length-2;i++){
                //carl的java 代码没有这个if?为什么没有添加会无影响；这一步属于二层剪枝
                if(nums[i]+nums[k]>target && 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(left<right){
                    //int会溢出换long存储
                    long sum = (long)nums[k]+nums[i]+nums[left]+nums[right];
                    if(sum>target){
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        List<Integer> theadd = new ArrayList<>();
                        theadd.add(nums[k]);
                        theadd.add(nums[i]);
                        theadd.add(nums[left]);
                        theadd.add(nums[right]);
                        result.add(theadd);
                        while(left<right && nums[right] == nums[right-1]){
                            right--;
                        }
                        while(left<right && nums[left] == nums[left+1]){
                            left++;
                        }
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;

    }
}

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