leetcode每日一题(2020.10.05) 18. 四数之和(中等)

最新推荐文章于 2022-05-11 20:57:40 发布
最新推荐文章于 2022-05-11 20:57:40 发布
阅读量266 收藏
点赞数
分类专栏： LeetCode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42072280/article/details/108931298
版权
本文详细介绍了如何使用排序和双指针法解决LeetCode中的三数之和与四数之和问题，从暴力解法到优化策略，包括使用HashMap去重，以及在遇到重复元素时的处理技巧。同时，展示了如何将这些方法应用于实际的代码实现，以提高算法效率和通过率。
摘要由CSDN通过智能技术生成

文章目录


leetcode每日一题汇总

15.三数之和(中等)

暴力法：会超时

/*
思路：
用了最简单的暴力法，但是直接暴力结果中会出现重复
所以在暴力遍历的时候，要去除会产生重复的情况
*/

//anan 2020.10.05
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);
        for(int i = 0; i < n; i++){
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(int j = i+1; j < n; j++){
                if(j != (i+1) && nums[j] == nums[j-1]) continue;
                for(int k = j+1; k < n; k++){
                    if(k != (j+1) && nums[k] == nums[k-1]) continue;
                    
                    if(nums[i]+nums[j]+nums[k] == 0){
                        res.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[j],nums[k])));
                        }
                    
                }
            }
        }
        return res;
    }
}

官解：排序+双指针法


//anan 2020.10.05
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);

        for(int k = 0; k < n-2; k++){
        	if(nums[k] > 0) break;
            if(k > 0 && nums[k] == nums[k-1]) continue;   //去重
            int left = k+1;
            int right = n-1;
            
            while(left < right){
                if(nums[k]+nums[left]+nums[right] < 0){
                    while(left < right && nums[left+1] == nums[left])   left++;  //去重              
                    left++;
                }else if(nums[k]+nums[left]+nums[right] > 0){
                    while(left < right && nums[right-1] == nums[right]) right--; //去重  
                    right--;
                }else{
                    res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[left], nums[right])));
                    while(left < right && nums[left+1] == nums[left])   left++;  //去重
                    while(left < right && nums[right-1] == nums[right]) right--; //去重
                    left++;
                    right--;
                }
            }           
        }

        return res;
    }
}

官解：排序+双指针法 稍微优化一点

//anan 2020.10.05
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);

        for(int k = 0; k < n-2; k++){
            if(nums[k] > 0) break;   // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
            if(k > 0 && nums[k] == nums[k-1]) continue;   //去重
            int left = k+1;
            int right = n-1;
            
            while(left < right){
                if(nums[k]+nums[left]+nums[right] < 0){
                    //这个不放到最终结果里，所以不去重也没关系
                    //while(left < right && nums[left+1] == nums[left])   left++;  //去重       
                    left++;
                }else if(nums[k]+nums[left]+nums[right] > 0){
                    //while(left < right && nums[right-1] == nums[right]) right--; //去重  
                    right--;
                }else{
                    res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[left], nums[right])));
                    while(left < right && nums[left+1] == nums[left])   left++;  //去重
                    while(left < right && nums[right-1] == nums[right]) right--; //去重
                    left++;
                    right--;
                }
            }           
        }

        return res;
    }
}

使用hashmap去重(过程中)


//anan 2020.10.05
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Map<List<Integer>, Integer> map = new HashMap<>();
        int n = nums.length;
        Arrays.sort(nums);

        for(int k = 0; k < n-2; k++){
            if(nums[k] > 0) break;   // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
            int left = k+1;
            int right = n-1;
            
            while(left < right){
                if(nums[k]+nums[left]+nums[right] < 0){
                    left++;
                }else if(nums[k]+nums[left]+nums[right] > 0){
                    right--;
                }else{
                    //如果之前有的话，就不加入了
                    if(!map.containsKey(Arrays.asList(nums[k], nums[left], nums[right]))){
                        res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[left], nums[right])));
                        map.put(Arrays.asList(nums[k], nums[left], nums[right]), 1);
                    }
                    left++;
                    right--;
                }
            }           
        }

        
      

        return res;
    }
}

使用hashmap去重(结束) (过了99.37%)

通不过案例：[0,0,0,0,0,…]


//anan 2020.10.05
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);

        for(int k = 0; k < n-2; k++){
            if(nums[k] > 0) break;   // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
            int left = k+1;
            int right = n-1;
            
            while(left < right){
                if(nums[k]+nums[left]+nums[right] < 0){
                    left++;
                }else if(nums[k]+nums[left]+nums[right] > 0){
                    right--;
                }else{                   
                    res.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[left], nums[right])));
                    left++;
                    right--;
                }
            }           
        }
        System.out.println("res:"+res);

        Map<List<Integer>, Integer> map = new HashMap<>();
        for(int i = 0; i < res.size();){           
            if(map.containsKey(res.get(i))){
                System.out.println("重复："+ res.get(i));
                res.remove(i);
            }else{
                map.put(res.get(i), 1);
                i++;
            }
        }
      

        return res;
    }
}

18.四数之和(中等)

安安：暴力法(通过了)

/*
输入
[-2,-1,-1,1,1,2,2]
0
输出
[[-2,-1,1,2],[-1,-1,1,1]]
*/

/*
思路：
用了最简单的暴力法，但是直接暴力结果中会出现重复
所以在暴力遍历的时候，要去除会产生重复的情况
*/

//anan 2020.10.05
class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);
        for(int i = 0; i < n; i++){
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(int j = i+1; j < n; j++){
                if(j != (i+1) && nums[j] == nums[j-1]) continue;
                for(int k = j+1; k < n; k++){
                    if(k != (j+1) && nums[k] == nums[k-1]) continue;
                    for(int t = k+1; t < n; t++){
                        if(t != (k+1) && nums[t] == nums[t-1]) continue;
                        if(nums[i]+nums[j]+nums[k]+nums[t] == target){
                            res.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[j],nums[k],nums[t])));
                        }
                    }
                }
            }
        }
        return res;
    }
}

排序+双指针


class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);

        for(int i = 0; i < n-3; i++){
            if(i > 0 && nums[i] == nums[i-1]) continue;   //去重
            for(int j = i+1; j < n-2; j++){
                if(j > i+1 && nums[j] == nums[j-1]) continue;   //去重
                int left = j+1;
                int right = n-1;
               
                while(left < right){
                    if(nums[i]+nums[j]+nums[left]+nums[right] < target){
                        left++;
                    }else if(nums[i]+nums[j]+nums[left]+nums[right] > target){
                        right--;
                    }else{
                        res.add(new ArrayList<Integer>(Arrays.asList(nums[i], nums[j], nums[left], nums[right])));
                        while(left < right && nums[left+1] == nums[left])   left++;  //去重
                        while(left < right && nums[right-1] == nums[right]) right--; //去重
                        left++;
                        right--;
                    }
                }           
            }
        }
        

        return res;
    }
}

二维数组(List< List< Integer>>)去重

import java.util.*;
/*
输入：
[[-4, -2, 6], [-4, -2, 6], [-4, 0, 4],
[-4, 1, 3], [-4, 2, 2], [-2, -2, 4], [-2, -2, 4],
[-2, 0, 2], [-2, -2, 4], [-2, 0, 2], [-2, 0, 2]]
 */
public class Main {
    public static void main(String[] args) {
        List<List<Integer>> res = new ArrayList<>();
        res.add(Arrays.asList(-4,-2,6));
        res.add(Arrays.asList(-4,-2,6));
        res.add(Arrays.asList(-4,0,4));
        res.add(Arrays.asList(-4,1,3));
        res.add(Arrays.asList(-4,2,2));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,0,2));
        res.add(Arrays.asList(-2,-2,4));
        res.add(Arrays.asList(-2,0,2));
        res.add(Arrays.asList(-2,0,2));

        System.out.println("去重前：res:"+res);

        Map<List<Integer>, Integer> map = new HashMap<>();
        for(int i = 0; i < res.size();){
            if(map.containsKey(res.get(i))){
                System.out.println("重复："+ res.get(i));
                res.remove(i);
            }else{
                map.put(res.get(i), 1);
                i++;
            }
        }

        System.out.println("去重后：res:"+res);
    }
}
/*
去重前：res:[[-4, -2, 6], [-4, -2, 6], [-4, 0, 4], [-4, 1, 3], [-4, 2, 2], [-2, -2, 4],
[-2, -2, 4], [-2, 0, 2], [-2, -2, 4], [-2, 0, 2], [-2, 0, 2]]
重复：[-4, -2, 6]
重复：[-2, -2, 4]
重复：[-2, -2, 4]
重复：[-2, 0, 2]
重复：[-2, 0, 2]
去重后：res:[[-4, -2, 6], [-4, 0, 4], [-4, 1, 3], [-4, 2, 2], [-2, -2, 4], [-2, 0, 2]]
 */
安安csdn
关注
专栏目录
【Leetcode每日一题】2020-09-10 216 组合总和 III - 中等 (Python & C++)
weixin_46062098的博客
09-12 219
来源：力扣 找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。 说明： 所有数字都是正整数。 解集不能包含重复的组合。 Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set
leetcode题解-2020.03.29（题目编号1/892/914/999/820/1162/2/3）
木风feng的博客
03-29 860
文章目录前言1 两数之和题目描述思路解析示例代码892 三维形体的表面积题目描述思路解析示例代码914 卡牌分组题目描述思路解析示例代码999 可以被一步捕获的棋子数题目描述思路解析示例代码820 单词的压缩编码题目描述思路解析示例代码 前言 本周完成的题目有： 1 两数之和（简单难度） 892 三维形体的表面积（简单难度，每日一题） 914 卡牌分组（简单难度，每日一题） 999 可以被一步捕...
leetcode题：18. 四数之和（中等）
tankpanv的博客
08-10 141
一、题目描述：18. 四数之和（中等） 给定一个包含n 个整数的数组nums和一个目标值target，判断nums中是否存在四个元素 a，b，c和 d，使得a + b + c + d的值与target相等？找出所有满足条件且不重复的四元组。 注意： 答案中不可以包含重复的四元组。 示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 ta...
18.四数之和（LeetCode）（中等）
qq_39980514的博客
04-14 137
给定一个包含n个整数的数组nums和一个目标值target，判断nums中是否存在四个元素a，b，c和d，使得a+b+c+d的值与target相等？找出所有满足条件且不重复的四元组。 注意： 答案中不可以包含重复的四元组。 示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合...
关于解释List＜Integer＞ list = new ArrayList＜Integer＞()
热门推荐
半岛铁盒的博客
03-18 2万+
List<Integer> list = new ArrayList<Integer>() List< Integer> List是一个接口 <>表示了List里面放的对象是什么类型的，这样写就表示了，你List里面放的必须是Integer类型的 关于 integer: int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装 类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null I
【LeetCode】【查找表】【几数之和相关问题】
zoroooooo的博客
07-22 166
利用hashmap的思路是没错的，但是要是遇到去重的话就比较蛋疼，考虑排序＋双指针比较好** 【1.两数之和】 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 输入：nums = [2,7,11,15], target = 9 输出：[0,1] ----暴力法就不多说了 注意数组return{i,j
0511刷题
qq_38374572的博客
05-11 215
0511刷题 LeetCode 334. 递增的三元子序列 LeetCode 334. 递增的三元子序列 贪心算法： class Solution { public: bool increasingTriplet(vector<int>& nums) { int a = INT_MAX, b = INT_MAX; for(int x: nums) if(x <= a) a = x; else i
LeetCode 第一周 （日期Oct.14 - Oct.20 2020）
qq_27213221的博客
10-28 629
注：本文部分内容及所有题目源自于Leetcode网站，仅供本人自己学习与作为练习笔记使用。（所有引用都已标注原网址，见文章或附录。若存在版权侵犯，请联系本人删除侵权内容。） 日期Oct.14 - Oct.20 2020（每日一题） 1. 题目1002. 查找常用字符（难度：简单）Oct.14 刷题请点击或见附录：1002. 查找常用字符 题目要求：给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是.
【Leetcode-NO.00003】动态规划-Leetcode write up by arttnba3
arttnba3的博客
11-20 387
github pages blog addr 文章目录[github pages blog addr](https://archive.next.arttnba3.cn/2020/09/06/%E3%80%90OJ-0x0003-Leetcode%E3%80%91%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E9%83%A8%E5%88%86write-up-by-arttnba3/)0x00.绪论pre.什么是动态规划算法？0x01.难度：简单0x00.[爬楼梯](https:
每日一题算法：2020年6月29日 数组中的第K个最大元素 findKthLargest
I12XXXXXLbull的博客
06-29 420
2020年6月29日 数组中的第K个最大元素 findKthLargest 默认格式： class Solution { public int findKthLargest(int[] nums, int k) { } } 解题思路： 这不就是直接排序吗？那用这方法不就等于在用暴力算法吗？所以作为一道中等难度的题目，必定有它巧妙的地方存在。 目前想到能够实现的最好的方法。 先对前k项进行一次冒泡排序，找到最小的元素就是第k大的元素。 一个新元素出现，先判断是否比第k个元素大，如果比第k
Java中res.add(list)和res.add(new ArrayList＜Integer＞(list))的区别
Awt_FuDongLai的博客
12-02 2526
先说结论 res.add(list)为浅拷贝； res.add(new ArrayList(list))为深拷贝。 看代码 import java.util.ArrayList; public class Test { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(1); list.add(2); list.a
三数之和&&四数之和
Joydong1的博客
07-11 221
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 示例： 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ] 1.Java 排序+双指针 class Solution { public List<List<Integer>>
LeetCode进阶之路（Permutations II）
书山有路勤为径 学海无涯苦作舟
08-14 302
Given a collection of numbers that might contain duplicates, return all possible unique permutations. For example, [1,1,2] have the following unique permutations: [ [1,1,2], [1,2,1], [2,1
347. Top K Frequent Elements
学渣记事本
07-14 244
Given a non-empty array of integers, return the k most frequent elements. For example, Given [1,1,1,2,2,3] and k = 2, return [1,2]. Note:  You may assume k is always valid, 1 ≤ k ≤ number
LeetCode（七）数组操作-#78
baldist的博客
10-19 118
List<List<Integer>> res = new ArrayList<>(1 << nums.length); //先添加一个空的集合 res.add(new ArrayList<>()); for (int num : nums) { //每遍历一个元素就在之前子集中的每个集合追加这个元素，让他变成新的子集 for (int i = 0, j = res.size(); i...
剑指offer题目代码总结
weixin_42072280的博客
08-04 1857
剑指 Offer 26. 树的子结构 二叉树匹配类问题总结 B 属于 A 的一部分也可以，没必要一直匹配到叶子节点 递归解法 recur的返回条件: 当节点 B 为空：说明树 B 已匹配完成（越过叶子节点），因此返回 true ； 当节点 A 为空：说明已经越过树 A 叶子节点，即匹配失败，返回 false； 剑指 Offer 28. 对称的二叉树 1.递归解法 2.非递归解法(队列) 剑指 Offer 27. 二叉树的镜像 1.递归解法 2.非递归解法(栈或队列) ​​ ...
DP(Dynamic Programming)动态规划
weixin_42072280的博客
03-01 1421
动态规划（英语：Dynamic programming，简称 DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解...
LeetCode：第1题 两数之和 C语言实现
weixin_42072280的博客
10-24 1229
题目： 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。 你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 分析： 1.for()...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

安安csdn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值