算法套路二:相向双指针
算法套路示例讲解:LeetCode167. 两数之和 II - 输入有序数组
给你一个下标从 1 开始的整数数组 numbers ,该数组已按 非递减顺序排列 ,请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ,则 1 <= index1 < index2 <= numbers.length 。以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。你可以假设每个输入 只对应唯一的答案 ,而且你 不可以 重复使用相同的元素。你所设计的解决方案必须只使用常量级的额外空间。
考虑相向双指针,若输入为[2,3,4,6,8],target为9,左指针 left = 0,右指针right = len(numbers) - 1
首先数组为2,3,4,6,8,此时左端点为2,右端点为8,相加为10>target=9,且由于是有序数组,左指针右边的数都比2大,故8与数组内任何数相加都大于target,所以8必不可能出现在答案中
,故我们将右指针向左移动
此时我们数组为2 3 4 6,此时左端点为2,右端点为6,相加为8<target=9,且由于是有序数组,右指针左边的数都比6小,故2与数组内任何数相加都小于target,所以2必不可能出现在答案中,故我们将左指针向右移动
此时数组为3 4 6,此时左端点为3,右端点为6,相加为9=target,故返回[left + 1, right + 1]
class Solution:
def twoSum(self, numbers: List[int], target: int) -> List[int]:
left = 0
right = len(numbers) - 1
while left < right
s = numbers[left] + numbers[right]
if s == target:
return [left + 1, right + 1]
if s > target:
right -= 1
else:
left += 1
套路总结:
要判断的值只与left和right指向的值有关,且值存在某种有序性,使每次遍历只需要移动left或right中的一个,那么当left<right时,
比较 s = numbers[left] + numbers[right]与固定值target(关键为找到该固定值)
如果s > target,right--
如果s < target,left++
练习一:LeetCode15. 三数之和
给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
由题设i<j<k,首先对数组进行排序
三数之和为0,我们可以从0到nums[i-3]遍历每个数为最小的数字i,这样我们只用和上题一样,考虑数组[i+1,········]是否存在两个数等于-nums[i]。
注意不能重复,所以每次遍历i,j,k都判断是否与前一个数相同,相同则继续遍历。
比上一题多了一个数,那么我们可以循环枚举第一个数假设为x,对后面两个数采用双向相指针
那么与上题一样
比较s := x + nums[j] + nums[k]与target=0
func threeSum(nums []int) (ans [][]int) {
sort.Ints(nums)
n := len(nums)
for i, x := range nums[:n-2] {
if i > 0 && x == nums[i-1] { // 跳过重复数字
continue
}
j, k := i+1, n-1
for j < k {
s := x + nums[j] + nums[k]
if s > 0 {
k--
} else if s < 0 {
j++
} else {
ans = append(ans, []int{x, nums[j], nums[k]})
for j++; j < k && nums[j] == nums[j-1]; j++ {} // 跳过重复数字
for k--; k > j && nums[k] == nums[k+1]; k-- {} // 跳过重复数字
}
}
}
return
}
练习二:LeetCode16. 最接近的三数之和
给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数,使它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在恰好一个解。
与上题几乎一样,只是多了取差值,且不用考虑是否重复
func threeSumClosest(nums []int, target int) int {
sort.Ints(nums)
n := len(nums)
best := math.MaxInt32
// 根据差值的绝对值来更新答案
update := func(cur int) {
if abs(cur - target) < abs(best - target) {
best = cur
}
}
// 枚举 a
for i := 0; i < n; i++ {
// 使用双指针枚举 b 和 c
j, k := i + 1, n - 1
for j < k {
sum := nums[i] + nums[j] + nums[k]
// 如果和为 target 直接返回答案
if sum == target {
return target
}
update(sum)
if sum > target {
// 如果和大于 target,移动 c 对应的指针
k --
} else {
// 如果和小于 target,移动 b 对应的指针
j++
}
}
}
return best
}
func abs(x int) int {if x < 0 {return -1 * x}; return x}
练习三:LeetCode18. 四数之和
给你一个由 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 你可以按 任意顺序 返回答案 。
在三数循环外在套一层循环
func fourSum(nums []int, target int) [][]int {
sort.Ints(nums)
n:=len(nums)
ans:=make([][]int ,0)
if n<4{
return ans
}
for a,numA:=range nums[:n-3]{
if a>0&&numA==nums[a-1]{
continue
}
for i := a + 1; i < len(nums) - 2; i++ {
if i > a+1 && nums[i] == nums[i-1] { // 跳过重复数字
continue
}
j, k := i+1, n-1
for j < k {
s := nums[i] + nums[j] + nums[k] + numA
if s > target {
k--
} else if s < target {
j++
} else {
ans = append(ans, []int{numA,nums[i], nums[j], nums[k]})
for j++; j < k && nums[j] == nums[j-1]; j++ {} // 跳过重复数字
for k--; k > j && nums[k] == nums[k+1]; k-- {} // 跳过重复数字
}
}
}
}
return ans
}
进阶一:LeetCode611. 有效三角形的个数
给定一个包含非负整数的数组 nums ,返回其中可以组成三角形三条边的三元组个数。
此题看上去没有固定值target,但其实与之前的三数之和一样,可以固定枚举最长边,对另外两条采用相向双指针
以最长边nums[k]为值target枚举
,从而使判断条件为nums[l] + nums[r]>target
func triangleNumber(nums []int) int {
sort.Ints(nums)
var res int
// 遍历第三条边,找前两条边之和大于第三条边的组合
for k := len(nums)-1; k >= 2; k-- {
l, r := 0, k - 1
target:=nums[k]
for l < r {
if nums[l] + nums[r] >target {
res += r-l
r--
} else {
l++
}
}
}
return res
}
进阶二:LeetCode11. 盛最多水的容器
给定一个长度为 n 的整数数组 height 。有 n 条垂线,第 i 条线的两个端点是 (i, 0) 和 (i, height[i])
。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。
该题表面上高度并不能有序排列,但其实也有递减性,即在左右指相向针移动的过程中,装水区域的底是逐渐减少的
,且装水的多少与底和左右指针高度的最小值决定,
那么与之前类似,,left指向最左侧为0,right为len(height)-1即8,此时装水量由底高决定,底为right-left=8,高为左右指针值的最小值,即为左指针指向的高1。此时area为81=8。
此时考虑如果存在更大的area装水区域即左右指针往中间移动,则底一定会小于此时的底=8,那么左右指针指向的最小高度一定要更高
,则一定大于1,所以若处在更大的area,左指针指向的一定不是1,所以left++,则此时与之前双向双指针的思想完全一致,每次只需要移动left与right中高度较低的指针,直到left=right
func maxArea(height []int) (int) {
left,right:=0,len(height)-1
ans:=0
for left<right{
area:=(right-left)*min(height[right],height[left])
ans=max(ans,area)
if height[right]<height[left]{
right--
}else{
left++
}
}
return ans
}
func min(a, b int) int { if a > b { return b }; return a }
func max(a, b int) int { if a < b { return b }; return a }
进阶三:LeetCode42. 接雨水
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。
法一:前缀与后缀
先不考虑双指针,以这个图为例,对于高度为0的点,想要知道能接多少水,就不能只看这一个点,而要看他左边最高的柱子与右边最高的柱子
,而这两个柱子中较低的那个柱子高度就是装水的量
,那我们用两个数组记录,一个记录从左到右过程中的最高柱子,一个记录从右到左的最高柱子,对这两个数组每个点取最小值,就能知道当前点左右两边最高柱子的最小值,减去自己所在的柱子的高度就是装水量。
func trap(height []int) (ans int) {
n := len(height)
preMax := make([]int, n)
preMax[0] = height[0]
for i := 1; i < n; i++ {
preMax[i] = max(preMax[i-1], height[i])
}
sufMax := make([]int, n)
sufMax[n-1] = height[n-1]
for i := n - 2; i >= 0; i-- {
sufMax[i] = max(sufMax[i+1], height[i])
}
for i, h := range height {
ans += min(preMax[i], sufMax[i]) - h
}
return
}
func min(a, b int) int { if a > b { return b }; return a }
func max(a, b int) int { if a < b { return b }; return a }
法二:相向双指针
与上题一样,本题看上去没有单调性,但其实有递增性,那就是(左边最高的柱子,右边最高的柱子)的最小值,随着指针往中间移动,左边与右边的柱子高度也会变大,故他们的最小值也会递增
法一的空间复杂度为O(n),但其实不需要数组记录柱子最高值,只需要使用双指针比较得出两边最低值
并用变量minH记录,且只需要移动指向高度低的柱子的指针,移动后继续比较左右柱子的较低值,并与之前的minH比较,若大于之前的最低值则更新minH,循环直到left=right,最后left与right都会停在最高的柱子处。
func trap(height []int) int {
left,right:=0,len(height)-1
ans:=0
minH:=0
for left<right{
if height[left]<=height[right]{
minH=max(minH,height[left])
ans+=minH-height[left]
left++
}else{
minH=max(minH,height[right])
ans+=minH-height[right]
right--
}
}
return ans
}
func max(x,y int)int {if x<y {return y}; return x}