算法 （四）

题目链接：15. 三数之和 - 力扣（LeetCode）

题目描述：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

解法：排序+双指针

思路：此题与两数之和的方法类似，与两数之和稍微不同的是，题目中要求找到所有「不重复」的三元组。那我们可以利用在两数之和 那里用的双指针思想，来对我们的暴力枚举做优化：

i. 先排序（升序）；

ii. 然后固定⼀个数 a ：

iii. 在这个数后面的区间内，使用「双指针算法」快速找到两个数之和等于 -a 即可（也就相当于代码中的-nums[i]）。

但是要注意的是，这道题里面需要有「去重」操作：

i. 找到⼀个结果之后， left 和 right 指针要「跳过重复」的元素（两者指针分别向前、向后各组一步，若去前面的数或后面的数相同，则继续向前或向后走一步）；

ii. 当使用完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素（一轮走完后进入下一轮，看这一轮固定的数b是否与上一轮a是同一个数，若是同一个，则继续往后走）。

代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ret=new ArrayList<>();
        //1.排序
        Arrays.sort(nums);
        //2.利用双指针解决问题
        int n=nums.length;
        for(int i=0;i<n;){//固定数a
            if(nums[i]>0){
                break;
            }
            int left=i+1,right=n-1,target=-nums[i];
            while(left<right){
                int sum=nums[left]+nums[right];
                if(sum>target){
                    right--;
                }else if(sum<target){
                    left++;
                }else{
                    //nums[i] nums[left] nums[right]
                    ret.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[left],nums[right])));
                    left++;right--;//缩小区间继续寻找
                    //去重 left right
                    while(left<right&&nums[left]==nums[left-1]){
                        left++;
                    }
                    while(left<right&&nums[right]==nums[right+1]){
                        right--;
                    }
                }
                
            }
            //去重i
                i++;
                while(i<n&&nums[i]==nums[i-1]){
                    i++;
                }
        }
        return ret;
    }
}

题目链接：18. 四数之和 - 力扣（LeetCode） 

题目描述：

给你一个由 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

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

示例 1：

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

示例 2：

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

提示：

• 1 <= nums.length <= 200
• -109 <= nums[i] <= 109
• -109 <= target <= 109

思路：与三数之和类似

1.排序（升序）；

2.a. 依次固定⼀个数 a ；

   b. 在这个数 a 的后⾯区间上，利⽤Γ三数之和」找到三个数，使这三个数的和等于 target - a 即可。

3.里面的三数之和做法与前面的两数之和类似，在三数之和中找到 target-a-b 即可。

但是要注意的是，这道题里面也需要有「去重」操作：

i. 找到⼀个结果之后， left 和 right 指针要「跳过重复」的元素（两者指针分别向前、向后各组一步，若去前面的数或后面的数相同，则继续向前或向后走一步）；

ii. 当使用完⼀次双指针算法之后，固定的 b 也要「跳过重复」的元素（一轮走完后进入下一轮，看这一轮固定的数b是否与上一轮b是同一个数，若是同一个，则继续往后走）。

iii.当使用完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素（一轮走完后进入下一轮，看这一轮固定的数a是否与上一轮a是同一个数，若是同一个，则继续往后走）。

 代码：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ret=new ArrayList<>();
        //1.排序
        Arrays.sort(nums);
        //2.利用双指针解决问题
        int n=nums.length;
        for(int i=0;i<n;){//固定a
            //三数之和
            for(int j=i+1;j<n;){//固定b
                //双指针
                int left=j+1,right=n-1;
                long aim=(long)target-nums[i]-nums[j];
                while(left<right){
                    int sum=nums[left]+nums[right];
                    if(sum>aim){
                        right--;
                    }else if(sum<aim){
                        left++;
                    }else{
                        ret.add(Arrays.asList(nums[i],nums[j],nums[left++],nums[right--]));
                        //去重
                        while(left < right && nums[left]==nums[left-1]){
                            left++;
                        }
                        while(left<right && nums[right]==nums[right+1]){
                            right--;
                        }
                    }
                }
                //去重j
                j++;
                while(j<n&&nums[j]==nums[j-1]){
                    j++;
                }
            }
            //去重i
            i++;
            while(i<n&&nums[i]==nums[i-1]){
                i++;
            }
        }
        return ret;
    }
}