day07：哈希表应用2|454.四数相加II 、383. 赎金信、15. 三数之和、18. 四数之和

测试的艺术

已于 2024-05-14 21:17:38 修改

阅读量573

点赞数 23

文章标签：散列表数据结构算法

于 2024-05-14 20:56:58 首次发布

本文链接：https://blog.csdn.net/qq_39522022/article/details/138817927

版权

相关题目：
● 454.四数相加II
● 383. 赎金信
● 15. 三数之和
● 18. 四数之和

四数相加II

思路

暴力思想：使用四层循环进行解决，按照一定的顺序在四个数组中去四位数，判断四个数之和是否为0，计数加一。

实现过程

public static int fourSumCount(int[] nums1,int[] nums2,int[] nums3,int[] nums4){
        int count = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                for (int k = 0; k < nums3.length; k++) {
                    for (int l = 0; l < nums4.length; l++) {
                        if (nums1[i] + nums2[j] + nums3[k]+nums4[l] == 0) {
                            count++;
                        }
                    }
                }
            }
        }
        return count;
    }

问题：时间复杂度为O(n^4)当数组元素过多时，时间超出时间限制
在这里插入图片描述

随想录解法

将暴力解法的时间复杂度将为O(n^2)，思路为：
计算前两个数组的各个元素之和并将及其结果出现的次数存放在map当中。
计算后两个数组各个元素之和，然后在map中查找0-(后两个数组各个元素之和)的元素出现的次数，然后计数加上对应的次数
实现过程：

public static int fourSumCount(int[] nums1,int[] nums2,int[] nums3,int[] nums4){
        int count = 0;
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                int sum1 = nums1[i]+nums2[j];
//                if(!map.containsKey(sum1)){
//                    map.put(sum1,1);
//                }
//                else {
//                    map.put(sum1,map.get(sum1)+1);
//                }
                map.put(sum1,map.getOrDefault(sum1,0)+1);
            }
        }
        for (int i = 0; i < nums3.length; i++) {
            for (int j = 0; j < nums4.length; j++) {
                int sum2 = nums3[i]+nums4[j];
                if(map.containsKey(0-sum2)){
                    count+=map.get(0-sum2);
                }
            }
        }
        return count;
    }

总结：

四数相加题目是哈希表应用的经典题目，该题目的实现方式类似于“两数之和”，但又存在些许差异，其基本思想必须要掌握
代码相关知识：掌握使用map.getOrDefault(Object key, V defaultValue)简化代码

赎金信

思路：该题目的解决方法我参考的是“有效字母异位词”的解法，思路如下：

遍历magazine中的各个字符，由于两个字符串都是用小写字符构成，所以可以使用int[26]进行存储对应字符-‘a’下标的值进行加一操作，及出现过字符的个数
遍历ransomNote中各个字符，操作int[26]数组，各个字符-‘a’ 为下标的位置元素进行减一操作
遍历int[26]数组，判断各个下标位置的值是否有小于0的，若有则返回false，没有就返回ture

实现过程:

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

三数之和

力扣链接
题目要求：给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

实现思路

方法1：使用哈希表进行解决，难点在于去重

思路：遍历第一个数组和第二个数组，将结果映射到哈希表中，遍历第三个数组，哈希表中找等于0-nums3[i] 的元素，如果找到，输出这三个数，并与结果集中的数据进行判断（去重），判断这三个元素是否与结果集中的某个三元素数据相同
这个思路的难点在于如何去重

方法2：使用双指针

思路：

对数组元素进行排序
遍历已排序的数组（for循环），获取第一个元素A，
对A去重，由于对数组以进行排序，因此与A相同的元素一定在A的前边或者后边，对A去重，分为两种：
（1）判断nums[i] == nums[i-1]
（2）判断nums[i] == nums[i+1]
到底是哪一种呢：
如果使用第二种，与第4点中的left重复，因此选择第一种，只需判断nums[i] 是否等于nums[i-1]即可（前提i>0），如果nums[i] == nums[i-1]，说明此A元素已经用过，去取下一个A即可（continue）
定义两个指针left和right，分别指向指向i+1和len-1的位置，获取第二个元素B和第三个元素C
判断i位置、left位置、rigth位置三个元素之和是否等于0
三个元素之和大于0：right–
三个元素之和小于0：left++
三个元素之和等于0：输出三个元素组成的三元组
对B和C去重：如数组定义为：[0, -1, -1, -1, 1, 1, 1]，这个例子只有一个结果集：[0, -1, 0]，当我们收获了第一个结果集[0, -1, 1]后，left和right按理讲都往里面收缩一下。但不一定只是一下，如果只收缩一下，那就可能会重复收割相同的结果集。所以，left和right是循环收缩的，直到left和rigth位置的值不重复为止。

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]> 0 ) return res;
            //对A去重
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }
            int left = i+1;
            int right = nums.length-1;
            while(left<right){
                int sum = nums[i]+nums[left]+nums[right];
                if(sum > 0){
                    right--;
                }
                else if(sum < 0){
                    left++;
                }
                else{
                    res.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    while(right>left&&nums[left] == nums[left+1]){
                        left++;
                    }
                    while(right>left&&nums[right] == nums[right-1]){
                        right--;
                    }
                    left++;
                    right--;
                }
            }

        }
        return res;
    }

总结：掌握sort所在的类Arrays
掌握数组转化为List Arrays.asList(数组元素)

进阶

使用set存结果集，使用set的去重功能

 public static List<List<Integer>> threeSum(int[] nums) {
        Set<List<Integer>> set = new HashSet<>();
        //List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]>0)
            	 return set.stream().collect(Collectors.toList());
            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{
                    List<Integer> list= new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    set.add(list);
                    left++;
                    right--;
                }
            }
        }
        return set.stream().collect(Collectors.toList());
    }

四数之和

该题目为三数之和的变形版，因此解题思路和三数之和思路一致，不同点是需要考虑四位数相加的情况
难点去重
实现过程如下:

public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
       
        for (int i = 0; i < nums.length; i++) {
		
            // nums[i] > target 直接返回, 剪枝操作
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
		
            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
		    // nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        result.add(Arrays.asList(nums[i], nums[j], 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++;

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }

总结

求数组中n个数相加等于目标元素，符合条件的元组个数—使用哈希表（map）进行解题
求数组中n个数相加等于目标元素的元组数并输出符合条件的元组（无需考虑去重）—使用哈希表或双指针进行求解
求数组中n个数相加等于目标元素的元组数并输出符合条件的元组（需要考虑去重）—建议使用双指针进行求解

哈希表的总结：哈希表常用于判断集合中是否存在某个元素

数组或List

常用于数组长度或数值大小有限制的情况，如：
242.有效的字母异位词 (opens new window)中，题目给出字母的范围：都是小写字母，因此使用数组来做哈希最合适不过。
383.赎金信 (opens new window)中同样要求只有小写字母，那么就给我们浓浓的暗示，用数组！
再如：349. 两个数组的交集 (opens new window)中题目没有限制数值的大小，就无法使用数组来做哈希表了。原因有如下如下两点：
4. 数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
5. 如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

set

常用于数据没有大小限制，且需要对结果去重的情况
如：在202.快乐数 (opens new window)中，我们再次使用了set来判断一个数是否重复出现过
使用数组和set来做哈希法的局限性：

数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

map

map是一种<key, value>的结构，用key保存数值，用value在保存数值所在的下标的情况时使用map最为合适。
如：1.两数之和需要输出元素对应的下标时，可以使用key保存数值，用value在保存数值所在的下标
454.四数相加 (opens new window)中我们提到了其实需要哈希的地方都能找到map的身影
而在三数之和、四数之和的题目中需要对元组数据进行去重，使用哈希表进行解题就比较困难，因此我们引入了双指针来解就很淡然了

在这里插入图片描述