算法套路二:相向双指针

算法套路示例讲解：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 True:  # left < right
            s = numbers[left] + numbers[right]
            if s == target:
                return [left + 1, right + 1]
            if s > target:
                right -= 1
            else:
                left += 1

套路总结

比较 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都判断是否与前一个数相同，相同则继续遍历。

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
        }
        if x+nums[i+1]+nums[i+2] > 0 { // 优化一
            break
        }
        if x+nums[n-2]+nums[n-1] < 0 { // 优化二
            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 ，返回其中可以组成三角形三条边的三元组个数。

以最长边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
}