力扣网-四数之和

四数之和

问题简介

编程思路

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o69sd9Aa-1644564020552)(…/…/AppData/Roaming/Typora/typora-user-images/image-20220211151108383.png)]

编程实现

第一个版本-AC

FourName类

 FourName类是一个简单数据容器类，是为了保存一组解而生的。

import java.util.Objects;

/**
 * @author songquanheng
 * 2022/2/11-14:20
 */
public class FourNum {
    private int a;
    private int b;
    private int c;
    private int d;

    public FourNum(int a, int b, int c, int d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }

    public int getA() {
        return a;
    }

    public void setA(Integer a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(Integer b) {
        this.b = b;
    }

    public int getC() {
        return c;
    }

    public void setC(Integer c) {
        this.c = c;
    }

    public int getD() {
        return d;
    }

    public void setD(Integer d) {
        this.d = d;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        FourNum fourNum = (FourNum) o;
        return Objects.equals(a, fourNum.a) &&
                Objects.equals(b, fourNum.b) &&
                Objects.equals(c, fourNum.c) &&
                Objects.equals(d, fourNum.d);
    }

    @Override
    public int hashCode() {

        return Objects.hash(a, b, c, d);
    }
}

主体方法

    public List<List<Integer>> fourSum(int[] nums, int target) {
        Set<FourNum> result = new HashSet<>();
        List<Integer> list = Arrays.stream(nums).boxed().sorted().collect(Collectors.toList());
        for (int i = 0; i < list.size(); i++) {
            Integer first = list.get(i);
            for (int j = i + 1; j < list.size() - 2; j++) {
                Integer second = list.get(j);
                int k = j + 1;
                int m = list.size() - 1;
                while (k < m) {
                    Integer third = list.get(k);
                    Integer forth = list.get(m);
                    Integer sum = first + second + third + forth;
                    if (sum == target) {
                        result.add(new FourNum(first, second, third, forth));
                        k++;
                        m--;
                    } else if (sum > target) {
                        m--;
                    } else {
                        k++;
                    }
                }


            }
        }

        List<List<Integer>> res = new ArrayList<>();
        for (FourNum fourNum : result) {
            res.add(new ArrayList<>(Arrays.asList(fourNum.getA(), fourNum.getB(), fourNum.getC(), fourNum.getD())));
        }
        return res;
    }

 上述的主干过程分为两个步骤，第一步，把所有有效解（去重）之后保存在Set中，由于FourName重写了equals方法，因此Set会过滤相同的FourName的对象。然后就是把每个FourName转化成题目要求的List格式。

 思路也是比较清晰的。

第二个方法-递归

 递归这个思想也很强大，很秀。代码阅读起来也不复杂。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSum(nums, target, 4);
    }
    /*
    **  n数之和
    **  @param number 要求几个数
    */
    public static List<List<Integer>> nSum(int[] nums, int target, int number) {
        if (nums.length < number) return new ArrayList<>();
        List<List<Integer>> result = new ArrayList<>();
        
        if (number > 2) {
            // number大于2时，继续划分和递归，直到 number == 2
            for (int i = 0; i < nums.length; i++) {
                // 递归，数组划分、目标值target更新、number减一
                List<List<Integer>> deeperResult = nSum(Arrays.copyOfRange(nums, i + 1, nums.length), target - nums[i], number - 1);
                // 收集下层递归的返回值并处理
                if (deeperResult.size() > 0) {
                    for (List<Integer> tempResult : deeperResult) {
                        tempResult.add(nums[i]);
                        // 去重后添加到result
                        if (!result.contains(tempResult)) {
                            result.add(tempResult);
                        }
                    }
                }
            }
        } else {
            // number == 2 时变为两数之和
            int i = 0, j = nums.length - 1;
            while (i < j) {
                if (nums[i] + nums[j] < target) {
                    i++;
                } else if (nums[i] + nums[j] > target) {
                    j--;
                } else {
                    List<Integer> tempResult = new ArrayList<>(Arrays.asList(nums[i], nums[j]));
                    if (!result.contains(tempResult)) {
                        result.add(tempResult);
                    }
                    i++;
                    j--;
                }
            }
        }
        
        return result;
    }
}

 第一种思想，即双指针的思想，必须掌握，而第二种思想，最好好好揣摩，然后掌握。

总结

 今天是2月11日，距离回杭2月13日还有两天，人生遗憾的事情，十之八九，得失看淡，不服就干，各位读者，也希望你能够在自己的人生之中，通过自己的努力，获得心满意足的答案。

 双指针相似的题目如下所示：

• 力扣网-最接近的三数之和
• 力扣网-三数之和等于0
• 力扣网-盛最多水的容器
• 力扣网-两数之和

2022年2月11日15:15:56于宋营