Python|数组|双指针|字符串|回溯|字典树|记忆化搜索|单选记录：最接近的三数之和|复原 IP 地址|单词拆分 II

1、最接近的三数之和（数组，双指针）

给定一个包括 n 个整数的数组 nums 和一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

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

提示：

3 <= nums.length <= 10^3
-10^3 <= nums[i] <= 10^3
-10^4 <= target <= 10^4

选项代码：

from typing import List
class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        cur = 0
        closest = nums[0] + nums[1] + nums[2]
        while cur < len(nums) - 2:
            left = cur + 1
            right = len(nums) - 1
            while left < right:
                n = nums[cur] + nums[left] + nums[right]
                if abs(target - n) < abs(target - closest):
                    closest = n
                if n == target:
                    break
                elif n > target:
                    t = right - 1
                    while (t > left and nums[t] == nums[right]):
                        t -= 1
                    right = t
                else:
                    t = left + 1
                    while (t < right and nums[t] == nums[left]):
                        t += 1
                    left = t
            t = cur + 1
            while (t < len(nums) and nums[t] == nums[cur]):
                t += 1
            cur = t
        return closest
# %%
s = Solution()
print(s.threeSumClosest(nums = [-1,2,1,-4], target = 1))

2、复原 IP 地址（字符串，回溯）

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的有效 IP 地址。你可以按任何顺序返回答案。

有效 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是无效 IP 地址。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "1111"
输出：["1.1.1.1"]

示例 4：

输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]

示例 5：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

0 <= s.length <= 3000
s 仅由数字组成

选项代码：

class Solution(object):
    def restoreIpAddresses(self, s):
        ls = len(s)
        if ls == 0 or ls > 12:
            return []
        res = []
        for i in range(1, 4):
            for j in range(1, 4):
                for k in range(1, 4):
                    m = ls - i - j - k
                    if m > 0 and m <= 3:
                        add1 = s[0:i]
                        add2 = s[i:i + j]
                        add3 = s[i + j:i + j + k]
                        add4 = s[i + j + k:]
                        if self.isValid(add1) and self.isValid(add2) and \
                                        self.isValid(add3) and self.isValid(add4):
                            res.append(add1 + '.' + add2 + '.' + add3 + '.' + add4)
        return res
    def isValid(self, add):
        if len(add) == 1:
            return True
        if add[0] == '0':
            return False
        if int(add) <= 255:
            return True
        return False
if __name__ == '__main__':
    s = Solution()
    print (s.restoreIpAddresses("101023"))

3、单词拆分 II（字典树，记忆化搜索）

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。

说明：

分隔时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。

示例 1：

输入:

s = "catsanddog"

wordDict = ["cat", "cats", "and", "sand", "dog"]

输出:

[

"cats and dog",

"cat sand dog"

]

示例 2：

输入:

s = "pineapplepenapple"

wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]

输出:

[

"pine apple pen apple",

"pineapple pen apple",

"pine applepen apple"

]

解释: 注意你可以重复使用字典中的单词。

示例 3：

输入:

s = "catsandog"

wordDict = ["cats", "dog", "sand", "and", "cat"]

输出:

[]

选项代码：

class Solution(object):
    def dfs(self, low, length, s, res, vaild, path=[]):
        if low == length:
            res.append(" ".join(path))
            return
        for i in range(low, length):
            if vaild[low][i]:
                self.dfs(i + 1, length, s, res, vaild, path + [s[low : i + 1]])
    def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: List[str]
        """
        length = len(s)
        vaild = [[False] * length for _ in range(length)]
        dp = [False for _ in range(length + 1)]
        dp[0] = True
        wordDict = set(wordDict)
        for i in range(1, length + 1):
            for j in range(i + 1):
                word = s[j:i]
                if dp[j] and word in wordDict:
                    dp[i] = True
                    vaild[j][i - 1] = True
        res = []
        if dp[-1]:
            self.dfs(0, length, s, res, vaild)
        return res
if __name__ == '__main__':
    slo = Solution()
    s = "pineapplepenapple"
    wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
    print (slo.wordBreak(s,wordDict))