leetcode笔记1—— “N数之和”类题
相关题目
以三数之和为例:
给定一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?找出所有满足条件且不重复的三元组。
示例:
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4],
满足要求的三元组集合为:
[
[-1, 0, 1],
[-1, -1, 2]
]
两数之和
参见官方题解,主要有两种方法
- 暴力法:两层循环 时间复杂度O(n^2),空间复杂度O(1)
- 哈希法:先建立哈希映射表,再顺序查表判断 时空复杂度均为O(n)
还有一种是排序遍历法,即先排序再用首尾双指针遍历,比暴力法要快
三数之和
方法一:循环嵌套法
在两数之和的排序遍历法基础上再套一层循环:先排序,再顺序遍历嵌套首尾双指针遍历(遍历时可通过去重进一步优化)
python3实现
def threeSum(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
nums.sort()
res = []
for i in range(len(nums)):
if i!=0 and nums[i]==nums[i-1]: # 去重
continue
l = i+1
r = len(nums)-1
while l<r:
s = nums[i] + nums[l] + nums[r]
if s==0:
res.append([nums[i], nums[l], nums[r]])
l += 1
r -= 1
while l<r and nums[l]==nums[l-1]:
l += 1
while r>l and nums[r]==nums[r+1]:
r -= 1
elif s<0:
l += 1
else:
r -= 1
return res
C++实现
vector<vector<int>> threeSum(vector<int> &nums)
{
sort(nums.begin(),nums.end());
int len=nums.size();
vector<vector<int>> result;
if(len < 3)
return result;
for(int i=0; i<len; ++i)
{
if(i==0 || nums[i]>nums[i-1])
{
int l = i+1;
int r = len-1;
while(l < r)
{
int sum = nums[i]+nums[l]+nums[r];
if(sum == 0)
{
result.push_back({nums[i], nums[l], nums[r]});
++l;
--r;
while(l<r && nums[l]==nums[l-1])
++l;
while(r>l && nums[r]==nums[r+1])
--r;
}
else if(sum < 0)
++l;
else
--r;
}
}
}
return result;
}
复杂度分析
- 时间复杂度:排序O(nlogn),外循环O(n),双指针遍历O(n),总共应不超过O(n^2)
- 空间复杂度:O(1)
方法二:递归法
将两数之和的排序遍历法作为递归基,将N数之和问题通过递归最终转化为两数之和问题
python3实现
def fourSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[List[int]]
"""
nums.sort()
res = []
self.nSum(nums, target, 4, [], res)
return res
def nSum(self, nums, target, N, temp, res):
# 通过递归将n数之和转化为2数之和
if len(nums)<N or N<2:
return
# 2-sum
if N==2:
left = 0
right = len(nums)-1
while left<right:
s = nums[left]+nums[right]
if s==target:
res.append(temp+[nums[left], nums[right]])
left += 1
right -= 1
while left<right and nums[left] == nums[left-1]:
left += 1
while left<right and nums[right] == nums[right+1]:
right -= 1
elif s<target:
left += 1
else:
right -= 1
else:
for i in range(len(nums)-N+1): # 因为已排序,N数之和的首个数只要遍历到len(nums)-N即可
if target<nums[0]*N or target>nums[-1]*N:
break # 目标值比最小数的N倍还小或比最大数的N倍还大必定不合条件
if i!=0 and nums[i]==nums[i-1]: # 去重
continue
self.nSum(nums[i+1:], target-nums[i], N-1, temp+[nums[i]], res)
return
C++版本暂未实现,欢迎大神补充
复杂度分析
与循环嵌套法应该相同,但更具扩展性
总结
- 相似问题要善于借助其中基础问题的解决思路去解决更复杂问题
- 有时间的话解决问题后多想一步,能否推而广之(如递归法)
- 可借助leetcode通过题的分布情况学习高效解法的思路