算法基础_LeetCode两数之和与三数之和的解析对比
1 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
这道题首先容易想到的就是暴力解，但是如果是在面试中写暴力解，那么大概率是凉凉。其次就是可以想到用双指针的方式来解决这个问题，但是双指针方式要求是要用排好序的数组，这里要求的返回值是数字在原数组的下标，如果使用这种方式，返回的只能是排序后数组的下标，所以不行。然后考虑使用哈希表，哈希表也是这道题考察的核心。
1.比较容易想到的两遍哈希表
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int len = nums.size();
if(len == 0) return vector<int>();
vector<int> res(2,-1);
map<int,int> hasht;
for(int i = 0; i < len; i++){
hasht[nums[i]] = i;
}
for(int i = 0; i < len; i++){
int diff = target - nums[i];
if(hasht.count(diff) && hasht[diff] != i){
res[0] = i;
res[1] = hasht[diff];
break;
}
}
return res;
}
};
提交结果：
2.优化后的一遍哈希表
考虑了前面的算法之后发现可以不用一开始就全部把数组加到map中，因为每种输入只对应一种答案，所以可以在查哈希表的时候一边查一边加，即使在最后才找到合适的，也比之前的方式效率高。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int len = nums.size();
if(len == 0) return vector<int>();
map<int,int> hasht;
for(int i = 0; i < len; i++){
int diff = target - nums[i];
if(hasht.count(diff) && hasht[diff] != i){
// hasht[diff]为已经加入map的元素的索引，所以小于本轮循环中的i，放在前面
return {hasht[diff],i};
}
hasht[nums[i]] = i;
}
return {};
}
};
提交结果：
2 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
刚看到这道题的时候就联想到了上题的解法，是否可以用哈希表的的方式来降低复杂度。因为使用哈希表可以把O(n)的查询降到O(1)，但是尝试后发现不好解决，因为这道题中有重复的元素，而且multimap不能使用下标，后边的去重也比较麻烦，于是放弃。然后想到了双指针方式，先固定一个数，然后剩下的两个数转化为求2数之和的问题。具体的思路下面这个老铁讲的很好：小浩算法之图解三数之和。
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
int len = nums.size();
if(len < 3) return res;
sort(nums.begin(),nums.end());//必须排序
for(int i = 0 ; i < len; i++)
{
int target = 0 - nums[i];
int left = i + 1,right = len - 1;
if(nums[i] > 0) break;//排序后固定点如果大于0，注定无法组合（left = i + 1）
if(i > 0 && nums[i] == nums[i-1]) continue; //固定点的去重，如果下一个指针的值和上一个一样就跳过
while(left < right){
int sum = nums[left] + nums[right];
if(sum == target)
{
res.push_back(vector<int>{nums[i],nums[left],nums[right]});
//左指针右移，所以左指针的值等于他右边的值就跳过
while(left<right && nums[left] == nums[left + 1] ) ++left;
//右指针左移，所以右指针的值等于他左边的值就跳过
//这里left<right必要，因为虽然进入while的时候判断过，但是上一行代码可能改变left < right的情况
while(left<right && nums[right] == nums[right - 1] ) --right;
//如果发生跳过，那么跳到最后的结果左右指针指向的值还是和上次相等，只是在边缘（再跳一次就不相等）
//如果没有跳过，也需要移动左右指针，不能只移动一个，因为移动一个接下来和的值必然不等于target
++left;
--right;
}
else if(sum < target){
++left;
}
else{
--right;
}
}
}
return res;
}
};
提交结果：
3 四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，
使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/4sum
这道题解法类似于三数之和，只不过需要固定2个数，多一次去重。
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res = {};
int len = nums.size();
if(len < 4) return res;
sort(nums.begin(),nums.end());//双指针必须排序
for(int i = 0; i < len-3;i++)
{
if(i > 0 && nums[i] == nums[i-1]) continue;//去重
for(int j = i+1; j < len-2; j++)//j < len -2，必须留2个给l和r否则会越界
{
int l = j + 1,r = len-1;
int tar = target - nums[i] - nums[j];
if(j > i+1 && nums[j] == nums[j-1]) continue;//去重注意，j>i+1：j不能和之前的重复，j必须大于i+1
while(l < r)
{
int sum = nums[l] + nums[r];
if(sum == tar)
{
res.push_back({nums[i],nums[j],nums[l],nums[r]});
while(l < r && nums[l] == nums[l+1]) ++l;
while(l < r && nums[r] == nums[r-1]) --r;
++l;
--r;
}
else if(sum < tar) ++l;
else --r;
}
}
}
return res;
}
};
提交结果：
4 最接近的三数之和
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。
返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
提示：
3 <= nums.length <= 10^3
-10^3 <= nums[i] <= 10^3
-10^4 <= target <= 10^4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum-closest
这道题就是在三数之和的基础上修改了一点点，而且还不需要去重，只要掌握了三数之和，这道题就比较容易了。
class Solution {
public:
int threeSumClosest(vector<int>& nums, int target) {
int res = 10000;
int sum;
int len = nums.size();
sort(nums.begin(),nums.end());
for(int i = 0; i < len-2; i++)
{
if(i > 0 && nums[i] == nums[i-1]) continue;//去重，非必须
int l = i+1, r = len-1;
while(l < r)
{
sum = nums[l] + nums[r]+nums[i];
if(abs(target-sum) < abs(res - target))
res = sum;
if(sum < target) ++l;
else --r;
}
}
return res;
}
};
提交结果：
扫一扫
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
