【5. 三数之和+18. 四数之和+454. 四数相加 II】

15. 三数之和

1.题目描述

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

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

输入：nums = []
输出：[]

输入：nums = [0]
输出：[]

2.解题思路及代码

• 方法一：排序+双指针

思路：
1，首先对数组进行排序，方便后续的操作
2，判断当前数组元素，如果大于0，那么直接停止，后面的操作不必进行，因为都是大于0
3，去重，如果当前的元素与前一个元素相同，可直接结束本层的遍历，进入到下一个元素
4，利用双指针，去判断三元素之和是否为0
是：仍然去重，对左右指针去重
否：根据条件移动左右指针

具体代码如下：

 public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>();
        //排序
        Arrays.sort(nums);
        //双指针
        int len = nums.length;
        for(int i = 0;i < len;++i) {
            if(nums[i] > 0) return lists;
              
            //去除重复的元素
            if(i > 0 && nums[i] == nums[i-1]) continue;

            int curr = nums[i];
            int L = i+1, R = len-1;
            while (L < R) {
                int tmp = curr + nums[L] + nums[R];
                if(tmp == 0) {
                    List<Integer> list = new ArrayList<>();
                    list.add(curr);
                    list.add(nums[L]);
                    list.add(nums[R]);
                    lists.add(list);
                    //去除重复的元素
                    while(L < R && nums[L+1] == nums[L]) ++L;
                    while (L < R && nums[R-1] == nums[R]) --R;
                    ++L;
                    --R;
                } else if(tmp < 0) {
                    ++L;
                } else {
                    --R;
                }
            }
        }
        return lists;
    }

时间复杂度：O(n^2)
空间复杂度：O(l)

18. 四数之和

1.题目描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

    0 <= a, b, c, d < n
    a、b、c 和 d 互不相同
    nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

2.解题思路及代码

• 方法一：排序+双指针

思路：如果采用暴力求解，很明显时间复杂度为O(n^4)，会出现运行超时。
因此，想办法降低时间的复杂度。
1，先对数组进行排序
2，和三数之和类似，先确定前两个数，然后利用双指针确定剩下的两个数，具体请看代码解析。

具体代码如下：

public List<List<Integer>> fourSum(int[] nums, int target) {
         List<List<Integer>> ans=new ArrayList<>();
         Arrays.sort(nums);
         for (int i=0;i<nums.length-3;i++){
             if (i>0 && nums[i]==nums[i-1]){
                 continue;
             }
             for (int j=i+1;j<nums.length-2;j++){
                 if (j>i+1 && nums[j]==nums[j-1]){
                     continue;
                 }
                 int left=j+1;
                 int right=nums.length-1;
                 while (left<right){
                     int sum = nums[i] + nums[j] + nums[left] + nums[right];
                     if (sum==target){
                         List<Integer> list=new ArrayList<>();
                         list.add(nums[i]);
                         list.add(nums[j]);
                         list.add(nums[left]);
                         list.add(nums[right]);
                         ans.add(list);

                         while (left<right && nums[left+1]==nums[left])left++;
                         while (left<right && nums[right]==nums[right-1])right--;
                         left++;
                         right--;
                     }else if (sum>target){
                         right--;
                     }else {
                         left++;
                     }
                 }
             }
         }
         return ans;
    }

时间复杂度：O(n^3)
空间复杂度：O(logn)

454. 四数相加 II

1.题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
    0 <= i, j, k, l < n
    nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
案例1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

案例2：
输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

2.解题思路及代码

• 方法：分组+哈希表

思路：
1，将四个数组分成两两处理
2，先对前两个数组，放入map中，map用来记录两个数组元素和的个数
3，根据四个数组的元素和为0，前两个元素和等于后两个元素和的负
利用map的contain方法判断就可以

具体代码如下：

public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        Map<Integer, Integer> countAB = new HashMap<Integer, Integer>();
        for (int u : A) {
            for (int v : B) {
                countAB.put(u + v, countAB.getOrDefault(u + v, 0) + 1);
            }
        }
        int ans = 0;
        for (int u : C) {
            for (int v : D) {
                if (countAB.containsKey(-u - v)) {
                    ans += countAB.get(-u - v);
                }
            }
        }
        return ans;
    }

时间复杂度：O(n^2)
空间复杂度：O(n^2)

题目链接：https://leetcode-cn.com/problems/4sum-ii