leetcode笔记｜第七周 双指针专题

125 验证回文串

回文：a == a[::-1]则为回文。或者使用双指针，左右两个相同时，往里前进一步，直至相遇。

class Solution:
    def isPalindrome(self, s: str) -> bool:
        newStr = "".join(ch.lower() for ch in s if ch.isalnum())
        if newStr == newStr[::-1]:
            return True
        else:
            return False
        # left, right = 0, len(newStr)-1
        # while left < right:
        #     if newStr[left]!= newStr[right]:
        #         return False
        #     left += 1
        #     right -= 1
        # return True

167 两数之和

[2,7,11,13] target=9，返回递增序列中两数和为target的index值，这个index不从0开始。因为是递增，所以暴力搜索。但是有很多无所谓的搜索，超时。双指针，两边往里挪指针，当和大了，那就right-1，和小了，left+1。双指针永远滴神。

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        # 暴力搜索，超时
        # res=[]
        # for i in range(len(numbers)-1):
        #     for j in range(i+1, len(numbers)):
        #         if numbers[i]+numbers[j] == target:
        #             res.append(i+1)
        #             res.append(j+1)
        #             return res
        #         if numbers[i]+numbers[j]>target:
        #             break
        i,j = 0, len(numbers)-1
        while i<j:
            if numbers[i]+numbers[j]==target:
                return [i+1,j+1]
            elif numbers[i]+numbers[j]>target:
                j-=1
            else:
                i+=1

424 替换后的最长重复字符

双指针检测区间内最多的字母+可修改个数是否超过区间长度。使用字典完成范围内字母的统计，

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        left = 0
        max_letter = 0
        letter_num = {} # 当前双指针范围内字母个数
        for right in range(len(s)):
            if s[right] not in letter_num:
                letter_num[s[right]]=0
            letter_num[s[right]] += 1
            max_letter = max(max_letter, letter_num[s[right]])
            if max_letter+k < right-left+1: # 如果不能满足全被改为同一字母
                letter_num[s[left]] -= 1    # 左指针右移一位
                left += 1
        return len(s)-left #右-左+1，右=len-1

524 通过删除字母匹配字典里最长单词

输入:s = “abpcplea”, d = [“ale”,“apple”,“monkey”,“plea”]

输出: “apple”

class Solution:
    def findLongestWord(self, s: str, d: List[str]) -> str:
        # d.sort(key=lambda i:len(i), reverse=True) # 按长度排序,倒序
        # d.sort(key=lambda i:-len(i)) # 与上面等价
        d.sort(key=lambda i: (-len(i),i)) # 按长度排序，倒序，等长按ascii排序
        for word in d:
            idx = 0
            for ele in word:
                idx = s.find(ele, idx) + 1 # find查找idx，不存在返回-1
                if not idx:
                    break
            else: # break后不走这边，否则正常是走的
                return word
        return ''

16 最接近的三数之和

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

思路：首先排序，三个数字和最接近target，可以认为固定a，希望b+c-target的绝对值最小。那么双指针移动，记录过程中绝对值最小的和为res，以及当时的min_distance。

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        if len(nums)==3:
            return nums[0]+nums[1]+nums[2]
        n = len(nums)
        distance = float('inf')
        nums = sorted(nums) # 排序后遍历
        res = 0
        for i in range(n):
            left, right =i+1, n-1
            while left<right: # 双指针，左右
                dis = nums[i]+nums[left]+nums[right]-target
                if abs(dis)<distance: # 更新最小距离
                    distance = abs(dis)
                    res = nums[i]+nums[left]+nums[right]
                if dis>0: # 大了，右指针往左，小一点
                    right -= 1
                elif dis<0: # 小了，左指针往右，大一点
                    left += 1
                else:
                    return target
        return res

18 四数之和

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。返回[[-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2]]

跟上一道题目差不多，就是需要排除二维数组重复的元素，注意不加tuple报错。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums = sorted(nums)
        res = []
        n = len(nums)
        for i in range(n-3):
            for j in range(i+1, n-2):
                left = j+1
                right = n-1
                while left<right:
                    numSum = nums[i]+nums[j]+nums[left]+nums[right]
                    if numSum == target:
                        res.append([nums[i],nums[j],nums[left],nums[right]])
                        left += 1
                        right -= 1
                    elif numSum > target:
                        right -= 1
                    else:
                        left += 1
        return list(set([tuple(t) for t in res]))

986 区间列表的交集

输入：A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]

class Solution:
    def intervalIntersection(self, A: List[List[int]], B: List[List[int]]) -> List[List[int]]:
        res = []
        i, j = 0, 0
        while i<len(A) and j<len(B):
            left = max(A[i][0], B[j][0])
            right = min(A[i][1], B[j][1])
            if left<=right:
                res.append([left, right])
            if A[i][1]<B[j][1]:
                i += 1
            else:
                j += 1
        return res