刷题计划day7 哈希表下【四数相加II，三数之和，四数之和】

最新推荐文章于 2024-10-17 11:39:06 发布

哈哈哈的懒羊羊

最新推荐文章于 2024-10-17 11:39:06 发布

阅读量773

点赞数 27

分类专栏： leetcode从0开始刷题计划及刷题笔记文章标签：算法散列表哈希算法数据结构蓝桥杯 leetcode java

本文链接：https://blog.csdn.net/weixin_72499901/article/details/141030188

版权

leetcode从0开始刷题计划及刷题笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

前言

一杯咖啡一根烟，一道力扣写一天。一顿操作猛如虎，一看击败百分五。

⚡刷题计划day7继续，可以点个免费的赞哦~

往期可看专栏，关注不迷路，

您的支持是我的最大动力🌹~

⚡刷题计划day6继续，可以点个免费的赞哦~

相关知识点上期末尾已讲解，有所遗忘的可以看专栏往期

废话不多说，直接开干

题目一：四数相加 II

leetcode：454. 四数相加 II

(https://leetcode.cn/problems/4sum-ii/description/)

本题是使用哈希法的经典题目，而下面的15.三数之和，18.四数之和，并不合适使用哈希法，因为三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的，很有多细节需要处理。

而这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！

初看好像没那么简单，细看思路其实大体和我们上一期的两数之和相似。

本题解题步骤：

首先定义一个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 就可以了

代码中有详细注释

AC代码

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0; // 初始化结果变量，用于计数和为0的组合数量

        // 创建一个HashMap用于存储两个数组元素对的和以及其出现的次数
        Map<Integer, Integer> map = new HashMap<>();

        // 遍历数组nums1和nums2，计算每对元素的和
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j; // 计算当前元素对的和

                // 使用map.put更新sum对应的计数，如果sum不在map中，则默认从0开始计数
                // map.getOrDefault(sum, 0)获取sum的当前计数，如果不存在则为0，然后加1
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }

        // 遍历数组nums3和nums4，计算每对元素的和，并检查这些和的相反数是否在map中
        for (int i : nums3) {
            for (int j : nums4) {
                int negativeSum = 0 - i - j; // 计算当前元素对的和的相反数

                // 使用map.getOrDefault检查和为negativeSum的元素对在map中的计数
                // 如果存在，说明找到了一个和为0的四元组，将对应的计数加到结果res上
                // 如果不存在，getOrDefault返回0，对res没有影响
                res += map.getOrDefault(negativeSum, 0);
            }
        }

        // 返回找到的和为0的四元组的总数
        return res;
    }
}

题目二：5. 三数之和【百度一面】

leetcode：15. 三数之和

（https://leetcode.cn/problems/3sum/description/)

开始感觉有点像上一期两数之和，然后用哈希解法，发现不太可行。

法一：哈希解法（此题不推荐）

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。

把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。

去重的过程不好处理，有很多小细节，如果在面试中很难想到位。

时间复杂度可以做到O(n^2)，但还是比较费时的，因为不好做剪枝操作。

大家可以尝试使用哈希法写一写，就知道其困难的程度了。

法二：双指针

如图，首先将数组排序，然后有一层c循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

有几点需要注意理解，看题：

1.三元组下标不等：i != j、i != k 且 j != k

2.三元组相加为0：值一定会有非正输出

3.三元组不重复：[nums[i], nums[j], nums[k]]，三元组是外边的[]，里面的三个数组值是可以重复的

关于去重：

说到去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]

a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。

但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。

有同学可能想，这不都一样吗。

其实不一样！

都是和 nums[i]进行比较，是比较它的前一个，还是比较它的后一个。

如果我们的写法是这样：

if (nums[i] == nums[i + 1]) { // 去重操作
    continue;
}

那我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断下一个也是-1，那这组数据就pass了。（意思就是如果是第一个三元组{-1, -1 ,2}是可以的，如果再来一个三元组是{-1, -1 ,2}就重复了）

我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！

所以这里是有两个重复的维度。

那么应该这么写：

if (i > 0 && nums[i] == nums[i - 1]) {
    continue;
}

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到结果集里。

这是一个非常细节的思考过程。

class Solution {
        public List<List<Integer>> threeSum(int[] nums) {
            List<List<Integer>> result = new ArrayList<>();
            Arrays.sort(nums);
            // 找出a + b + c = 0
            // a = nums[i], b = nums[left], c = nums[right]
            for (int i = 0; i < nums.length; i++) {
                // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
                if (nums[i] > 0) {
                    return result;
                }
                // 去重a
                if (i > 0 && nums[i] == nums[i - 1]) { 
                    continue;
                }

                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去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

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

题目三：18. 四数之和

leetcode:18. 四数之和 (https://leetcode.cn/problems/4sum/description/)

思路和"三数之和"相似，也是双指针，四数之和是在三数之和的基础上再加一层for循环

然后注意细节不同点：

不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了；

四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

四数之和的双指针解法是两层for循环nums[i] + nums[j]为确定值，依然是循环内有left和right下标作为双指针，找出nums[i] + nums[j] + nums[left] + nums[right] == target的情况.

使用双指针的优点：

对于三数之和.三数之和双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。

有几个剪枝优化点：

首先我们已经从小到大进行了排序

1.判断如果Min(sum)>target，则说明最小值都比target大，而我们需要等于target，后面加的数更大，所以可以break;

注意：辅助理解，我们是将有序数组，由nums[i]开始前面四个相加，如果再循环nums[i]及其四个值会更大，所以可以直接break跳过后续循环;

if ((long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break; // 优化一

2.判断如果Max(sum)<target，则说明当前最大值比taget小，continue跳过。

注意：我们找最大值是已经固定的指针i，加上从最末端开始最大的三个，如果再循环，nums[i]增大，有可能再加上末尾三个值是可能大于target的。所以此时表示的是在指针等于i时的最大值，不是整个i循环的最大值，使用continue跳过此次循环。

if ((long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue; // 优化二

AC代码

 class Solution {
        public List<List<Integer>> fourSum(int[] nums, int target) {

            List<List<Integer>> result = new ArrayList<>();
            Arrays.sort(nums);
            int n = nums.length;
            for (int i = 0; i < n-3; i++) {
                // 对nums[i]去重
                if (i > 0 && nums[i] == nums[i - 1]) {
                    continue;
                }
                if ((long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break; // 优化一
                if ((long)nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue; // 优化二

                for (int j = i + 1; j < n-2; j++) {
                    // 对nums[j]去重
                    if (j > i+1 && nums[j] == nums[j - 1]) {
                        continue;
                    }
                    if ((long)nums[i] + nums[j] + nums[j + 1] + nums[i + 2] > target) break; // 优化一
                    if ((long)nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target) continue; // 优化二
                    int left = j + 1;
                    int right = n - 1;
                    while (left < right) {
                        long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];

                        if (sum < target) {
                            left++;
                        } else if (sum > target) {
                            right--;
                        } else {
                            result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                            // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                            while (right > left && nums[left] == nums[left + 1]) left++;
                            while (right > left && nums[right] == nums[right - 1]) right--;
                            right--;
                            left++;
                        }
                    }
                }
            }
            return result;
        }
    }