LeetCode 两(三、四)数之和

最新推荐文章于 2024-10-09 07:57:30 发布

yjx@qq.com

最新推荐文章于 2024-10-09 07:57:30 发布

阅读量171

点赞数 1

分类专栏： LeetCode刷题文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/qq_39924622/article/details/106158007

版权

LeetCode刷题专栏收录该内容

17 篇文章 0 订阅

订阅专栏

LeetCode 1.两数之和

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

题解

方法1 暴力法

不多说，两重循环解决，时间复杂度为O(n²)，空间复杂度为O(1)。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2];
        for(int i=0; i<nums.length-1; i++){
            for(int j=i+1; j<nums.length; j++){
                if(nums[i] + nums[j] == target){
                    ans[0] = i;
                    ans[1] = j;
                    break;
                }
            }
        }
        return ans;
    }
}

在这里插入图片描述

方法2 两遍哈希表

第一遍哈希：将所有元素存入哈希表；
第二遍哈希：对于下标为i的元素，查找哈希表是否存在键为 $t a r g e t - n u m s [i]$ 这个元素。
时间复杂度为O(n)，空间复杂度为O(n)。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i=0; i<nums.length; i++)
            map.put(nums[i],i);   //将下标作为值，是因为题目要求返回目标元素下标
        for(int i=0; i<nums.length;i++){
            if(map.containsKey(target-nums[i]) && map.get(target-nums[i]) != i)
                return new int[]{i, map.get(target - nums[i])} ;
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

在这里插入图片描述

方法3 一遍哈希表

可以在插入新的哈希键值对的同时就判断是否哈希表中已经存在当前元素对应的元素。
时间复杂度仍然为O(n)，空间复杂度O(n)，但性能进一步加强了。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i=0; i<nums.length; i++){
            if(map.containsKey(target-nums[i]))
                return new int[]{i, map.get(target - nums[i])} ;
            map.put(nums[i],i);   //将下标作为值，是因为题目要求返回目标元素下标
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

在这里插入图片描述

LeetCode 15.三数之和

题目描述

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

题解

方法1 暴力法

三重循环解决，时间复杂度为O(n³)。

方法1 哈希表

依题意，要找出满足 $a + b + c = 0$ （即 $a + b = - c$ ）的三个数
那么先固定a,b的值，然后查询哈希表中是否存在 $- c = - （ a + b ）$ 这个元素即可。
考虑a,b,c的取值有三种情况：

全为0
两个相同，一个不同
三个互不相同的数

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0; i<nums.length; i++){
            if(map.containsKey(nums[i]))
                map.put(nums[i], map.get(nums[i]) + 1);//重复元素记录下来，用来去重
            else
                 map.put(nums[i] , 1);
        }
        //存在3个0的情况
        if(map.containsKey(0) && map.get(0)>=3)
            ans.add(new ArrayList<Integer>(Arrays.asList(0,0,0)));
        List<Integer> list = new ArrayList<>(map.keySet()); //去重,map的键是不可重复的
        Collections.sort(list);          //排序
        for(int i=0; i<list.size()-1; i++){
            for(int j=i+1; j<list.size(); j++){
                //有两个数相同，一个数不同的情况
                if((list.get(i)<<1) + list.get(j) == 0 && map.get(list.get(i)) >= 2)
                    ans.add(new ArrayList<Integer>(Arrays.asList(list.get(i), list.get(i), list.get(j))));
                if((list.get(j)<<1) + list.get(i) == 0 && map.get(list.get(j)) >= 2)
                    ans.add(new ArrayList<Integer>(Arrays.asList(list.get(i), list.get(j), list.get(j))));
                //三个数都不同的情况
                int k = -(list.get(i) + list.get(j)); //要找的最后一个数
                if(k > list.get(j) && map.containsKey(k))
                    ans.add(new ArrayList<Integer>(Arrays.asList(list.get(i), list.get(j), k)));
            }
        }
        return ans;
    }
}

在这里插入图片描述
时间复杂度为O(n²)，空间复杂度为O(n)。

方法2 双指针法

先将数组排序；
每次固定一个 $i$ 元素,指针 $j (从 i 的下一个元素开始)$ 和指针 $k (数组末尾)$ 向中间逼近。

$n u m s [i] > 0$ : 最小的元素已经大于0了，说明从 $i$ 位置之后不会存在满足条件的值了
$n u m s [i] + n u m s [j] + n u m s [k]) > 0$ : $k$ 位置的值过大， $k$ 指针左移
$n u m s [i] + n u m s [j] + n u m s [k]) < 0$ : $j$ 位置的值过小， $j$ 指针右移
注意：要去重，下面代码中while语句是用来去重的（跳过相同的元素）

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        for(int i=0;i<nums.length-2;i++){
            if(nums[i] > 0)
                break;
            if(i>0 && nums[i]==nums[i-1])
                continue;
            for(int j=i+1, k=nums.length-1; j<k;){
                if((nums[i] + nums[j] + nums[k]) > 0){
                    while(j<k && nums[k] == nums[--k]);
                }
                else if((nums[i] + nums[j] + nums[k]) < 0){
                    while(j<k && nums[j] == nums[++j]);
                }
                else{
                    ans.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[j],nums[k])));
                    while(j<k && nums[j]==nums[++j]);
                    while(j<k && nums[k]==nums[--k]);
                }       
            }
        }
        return ans;
    }
}

在这里插入图片描述

LeetCode 18.四数之和

题目描述

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

题解

双指针法

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        int start = 0; //双指针
        int end = 0;
        for(int i=0; i<nums.length-3; i++){   //固定i位置的值
            if(nums[i] > (target>>2))   //最小的数nums[i]>(1/4)target,无解
                break;
            if(i > 0 && nums[i] == nums[i-1])
                continue;
            for(int j=i+1; j<nums.length-2; j++){ //固定j位置的值
                if(j>i+1 && nums[j] == nums[j-1])
                    continue;
                if(nums[i] + nums[j] > (target>>1))
                    break;
                for(start = j + 1, end = nums.length - 1; start<end; ){
                    if(nums[end] < (target>>2))
                        break;
                    int sum = nums[i] + nums[j] + nums[start] + nums[end];
                    if(sum > target)
                        while(start < end && nums[end] == nums[--end]);
                    else if(sum < target)
                        while(start < end && nums[start] == nums[++start]);
                    else{
                        ans.add(new ArrayList<Integer>(Arrays.asList(nums[i], nums[j], nums[start], nums[end])));
                        while(start < end && nums[start] == nums[++start]);
                        while(start < end && nums[end] == nums[--end]);
                    }
                }
            }
        }
        return ans;
    }
}

在这里插入图片描述
添加几个条件，减少不必要的运算，代码如下：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        int start = 0;
        int end = 0;
        int length = nums.length;
        for(int i=0; i<length-3; i++){
            if(nums[i] > (target>>2))
                break;
            if(i > 0 && nums[i] == nums[i-1])
                continue;
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3] > target)//当前最小的四个数之和大于target
                break;
            if(nums[i]+nums[length-1]+nums[length-2]+nums[length-3] < target)//当前最大值小于target
                continue;
            for(int j=i+1; j<length-2; j++){
                if(j>i+1 && nums[j] == nums[j-1])
                    continue;
                if(nums[i] + nums[j] > (target>>1))  //nums[i]与nums[j]的和大于target的一半
                    break;
                // if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3] > target)//当前最小的四个数之和大于target
                //     break;
                if(nums[i]+nums[j]+nums[length-1]+nums[length-2] < target)//当前最大值小于target
                    continue;
                for(start = j + 1, end = length - 1; start<end; ){
                    if(nums[end] < (target>>2)) //四个数之中最大的数小于target的1/4
                        break;
                    int sum = nums[i] + nums[j] + nums[start] + nums[end];
                    if(sum > target)
                        while(start < end && nums[end] == nums[--end]);
                    else if(sum < target)
                        while(start < end && nums[start] == nums[++start]);
                    else{
                        ans.add(new ArrayList<Integer>(Arrays.asList(nums[i], nums[j], nums[start], nums[end])));
                        while(start < end && nums[start] == nums[++start]);
                        while(start < end && nums[end] == nums[--end]);
                    }
                }
            }
        }
        return ans;
    }
}