代码随想录算法训练营 DAY7|454.四数相加II 383.赎金信 15.三数之和 18.四数之和

最新推荐文章于 2024-07-24 22:50:16 发布

林酽

最新推荐文章于 2024-07-24 22:50:16 发布

阅读量939

点赞数 14

文章标签：算法 java 哈希表

本文链接：https://blog.csdn.net/qq_35904005/article/details/136659083

版权

本文介绍了LeetCode中的4Sum和4SumII问题的解题思路，包括暴力法的O(n^4)复杂度，以及通过哈希表和双指针优化至O(n^2)的方法。重点讨论了如何通过map进行计数和去重，以及三数之和和四数之和的相似解题策略。

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

454.四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/description/

视频链接：https://www.bilibili.com/video/BV1Md4y1Q7Yh/?spm_id_from=333.788&vd_source=80cf8293f27c076730af6c32ceeb2689

讲解链接：https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html

思路讲解

理解：题目只要求返回所有可能的个数，用一个count计数即可。

暴力法：四个for循环遍历4个数组。O(n^4)

怎么优化？考虑只遍历1,2数组，取出a+b，然后遍历3,4数组，看0-(c+d)是否在哈希表里。
同时还要统计a+b这个数值一共出现了多少次！—出现一次就代表a和b的一种组合。

所以选择用map来存。key 存a+b ，value存a+b出现的次数。统计3,4数组时，查到一次，count += 0-(a+b)出现的次数（不是直接count++！！！）。这样是O(n^2)。

//根据key查询对应value，查不到就返回传的默认值（第二个参数）
map.getOrDefault(key,defaultValue);

第一次放进去的时候，getOrDefault(sum,0)结果为0，所以是map.put(sum, 0 + 1);

第二次放进去的时候，getOrDefault(sum,0)查到了，value是1，所以是map.put(sum, 1 + 1);

…

遍历3,4查询的时候，直接count += map.getOrDefault(0-(i+j),0) 查到了就是count+=0，没查到就是count+=出现的次数

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        int count = 0;
        for(int i : nums1) {
            for(int j : nums2) {
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum,0) + 1);
            }
        }

        for(int i : nums3) {
            for(int j : nums4) {
                count += map.getOrDefault(0-(i+j),0);
            }
        }
        return count;
    }
}

383.赎金信

题目链接：https://leetcode.cn/problems/ransom-note/description/

讲解链接：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html#%E6%80%9D%E8%B7%AF

思路

这题很简单。用数组或者map都可以。

都是小写字母，考虑用数组哈希表。

遍历magazine中的字符，存到int hash[26]对应位置，同时统计出现次数。

遍历rensomNote中的，用一次就对应位置hash数组–。最后看数组里是否出现负数，有就false。否则return true。

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']--;
        }
        for(int i : hash) {
            if(i < 0) return false;
        }
        return true;
    }
}

15.三数之和

题目链接：https://leetcode.cn/problems/3sum/description/

视频链接：https://www.bilibili.com/video/BV1GW4y127qo/?spm_id_from=333.788&vd_source=80cf8293f27c076730af6c32ceeb2689

讲解链接：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

难点在于如何去重，哈希表不容易做。

双指针法

要先对数组进行排序（因为不用返回下标，直接返回三元组即可）。

为什么要先排序？–方便通过三个数的和来移动left或right进行放缩

数组是从小---->大！

在这里插入图片描述

遍历i，每次拿着nums[i]去找nums[left]和nums[right]。

如果nums[i]+nums[left]+nums[right]>0，就right–
如果nums[i]+nums[left]+nums[right]<0，就left++
如果nums[i]+nums[left]+nums[right]=0，就找到了一组结果

但是要注意去重！！！例如[1,2,3]和[1,3,2]是重复的。但是三元组里的元素是可以重复的，如[0,0,0]

细节部分和去重

首先排序Arrays.sort(nums);

for(i=0; i<nums.length; i++)
	if(nums[i]>0) return;  //提前退出，如果已经大于0直接返回（排好序了的）

第一步去重：对a

我们是判断nums[i]==nums[i+1]还是nums[i]==nums[i-1]呢？

如果是nums[i]==nums[i+1]，考虑[-1,-1,2]分别为i,left,right的情况，这样的话直接continue了，显然不对。
如果是nums[i]==nums[i-1]，还是考虑上面的情况，此时不会跳过，当i遍历到第二个-1的时候才会跳过！！！！

第一步去重操作：if(i>0 && nums[i]==nums[i-1]) continue； 跳过这个i，直接到下一个

接着初始化left和right指针left=i+1; right=nums.size-1;

接下来进到while循环判断缩小left和right范围。

while条件的边界写什么？while(right ? left)

不放带入试一下，如果right=left了，题目要求三个索引互不相等，显然这时候不要进while里了。

应该是while(right > left)

在while里不断移动left和right指针，找nums[i]+nums[left]+nums[right]=0的情况。

然后把这个三元组添加到result中。

第二步去重：对b和c

收获结果三元组的时候，也要进行去重。

考虑这种情况：

在这里插入图片描述

因此在收获了一个[-1,0,1]的结果后，要进行去重。不断移动left和right到它们的值都变了为止

//收获完一个结果集后，要去重
if(right > left && nums[right] == nums[right-1]) right--;
if(right > left && nums[left] == nums[left++]) left++;

为什么第二次去重要保证放在收获一个结果集之后？

举例：[0,0,0,0,0]如果在收获之前就去重，left和right会一直移动知道退出while，都没有收获结果！！

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++) {
            //提前终止：因为数组是排序了的
            if(nums[i] > 0) return result;
            if(i > 0 && nums[i] == nums[i-1]) continue;   //这个i和它前面一个相等 就跳过
            int left = i + 1;
            int right = nums.length - 1;
            while(right > left) {
                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]));
                    //收集完之后再对b c去重，持续移动l和r直到和收集到的值不一样
                    while(right > left && nums[right] == nums[right-1]) right--;
                    while(right > left && nums[left] == nums[left+1]) left++;
                    //到这里right和left还是指向相同值，需要再移动一次
                    right--; 
                    left++;
                }
            }
        }
        return result;
    }
}

18.四数之和

题目链接：https://leetcode.cn/problems/4sum/description/

视频链接：https://www.bilibili.com/video/BV1DS4y147US/?spm_id_from=333.788&vd_source=80cf8293f27c076730af6c32ceeb2689

讲解链接：https://programmercarl.com/0018.%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

思路

在这里插入图片描述

和三数之和思路差不多，就是i的遍历变成了i和k，两层for的遍历。注意这里是和为target，不是为0，所以剪枝操作略有不同。

剪枝和去重

不能用nums[i]>target直接剪枝！例如[-4,-1,0,0] target = -5，这样就错过了。有前提条件：nums[i] > 0 && target > 0 && nums[i] > target才能剪枝。

多了一次去重，在第一层for(i)的循环，后面就和三数之和一样了。

注意是先for(i)，去重之后，再for(j)！！！！

对于j的剪枝：num[i]+nums[j]>0 && target > 0 && nums[i]+nums[j]>0

class Solution {
    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;
    }
}

day7总结

list操作：

在这里插入图片描述

Arrays.asList(num1,num2,num3)可以把几个数转换成list返回！
map.getOrDefault(key,默认值) 如果有对应的key，返回value，如果没有返回默认值。可以用来简化统计出现次数的操作。
三数之和和四数之和思路相近，都是遍历一个i或者i和j，拿着这个，用双指针对后面的进行判断。去重和剪枝的细节需要注意。

林酽

关注

14
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营 DAY7|454.四数相加II 383.赎金信 15.三数之和 18.四数之和

list操作：Arrays.asList(num1,num2,num3)可以把几个数转换成list返回！map.getOrDefault(key,默认值)如果有对应的key，返回value，如果没有返回默认值。可以用来简化统计出现次数的操作。三数之和和四数之和思路相近，都是遍历一个i或者i和j，拿着这个，用双指针对后面的进行判断。去重和剪枝的细节需要注意。
复制链接

扫一扫