【LeetCode】two sum系列

最新推荐文章于 2024-03-02 21:28:00 发布

原创最新推荐文章于 2024-03-02 21:28:00 发布 · 371 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

4 篇文章

订阅专栏

本文提供了LeetCode上多个经典问题的高效解决方案，包括TwoSum、3Sum、4Sum等题目，详细介绍了使用HashMap和TwoPointers技巧来解决数组中特定数值组合的问题。

1. Two Sum

题目：在数组中找到两数之和为目标值

思路：HashMap——遍历数组，看hashmap中是否存在目标值与该值的差值，存在就返回，否则将该值与索引值存入hashmap。

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ret=new int[2];
        HashMap<Integer,Integer> hm=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(hm.containsKey(target-nums[i])){
                ret[0]=hm.get(target-nums[i]);
                ret[1]=i;
                return ret;
            }
            else{
                hm.put(nums[i],i);
            }
        }
        return ret;
    }
}

167. Two Sum II - Input array is sorted
题目：输入数组被排序之后怎么做
思路：two pointers——数组前后各设置一个标志位，相加等于目标值输出，大于后标志位前移，小于前标志位后移，直至找到目标值为止。
public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i = 0, j = numbers.length-1;
        int[] ret = new int[2];
        while(i < j){
            if(numbers[i]+numbers[j] == target){
                ret[0] = i+1;
                ret[1] = j+1;
                return ret;
            }
            else if(numbers[i]+numbers[j] > target){
                j--;
            }
            else{
                i++;
            }
        }
        return ret;
    }
}

15. 3Sum

题目：列出数组上三个数之和为零的组合。

思路：two pointers——先对数组排序，遍历数组，然后类似two sum，需要注意两点，一是利用Arrays.asList()比将元素一个个加到LinkedList里面要快很多，二是注意去重。

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

16. 3Sum Closest

题目：找到最接近目标的三数之和

思路：two pointers——与two sum类似，区别在于每次计算sum并移位之后，需要判断sum与当前最接近值谁更接近目标值。这里最开始想的是将大于目标值与小于目标值的临界点作为分界线，可以缩短时间，但是会造成提前break，结果不准确。另外，还需注意去重。

public class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int min=nums[0]+nums[1]+nums[nums.length-1];
        for(int i=0;i<nums.length-2;i++){
            if(i!=0&&nums[i]==nums[i-1]) continue;
            int j=i+1,k=nums.length-1;
            if(j!=i+1&&nums[j]==nums[j-1]) {
                j++;
                continue;
            }
            if(k!=nums.length-1&&nums[k]==nums[k+1]){
                k--;
                continue;
            }
            while(j<k){
                int sum=nums[i]+nums[j]+nums[k];
                if(sum==target){
                    return target;
                }
                else if(sum>target){
                    k--;
                }
                else{
                    j++;
                }
                if(Math.abs(sum-target)<Math.abs(min-target)){
                    min=sum;
                }
            }
        }
        return min;
    }
}

18. 4Sum

题目：列出数组上四个数之和为目标值的组合。

思路：two pointers——与three sum差不多，就是增加一层循环

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ret=new LinkedList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length-3;i++){
            while(i<nums.length&&i!=0&&nums[i]==nums[i-1]) i++;
            for(int j=i+1;j<nums.length-2;j++){
                while(j<nums.length&&j!=i+1&&nums[j]==nums[j-1]) j++;
                int m=j+1,n=nums.length-1;
                while(m<n){
                    int sum=nums[i]+nums[j]+nums[m]+nums[n];
                    if(sum==target){
                        ret.add(Arrays.asList(nums[i],nums[j],nums[m],nums[n]));
                        m++;
                        n--;
                        while(m<nums.length&&m!=j+1&&nums[m]==nums[m-1]) m++;
                        while(n>=0&&n!=nums.length-1&&nums[n]==nums[n+1]) n--;
                    }
                    else if(sum<target){
                        m++;
                    }
                    else{
                        n--;
                    }                
                }
            }
        }
        return ret;
    }
}

454. 4Sum II

题目：

思路：