最接近的三数之和

来源：力扣（LeetCode） 链接：leetcode.cn/problems/3s…

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

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

输出：2

解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

输入：nums = [0,0,0], target = 1

输出：0

提示：

• 3 <= nums.length <= 1000
• -1000 <= nums[i] <= 1000
• -104 <= target <= 104

代码

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int closestSum = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length - 2; i++) {
            int left = i + 1, right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (Math.abs(sum - target) < Math.abs(closestSum - target)) {
                    closestSum = sum;
                }
                if (sum < target) {
                    left++;
                } else {
                    right--;
                }
            }
        }
        return closestSum;
    }
}

思路分析

这个算法的时间复杂度为O(n^2)，其中n是数组的长度。

这个算法的思路类似于"三数之和"，我们还是先将数组排序。然后，我们遍历数组，并使用双指针left和right查找两个数，使得nums[i]+nums[left]+nums[right]最接近target。具体地，我们将left指针指向i+1，right指针指向数组的结尾。如果当前的和sum更接近target，则更新closestSum的值。然后，我们将left指针向右移动一个位置，将right指针向左移动一个位置。如果sum小于target，则将left指针向右移动一个位置，以使得sum变得更大；如果sum大于target，则将right指针向左移动一个位置，以使得sum变得更小。

这个算法的优点是它的时间复杂度为O(n^2)，因为只需要遍历一遍数组，然后对于每个元素，需要使用双指针遍历剩余的元素。缺点是它的空间复杂度为O(1)，因为只需要使用常数额外的空间来存储一些变量。

四数之和

来源：力扣（LeetCode） 链接：leetcode.cn/problems/4s…

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

代码

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = 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, right = nums.length - 1;
                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        res.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--;
                        left++;
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return res;
    }
}

思路分析

这个算法的时间复杂度为O(n^3)，其中n是数组的长度。

这个算法的思路类似于"三数之和"，我们使用四个指针i、j、left和right遍历数组，使得nums[i]+nums[j]+nums[left]+nums[right]=target。具体地，我们首先将数组排序，然后使用两层循环遍历i和j，对于每个(i,j)组合，使用双指针left和right查找两个数，使得nums[i]+nums[j]+nums[left]+nums[right]=target。如果当前的和sum等于target，则将这四个数添加到结果中。然后，我们将left指针向右移动一个位置，将right指针向左移动一个位置，并跳过重复的元素。如果sum小于target，则将left指针向右移动一个位置；如果sum大于target，则将right指针向左移动一个位置。

这个算法的优点是它的时间复杂度为O(n^3)，因为只需要使用三层循环遍历数组。缺点是它的空间复杂度为O(1)，因为只需要使用常数额外的空间来存储一些变量。