leetcode

最新推荐文章于 2025-12-20 22:59:04 发布

原创最新推荐文章于 2025-12-20 22:59:04 发布 · 59 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #哈希算法 #散列表

文章讲述了在编程中如何利用哈希表和双指针技巧解决四数相加和三数之和的问题，包括使用HashMap存储两两数组的和以及在三数之和和四数之和问题中的具体算法实现和优化。

代码随想录计划

Day 06–哈希表

四数相加 2

四数相加 II

思路是用map作为哈希表来存放两两数组的相加之和，再根据这个和出现的次数来累加count

这个一开始也没想到要存他们的和，而且用完还是双循环。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        Map<Integer,Integer> map = new HashMap<>();

        for(Integer num1 : nums1){
            for(Integer num2 : nums2){
                Integer temp = num1+num2;
                map.put(temp,map.getOrDefault(temp,0)+1);
            }
        }
        int count = 0;
        for(Integer num3 : nums3){
            for(Integer num4 : nums4){
                Integer temp = num3+num4;
                count += map.getOrDefault(0-temp,0);
            }
        }
        return count;
    }
}

赎金信

跟昨天做的字母异位词是一样的，也是规定了只有小写字母，那么直接定义一个长度26的数组来当哈希表

代码：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] hash = new int[26];

        for(int i = 0; i<magazine.length();i++){
            hash[magazine.charAt(i) - 'a']++;
        }


        for(int i = 0;i<ransomNote.length();i++){
            hash[ransomNote.charAt(i)-'a']--;
            if(hash[ransomNote.charAt(i)-'a'] < 0) return false;
        }

        return true;

    }
}

三数之和

这道题难点在于需要给出不重复的三元组，满足条件的三元组中，去重是一个大问题。

主要思想采取双指针的办法，但是光想到双指针还不行。想到双指针的同时要想到，应用双指针时，很有可能需要对数组排序。

虽然说不是所有双指针的题目都要对数组排序，但是当我们想利用双指针思想解决问题时，应该也要同时思考是否需要利用排序要对数组进行处理。

本题具体逻辑思路看下面代码

代码如下：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        
        Arrays.sort(nums); // 使用双指针时，要考虑是否需要排序

        for(int i=0;i<nums.length;i++){
            //如果排完序最小的都大于0 那么没有符合条件的三元组
            if(nums[i]>0) return result;
            //对 a + b +c 中 a的去重
            if(i>0 && nums[i] == nums[i-1]) continue;
            int left = i+1;
            int right = nums.length - 1;
            while(right>left){
                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]));
                    //做b和c的去重
                    while(right>left && nums[right] == nums[right - 1]) right--;
                    while(right>left && nums[left] == nums[left+1]) left++;
                    left++;
                    right--;
                }
            }
        }
        return result;

    }
}

四数之和

由于刚写完三数之和，写四数之和自然想到也用双指针。而且双指针将三数之和的复杂度从O(n^3) -> O(n^2) ，那么很容易会猜测四数之和的复杂度最终应该为O(n^3) 。想到这里应该会明白四数之和只不过是三数之和外面再加一个for循环。

同样是先排序，四数之和的结果为当前值 + 三数之和的结果是否等于 target。三数之和相当于四数之和的子问题。

代码：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new LinkedList<>();
        if(nums.length < 4) return result;
        Arrays.sort(nums);
        for(int a = 0 ;a<nums.length;a++){
            if(nums[a]>0 && nums[a]>target) return result;

            if(a>0&& nums[a] == nums[a-1]) continue;
            int sum = target - nums[a];
            for(int b = a+1;b <nums.length ;b++){
                if(nums[b] > 0 &&nums[b] > sum) break;

                if(b > a+1 && nums[b] == nums[b -1]) continue;
                int c = b +1;
                int d = nums.length -1;
                while(c<d){
                    int count = nums[b]+nums[c]+nums[d];
                    if(count > sum){
                        d--;
                    }else if(count <sum){
                        c++;
                    }else{
                        result.add(Arrays.asList(nums[a],nums[b],nums[c],nums[d]));
                        while(c<d&& nums[d] == nums[d - 1]) d--;
                        while(c<d&& nums[c] == nums[c + 1]) c++;
                        d--;
                        c++;
                    }
                } 
            }
        }
        return result;

    }
}