【算法】16. 最接近的三数之和（多语言实现）
【摘要】 16. 最接近的三数之和：给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在恰好一个解。 样例 1：输入： nums = [-1,2,1,-4], target = 1 输出： 2 解释： 与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。 ...
16. 最接近的三数之和：
给你一个长度为 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
原题传送门：
https://leetcode.cn/problems/3sum-closest/
分析
- 面对这道算法题目，二当家的陷入了沉思。
- 这道题和【15. 三数之和】很像，但是不再是找一个值，而是要把可能的值都找一遍，最后确定最接近的值，所以不再是直接跳过大于目标，或者小于目标的值。
- 由于有三个变量，直观的做法还是暴力三层循环，但还是传说会超时。
- 同样我们先排个序，可以外层循环遍历作为第一个数。
- 这里用到双指针的思想，如果是找最接近的两数之和，我们可以将两个指针先定位在有序数组的两端，去判断两数之和是否和目标相等，如果相等就是想要的结果；如果大于目标，我们向左移动右面的指针；如果小于目标，我们就向右移动左边的指针。（如果右面的指针一直向左移动就会让两数之和最小，反之如果让左面的指针一直向右移动就会使两数之和最大，这样两个指针的移动方向虽然固定了，但是却不会漏掉某种组合）
- 扩展到三数之和，由于外层循环已经确定了第一个数的值，内层其实就是最接近的两数之和。
题解
rust
impl Solution {
pub fn three_sum_closest(mut nums: Vec<i32>, target: i32) -> i32 {
let n = nums.len();
nums.sort();
let mut ans = 23001;
for f in 0..n {
if f == 0 || nums[f] != nums[f - 1] {
let mut s = f + 1;
let mut t = n - 1;
while s < t {
let sum = nums[f] + nums[s] + nums[t];
if sum == target {
return target;
}
if (sum - target).abs() < (ans - target).abs() {
ans = sum;
}
if sum > target {
let mut t0 = t - 1;
while s < t0 && nums[t0] == nums[t] {
t0 -= 1;
}
t = t0;
} else {
let mut s0 = s + 1;
while s0 < t && nums[s0] == nums[s] {
s0 += 1;
}
s = s0;
}
}
}
}
return ans;
}
}
go
func threeSumClosest(nums []int, target int) int {
n := len(nums)
sort.Ints(nums)
ans := 23001
abs := func(num int) int {
if num < 0 {
return -num
}
return num
}
for f := 0; f < n; f++ {
if f > 0 && nums[f] == nums[f-1] {
continue
}
s, t := f+1, n-1
for s < t {
sum := nums[f] + nums[s] + nums[t]
if sum == target {
return target
}
if abs(sum-target) < abs(ans-target) {
ans = sum
}
if sum > target {
t0 := t - 1
for s < t0 && nums[t0] == nums[t] {
t0 -= 1
}
t = t0
} else {
s0 := s + 1
for s0 < t && nums[s0] == nums[s] {
s0 += 1
}
s = s0
}
}
}
return ans
}
c++
class Solution {
public:
int threeSumClosest(vector<int>& nums, int target) {
int n = nums.size();
sort(nums.begin(), nums.end());
int ans = 23001;
for (int f = 0; f < n; ++f) {
if (f > 0 && nums[f] == nums[f - 1]) {
continue;
}
int s = f + 1;
int t = n - 1;
while (s < t) {
int sum = nums[f] + nums[s] + nums[t];
if (sum == target) {
return target;
}
if (abs(sum - target) < abs(ans - target)) {
ans = sum;
}
if (sum > target) {
int t0 = t - 1;
while (s < t0 && nums[t0] == nums[t]) {
t0 -= 1;
}
t = t0;
} else {
int s0 = s + 1;
while (s0 < t && nums[s0] == nums[s]) {
s0 += 1;
}
s = s0;
}
}
}
return ans;
}
};
java
class Solution {
public int threeSumClosest(int[] nums, int target) {
int n = nums.length;
Arrays.sort(nums);
int ans = 23001;
for (int f = 0; f < n; ++f) {
if (f > 0 && nums[f] == nums[f - 1]) {
continue;
}
int s = f + 1;
int t = n - 1;
while (s < t) {
int sum = nums[f] + nums[s] + nums[t];
if (sum == target) {
return target;
}
if (Math.abs(sum - target) < Math.abs(ans - target)) {
ans = sum;
}
if (sum > target) {
int t0 = t - 1;
while (s < t0 && nums[t0] == nums[t]) {
t0 -= 1;
}
t = t0;
} else {
int s0 = s + 1;
while (s0 < t && nums[s0] == nums[s]) {
s0 += 1;
}
s = s0;
}
}
}
return ans;
}
}
typescript
function threeSumClosest(nums: number[], target: number): number {
const n = nums.length;
nums.sort((a, b) => a - b);
let ans = 23001;
for (let f = 0; f < nums.length; ++f) {
if (f > 0 && nums[f] === nums[f - 1]) {
continue;
}
let s = f + 1;
let t = n - 1;
while (s < t) {
const sum = nums[f] + nums[s] + nums[t];
if (sum === target) {
return target;
}
if (Math.abs(sum - target) < Math.abs(ans - target)) {
ans = sum;
}
if (sum > target) {
let t0 = t - 1;
while (s < t0 && nums[t0] === nums[t]) {
t0 -= 1;
}
t = t0;
} else {
let s0 = s + 1;
while (s0 < t && nums[s0] === nums[s]) {
s0 += 1;
}
s = s0;
}
}
}
return ans;
};
python
class Solution:
def threeSumClosest(self, nums: List[int], target: int) -> int:
n = len(nums)
nums.sort()
ans = 23001
for f in range(n):
if f > 0 and nums[f] == nums[f - 1]:
continue
s = f + 1
t = n - 1
while s < t:
sum = nums[f] + nums[s] + nums[t]
if sum == target:
return target
if abs(sum - target) < abs(ans - target):
ans = sum
if sum > target:
t0 = t - 1
while s < t0 and nums[t0] == nums[t]:
t0 -= 1
t = t0
else:
s0 = s + 1
while s0 < t and nums[s0] == nums[s]:
s0 += 1
s = s0
return ans
非常感谢你阅读本文~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://bbs.huaweicloud.com/community/usersnew/id_1628396583336561 博客原创~
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）