代码随想录第七天|454.四数相加、383.赎金信、15.三数之和、18.四数之和、小总结

题目链接：454. 四数相加 II - 力扣（LeetCode）

求解思路：将第一、第二个数组的每个数字相加存放于map表中，随即判断第三、第四个数组中的每个数字相加后的负值是否位于map表中，若有，令res+=对应map中key的值，最终返回即可，ac代码如下：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    Map<Integer,Integer> map = new HashMap<>();
    int temp;
    int res = 0;
    for(int i:nums1){
        for(int j:nums2){
            temp = i + j;
            if(map.containsKey(temp)){
                map.put(temp,map.get(temp)+1);
            }
            else{
                map.put(temp,1);
            }
        }
    }
    for(int i:nums3){
        for(int j:nums4){
            if(map.containsKey(0 - (i+j))){
                res += map.get( 0 -(i+j));
            }
        }
    }
    return res;
    }
}

---

题目链接：383. 赎金信 - 力扣（LeetCode）

初见思路：此题与之前的有效的字母异位词相似，都是使用一个数组来保存所有字母，然后在下一个字符串中判断能否实现即可

ac代码如下：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int []res = new int[26];
        for(int i = 0; i < ransomNote.length();i++){
            res[ransomNote.charAt(i)-'a']++;
        }
        for(int i = 0; i < magazine.length();i++){
            res[magazine.charAt(i)-'a']--;
        }
        for(int i = 0 ; i < 26;i++){
            if(res[i] > 0){
                return false;
            }
        }
        return true;
    }
}

---

题目链接：15. 三数之和 - 力扣（LeetCode）

看起来没啥思路，于是直接去看了题解，总结做题思路如下：

本题中需要判断一个整数数组中是否存在三元组使得他们的值相加为0，且同一个元素不能够多次使用，本题使用双指针法进行解答

首先对数组进行一次排序，排序后我们就可以使用初始位置，初始位置右侧，数组末尾来判断其值相加是否为0，具体如下：

在每次循环中，令左指针= i+1，右指针=nums.length-1,当三数相加小于0时，将左指针向右移动，大于0则将右指针向左移动，直至左右指针相遇

然而本题的难点在于如何求出**不重复的三元组，**我们可以通过如下方法来跳过重复：

1. 对于i的处理：我们要判断 当 nums[i-1] == nums[i] 时，令i++，以此来跳过重复的元素。 注意此处不能够判断 nums[i] == nums[i+1]，否则会跳过[-1,-1,2]类似的结果。
2. 对于左右指针，当下一个值与得出的答案值相同时，令其向相应的位置移动。

具体ac代码如下：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {

        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        if(nums.length < 3 || nums[0] > 0){
            return result;
        }
        for(int i = 0; i< nums.length;i++){
            if(nums[i] > 0){
                return result;
            }
            //去重
            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 {
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    while(left < right && nums[right-1] == nums[right]){
                        right--;
                    }
                    while(left < right && nums[left+1] == nums[left]){
                        left++;
                    }
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

---

题目链接：18. 四数之和 - 力扣（LeetCode）

本题与上一题三数之和相似，本次使用两次循环确定前两个数字，后面的两个数字同样使用双指针法进行确定，与上一道题完全一样的配方，但此处应当注意

1. 本题中要注意不能使用nums[i] > target相同进行剪枝，这是由于可能为负值，如 -4 -3 -2 -1 target为-10 ，此处应当判断其nums[i]值为正数进行剪枝。
2. 同样的，在进行去重操作时，在第一层循环需要进行判断，在第二层循环中同样需要进行判断
3. 在进行左右指针的去重时，要注意我们此刻使用while判断，这是因为重复值是需要被不断删除的。

ac代码如下：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        if(nums.length < 4){
            return result;
        }

        for(int i = 0; i < nums.length;i++){
            if(nums[i] > target && nums[i] > 0){
                return result;
            }
            if( i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            for(int j = i+1;j < nums.length;j++){
                if(j > i+1 && nums[j-1] == nums[j]){
                    continue;
                }
                int left = j + 1;
                int right = nums.length-1;
                while(left < right){
                    if(nums[i] + nums[j] + nums[left] + nums[right] > target){
                        right--;
                    }
                    else if(nums[i] + nums[j] + nums[left] + nums[right] < target){
                        left++;
                    }
                    else{
                        result.add(Arrays.asList(nums[i] , nums[j] , nums[left] , nums[right]));
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        while(left < right && nums[right] == nums[right-1]){
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

---

哈希表通常用来快速判断一个元素是否在出现在集合中

要知道哈希函数和哈希碰撞在哈希表中的作用

以下是常见的三种哈希结构：

• 数组
• set（集合）
• map（映射）

以下为Java中具体的哈希相关的使用，需要使用时应当能够回想起这个图

同时应该清晰具体的STL的底层实现（看源码）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ALtzapmq-1668437368415)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/9126126c-53dd-4a18-b699-aa0440f32908/Untitled.png)]

数组作为哈希表：

在如同在一些受限制的元素个数中，使用数组对问题进行处理是一个好的办法，它更加的简单且有效

set（集合）作为哈希表：

当元素个数不受限制时，此时就必须使用set来对问题进行处理了，这主要是由于以下几点造成的：

• 数组大小有限，受到系统栈空间的限制
• 若元素跨度较大，使用数组会造成较大的空间浪费

map作为哈希表：

由于数组和set存在一些局限，如以下几点：

• 数组大小是收到限制的，当元素个数很少时，哈希值太大会造成内存空间的浪费
• set为一个集合，里面只能够存放一个key，而没有value，在两数之和这道题中，我们不仅需要知道他存在，还需要知道他存在的位置，这种情况下就需要使用 map进行数据存储