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

最新推荐文章于 2024-11-02 15:25:13 发布

龙崎流河

最新推荐文章于 2024-11-02 15:25:13 发布

阅读量390

点赞数 2

分类专栏：哈希表代码随想录文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/Jiaodaqiaobiluo/article/details/128710576

版权

代码随想录同时被 2 个专栏收录

57 篇文章 1 订阅

订阅专栏

哈希表

2 篇文章 0 订阅

订阅专栏

文章介绍了使用哈希表和数组来解决编程问题中的求和问题，如四数相加II、赎金信、三数之和以及四数之和。对于这些题目的解决方案，强调了哈希表在存储和查找两数之和中的效率，以及双指针法在处理排序数组时避免重复和优化时间复杂度的作用。

摘要由CSDN通过智能技术生成

454. 四数相加 II

在这里插入图片描述
巧用哈希表，哈希表键值对对应的是两数之和，两数之和出现次数。

首先定义一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
最后返回统计值 count 就可以了

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int temp1:nums1){
            for(int temp2:nums2){
                int sum = temp1 + temp2;
                if(!map.containsKey(sum)){
                    map.put(sum,1);
                }else{
                    map.put(sum,map.get(sum)+1);
                }
            }
        }
        int res = 0;
        for(int temp3:nums3){
            for(int temp4:nums4){
                //遍历四种组合
                int sum = temp3 + temp4;
                if(map.containsKey(0-sum)){
                    
                    res += map.get(0-sum);
                }
            }
        }
        return res;
    }
}

在这里插入图片描述

383. 赎金信

在这里插入图片描述
还是数组哈希解法，很简单不再概述

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

在这里插入图片描述

15. 三数之和

其实这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。
而且使用哈希法在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长。
该题目采用双指针法。
首先排好序，固定一个指针（遍历一遍），其余两个指针分别为左指针右指针，该题注意去重操作，三个指针都要去重。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for(int i = 0;i < nums.length;i++){
            //如果第一个元素大于0，就无从凑成三元组
            if(nums[i] > 0) return result;
            if(i > 0 && nums[i-1] == nums[i]) 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{
                    result.add(Arrays.asList(nums[i],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;
    }
}

在这里插入图片描述

18. 四数之和

在这里插入图片描述

思路和上一道三数之和完全相同，忽略了一个例子。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        for(int i = 0;i < nums.length;i++){
            if(i > 0 && nums[i] == nums[i - 1]) continue;
          
            for(int j = i + 1;j < nums.length;j++){
            //这块j > i + 1需要注意
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                int sum = target - nums[i] - nums[j];
                int left = j + 1;
                int right = nums.length - 1;
                while(left < right){
                    if(sum > nums[left] + nums[right]){
                        left++;
                    }else if(sum < nums[left] + nums[right]){
                        right--;
                    }else{
                        list.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 list;
}
}

在这里插入图片描述
Integer的最大值十位数2147483647，最小值-2147483647

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        for(int i = 0;i < nums.length;i++){
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            for(int j = i + 1;j < nums.length;j++){
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                //target减去nums[i]+nums[j]的和小于最小值，需强制类型转化
                long sum = target - nums[i] - (long)nums[j];
                int left = j + 1;
                int right = nums.length - 1;
                while(left < right){
                    long temp = nums[left] + nums[right];
                    if(sum > temp){
                        left++;
                    }else if(sum < temp){
                        right--;
                    }else{
                        list.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 list;
}
}