leetcode分类刷题：基于数组的双指针（三、有序数组的元素求和）

1、有点像“leetcode分类刷题：二分查找（Binary Search）（一、基于索引（定义域）的类型）”的前提，数组是排序好的，然后求解的目标是元素之和，不是查找某个元素第一次大于等于数组元素的索引位置
2、稍微复杂化的题型是对三元组、四元组等的求解，就像“leetcode分类刷题：哈希表（Hash Table）（一、简单的两数之和）”中所提到的，这类数组的元素求和题目，难点在于求解的目标，这里需要返回答案的值构成的三元组、四元组等，就需要考虑答案的去重问题；额外可以考虑加上 特殊情况的判断（当然不加这个的代码也能顺利通过），需要注意target值为负数还是非负数进行分类讨论，最后总结这类题目的解题思路：排序+双指针+答案的去重+特殊情况的判断（可以不加）

167. 两数之和 II - 输入有序数组

1、本文总结的经典题型，注意细节：下标从1开始
2、该题为后续几道题的基础题

from typing import List
'''
167. 两数之和 II - 输入有序数组
给你一个下标从 1 开始的整数数组numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数target 的两个数。
如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。
示例 1:
    输入：numbers = [2,7,11,15], target = 9
    输出：[1,2]
    解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
题眼：两数之和+有序
思路：有序问题使用双指针最好
'''


class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left, right = 0, len(numbers) - 1
        while left < right:  # 答案的下标不能重复
            if numbers[left] + numbers[right] == target:
                return [left+1, right+1]  # 下标从1开始
            elif numbers[left] + numbers[right] > target:
                right -= 1
            else:
                left += 1


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            in_line = input().strip().split('=')
            nums = [int(n) for n in in_line[1].split(']')[0].split('[')[1].split(',')]
            target = int(in_line[2].strip())
            print(obj.twoSum(nums, target))
        except EOFError:
            break

15. 三数之和

思路：不同于返回下标，这里是返回值；"167. 两数之和 II - 输入有序数组"的扩展 + 对三元组的答案在每个位置都要添加去重逻辑；
额外可以考虑加上 特殊情况的判断（需要注意target值为负数还是非负数）

from typing import List
'''
15. 三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。
请返回所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。
示例 1:
    输入: nums = [-1,0,1,2,-1,-4]
    输出: [[-1,-1,2],[-1,0,1]]
    解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
          nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
          nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
          不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。
题眼：这种题目的复杂程度取决于求解目标：求值构成的三元组 且不能重复
思路：不同于返回下标，这里是返回值；"167. 两数之和 II - 输入有序数组"的扩展 + 对三元组的答案在每个位置都要添加去重逻辑；
额外可以考虑加上 特殊情况的判断（需要注意target值为负数还是非负数）
'''


class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # 这种题目的复杂程度取决于求解目标：求值构成的三元组 且不能重复
        result = []
        nums.sort()
        for i in range(len(nums) - 2):
            # 特殊情况判断：三元组答案的第一个元素大于target，不必再求解后续位置元素
            if nums[i] > 0:
                break
            # 三元组答案的第一个元素去重
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            # "167. 两数之和 II - 输入有序数组"的扩展，查找剩余二元组，target值为-nums[i]；但要注意剩余二元组的去重
            left, right = i + 1, len(nums) - 1
            while left < right:
                # 双指针遍历过程
                if nums[left] + nums[right] > -nums[i]:
                    right -= 1
                elif nums[left] + nums[right] < -nums[i]:
                    left += 1
                else:
                    result.append([nums[i], 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
        return result


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            nums = [int(n) for n in input().strip().split('[')[1][:-1].split(',')]
            print(nums)
            print(obj.threeSum(nums))
        except EOFError:
            break

18. 四数之和

思路：“15. 三数之和”的扩展 + 对三元组的答案在每个位置都要添加去重逻辑；
额外可以考虑加上 特殊情况的判断（需要注意target值为负数还是非负数）

from typing import List
'''
18. 四数之和
给你一个由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
示例 1:
    输入: nums = [1,0,-1,0,-2,2], target = 0
    输出: [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
题眼：这种题目的复杂程度取决于求解目标：求值构成的四元组 且不能重复
思路：“15. 三数之和”的扩展 + 对三元组的答案在每个位置都要添加去重逻辑；
额外可以考虑加上 特殊情况的判断（需要注意target值为负数还是非负数）
'''


class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        result = []
        # 情况1、数组长度小于4，直接返回[]
        if len(nums) < 4:
            return result
        nums.sort()
        for i in range(len(nums) - 3):
            # 特殊情况判断：四元组答案的第一个元素情况（需要注意target值为负数还是非负数）
            if target >= 0 and nums[i] > target or target < 0 and nums[i] >= 0:
                break
            # 四元组答案的第一个元素去重
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            # 寻找剩余三元组的过程
            for j in range(i + 1, len(nums) - 2):
                # 特殊情况判断：四元组答案的第一个元素情况（需要注意target值为负数还是非负数）
                if target >= 0 and nums[i] + nums[j] > target or target < 0 and nums[i] + nums[j] >= 0:
                    break
                # 四元组答案的第二个元素去重
                if j > i + 1 and nums[j] == nums[j - 1]:
                    continue
                # 寻找剩余二元组的过程
                left, right = j + 1, len(nums) - 1
                while left < right:
                    # 双指针遍历过程
                    if nums[left] + nums[right] < target - nums[i] - nums[j]:
                        left += 1
                    elif nums[left] + nums[right] > target - nums[i] - nums[j]:
                        right -= 1
                    else:
                        result.append([nums[i], nums[j], 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
        return result


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            in_line = input().strip().split('=')
            nums = [int(n) for n in in_line[1].split(']')[0].split('[')[1].split(',')]
            target = int(in_line[2].strip())
            print(nums, target)
            print(obj.fourSum(nums, target))
        except EOFError:
            break

16. 最接近的三数之和

思路："167. 两数之和 II - 输入有序数组"的扩展，好像变得更简单了，因为不需要考虑答案去重了

from typing import List
'''
16. 最接近的三数之和
给你一个长度为 n 的整数数组nums和 一个目标值target。请你从 nums 中选出三个整数，使它们的和与target最接近。
返回这三个数的和。
假定每组输入只存在恰好一个解。
示例 1:
    输入：nums = [-1,2,1,-4], target = 1
    输出：2
    解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
题眼：三数之和
思路："167. 两数之和 II - 输入有序数组"的扩展
'''


class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        result = nums[0] + nums[1] + nums[2]  # 将result初始值设定为排序后的前三个元素之和 或者 设置为float('inf)
        for i in range(len(nums) - 2):
            # "167. 两数之和 II - 输入有序数组"的扩展
            left, right = i + 1, len(nums) - 1
            while left < right:
                s = nums[i] + nums[left] + nums[right]
                if abs(s - target) < abs(result - target):
                    result = s
                if s == target:
                    return result
                elif s > target:  # 更接近的加和 需要变小，更新右指针
                    right -= 1
                else:    # 更接近的加和 需要变大，更新左指针
                    left += 1
        return result


if __name__ == "__main__":
    while True:
        try:
            in_line = input().strip().split('=')
            nums = [int(n) for n in in_line[1].split('[')[1].split(']')[0].split(',')]
            target = int(in_line[2])
            print(nums, target)
        except EOFError:
            break

259. 较小的三数之和

思路："16. 最接近的三数之和"的扩展，求解目标变成了三元组的个数，也不需要考虑去重的问题

from typing import List
'''
259. 较小的三数之和
给定一个长度为 n 的整数数组和一个目标值 target，寻找能够使条件 nums[i] + nums[j] + nums[k] < target 
成立的三元组  i, j, k 个数（0 <= i < j < k < n）。
示例 1:
    输入: nums = [-2,0,1,3], target = 2
    输出: 2 
    解释: 因为一共有两个三元组满足累加和小于 2:
        [-2,0,1]
        [-2,0,3]
题眼：三数之和
思路："16. 最接近的三数之和"的扩展，求解目标变成了三元组的个数，不考虑去重的问题
'''


class Solution:
    def threeSumSmaller(self, nums: List[int], target: int) -> int:
        nums.sort()
        result = 0
        for i in range(len(nums) - 2):
            # "167. 两数之和 II - 输入有序数组"的扩展
            left, right = i + 1, len(nums) - 1
            while left < right:
                s = nums[i] + nums[left] + nums[right]
                if s < target:
                    result += right - left  # (left, right]区间的所有数值全部满足
                    left += 1
                else:
                    right -= 1
        return result


if __name__ == "__main__":
    obj = Solution()
    while True:
        try:
            in_line = input().strip().split('=')
            nums = [int(n) for n in in_line[1].split('[')[1].split(']')[0].split(',')]
            target = int(in_line[2])
            print(obj.threeSumSmaller(nums, target))
        except EOFError:
            break