代码随想录算法训练营第二十九天|93.复原IP地址 78.子集 90.子集II

93.复原IP地址

给定一个只包含数字的字符串,复原它并返回所有可能的 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 仅由数字组成

思路:

本题和其他字符串切割的题目类似,只是在切割点处应该用“.”连接起来得到一个IP地址,需要注意的是每个分割后的字段转换为数字后应该保持在0-255的范围内,此处注意点也是可以作为剪枝的方向。另外一个需要注意的点是前导0,如果在切割的时候发现存在前导0,此时不应该继续扩大字段,存在0的字段只能为0。

代码实现如下:

  1. class Solution:
  2.     def restoreIpAddresses(self, s: str) -> List[str]:
  3.         self.result = []
  4.         if len(s) > 12:     # IP最长长度为3*4(255.255.255.255),此处可剪枝
  5.             return self.result
  6.         self.backtracking(s, 0, [])
  7.         return self.result
  8.     def backtracking(self, s:str, start:int, path:List):
  9.         if len(path)==4 and start>=len(s):
  10.             self.result.append(".".join(path))
  11.         cur = 0
  12.         #zero = False      # 本来想判断是否存在前导0,但是如果存在并不需要进一步判断,如果cur*10+s[i]等于0说明只能做切割
  13.         for i in range(start, len(s)):
  14.             cur = cur * 10 + int(s[i])
  15.             #if zero==False and cur==0:
  16.             if cur == 0:
  17.                 #zero = True
  18.                 path.append(str(cur))
  19.                 self.backtracking(s, i+1, path)
  20.                 path.pop()
  21.                 return
  22.             if cur>0 and cur<=255:
  23.                 path.append(str(cur))
  24.                 self.backtracking(s, i+1, path)
  25.                 path.pop()
  26.             if cur>255:         #一个段最大为255,大于则剪枝
  27.                 return

规范代码:

回溯(版本一)

  1. class Solution:
  2.     def restoreIpAddresses(self, s: str) -> List[str]:
  3.         result = []
  4.         self.backtracking(s, 0, 0, "", result)
  5.         return result
  6.     def backtracking(self, s, start_index, point_num, current, result):
  7.         if point_num == 3:  # 逗点数量为3时,分隔结束
  8.             if self.is_valid(s, start_index, len(s) - 1):  # 判断第四段子字符串是否合法
  9.                 current += s[start_index:]  # 添加最后一段子字符串
  10.                 result.append(current)
  11.             return
  12.         for i in range(start_index, len(s)):
  13.             if self.is_valid(s, start_index, i):  # 判断 [start_index, i] 这个区间的子串是否合法
  14.                 sub = s[start_index:i + 1]
  15.                 self.backtracking(s, i + 1, point_num + 1, current + sub + '.', result)
  16.             else:
  17.                 break
  18.     def is_valid(self, s, start, end):
  19.         if start > end:
  20.             return False
  21.         if s[start] == '0' and start != end:  # 0开头的数字不合法
  22.             return False
  23.         num = 0
  24.         for i in range(start, end + 1):
  25.             if not s[i].isdigit():  # 遇到非数字字符不合法
  26.                 return False
  27.             num = num * 10 + int(s[i])
  28.             if num > 255:  # 如果大于255了不合法
  29.                 return False
  30.         return True

回溯(版本二)

  1. class Solution:
  2.     def restoreIpAddresses(self, s: str) -> List[str]:
  3.         results = []
  4.         self.backtracking(s, 0, [], results)
  5.         return results
  6.     def backtracking(self, s, index, path, results):
  7.         if index == len(s) and len(path) == 4:
  8.             results.append('.'.join(path))
  9.             return
  10.         if len(path) > 4:  # 剪枝
  11.             return
  12.         for i in range(index, min(index + 3, len(s))):
  13.             if self.is_valid(s, index, i):
  14.                 sub = s[index:i+1]
  15.                 path.append(sub)
  16.                 self.backtracking(s, i+1, path, results)
  17.                 path.pop()
  18.     def is_valid(self, s, start, end):
  19.         if start > end:
  20.             return False
  21.         if s[start] == '0' and start != end:  # 0开头的数字不合法
  22.             return False
  23.         num = int(s[start:end+1])
  24.         return 0 <= num <= 255

78.子集

给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。

说明:解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [ [3],   [1],   [2],   [1,2,3],   [1,3],   [2,3],   [1,2],   [] ]

思路:

将本题问题可以归结为分别对0~len(nums)个数组长度的切割,所以在回溯函数backtracking中加入length参数,并且从0~len(nums)循环输入进这个参数来进行调用,最后得到的结果数组即可。

代码实现如下:

  1. class Solution:
  2.     def subsets(self, nums: List[int]) -> List[List[int]]:
  3.         self.result = []
  4.         for i in range(len(nums)+1):
  5.             self.backtracking(nums, 0, [], i)
  6.         return self.result
  7.     def backtracking(self, nums:List[int], start:int, path:List, length:int):
  8.         if length == 0:
  9.             self.result.append(path[:])
  10.             return
  11.         for i in range(start, len(nums)):
  12.             path.append(nums[i])
  13.             self.backtracking(nums, i+1, path, length-1)
  14.             path.pop()

规范代码:(简洁很多,需学习)

  1. class Solution:
  2.     def subsets(self, nums):
  3.         result = []
  4.         path = []
  5.         self.backtracking(nums, 0, path, result)
  6.         return result
  7.     def backtracking(self, nums, startIndex, path, result):
  8.         result.append(path[:])  # 收集子集,要放在终止添加的上面,否则会漏掉自己
  9.         # if startIndex >= len(nums):  # 终止条件可以不加
  10.         #     return
  11.         for i in range(startIndex, len(nums)):
  12.             path.append(nums[i])
  13.             self.backtracking(nums, i + 1, path, result)
  14.             path.pop()

90.子集II

给定一个可能包含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。

说明:解集不能包含重复的子集。

示例:

  • 输入: [1,2,2]
  • 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

思路:

与上一题相比,多了一个去重步骤,和昨天的题目类似,在开始一个for循环的时候,判断遍历的元素是否与for循环中前一个元素相同,如果相同,说明此时在相同位置出现了同样的元素,所得到的结果必然也是相同的,所以此时应该忽略,寻找下一个不相同的元素。

代码实现如下:

  1. class Solution:
  2.     def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
  3.         self.result = []
  4.         nums.sort()
  5.         for i in range(len(nums)+1):       # i代表子集的长度(0~len(nums))
  6.             self.backtracking(nums, 0, [], i)
  7.         return self.result
  8.     def backtracking(self, nums: List[int], start:int, path:List, length:int):
  9.         if length == 0:
  10.             self.result.append(path[:])
  11.             return
  12.         for i in range(start, len(nums)):
  13.             if i>start and nums[i]==nums[i-1]: # 避免重复结果,一个循环内同元素可跳过,相当于起点是相同元素,不会得到不同结果
  14.                 continue
  15.             path.append(nums[i])
  16.             self.backtracking(nums, i+1, path, length-1)
  17.             path.pop()

规范代码:

回溯 利用used数组去重

  1. class Solution:
  2.     def subsetsWithDup(self, nums):
  3.         result = []
  4.         path = []
  5.         used = [False] * len(nums)
  6.         nums.sort()  # 去重需要排序
  7.         self.backtracking(nums, 0, used, path, result)
  8.         return result
  9.     def backtracking(self, nums, startIndex, used, path, result):
  10.         result.append(path[:])  # 收集子集
  11.         for i in range(startIndex, len(nums)):
  12.             # used[i - 1] == True,说明同一树枝 nums[i - 1] 使用过
  13.             # used[i - 1] == False,说明同一树层 nums[i - 1] 使用过
  14.             # 而我们要对同一树层使用过的元素进行跳过
  15.             if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:
  16.                 continue
  17.             path.append(nums[i])
  18.             used[i] = True
  19.             self.backtracking(nums, i + 1, used, path, result)
  20.             used[i] = False
  21.             path.pop()

回溯 利用集合去重

  1. class Solution:
  2.     def subsetsWithDup(self, nums):
  3.         result = []
  4.         path = []
  5.         nums.sort()  # 去重需要排序
  6.         self.backtracking(nums, 0, path, result)
  7.         return result
  8.     def backtracking(self, nums, startIndex, path, result):
  9.         result.append(path[:])  # 收集子集
  10.         uset = set()
  11.         for i in range(startIndex, len(nums)):
  12.             if nums[i] in uset:
  13.                 continue
  14.             uset.add(nums[i])
  15.             path.append(nums[i])
  16.             self.backtracking(nums, i + 1, path, result)
  17.             path.pop()

回溯 利用递归的时候下一个startIndex是i+1而不是0去重

  1. class Solution:
  2.     def subsetsWithDup(self, nums):
  3.         result = []
  4.         path = []
  5.         nums.sort()  # 去重需要排序
  6.         self.backtracking(nums, 0, path, result)
  7.         return result
  8.     def backtracking(self, nums, startIndex, path, result):
  9.         result.append(path[:])  # 收集子集
  10.         for i in range(startIndex, len(nums)):
  11.             # 而我们要对同一树层使用过的元素进行跳过
  12.             if i > startIndex and nums[i] == nums[i - 1]:
  13.                 continue
  14.             path.append(nums[i])
  15.             self.backtracking(nums, i + 1, path, result)
  16.             path.pop()

登录后您可以享受以下权益:

×
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值

举报

选择你想要举报的内容(必选)
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他
点击体验
DeepSeekR1满血版
程序员都在用的中文IT技术交流社区

程序员都在用的中文IT技术交流社区

专业的中文 IT 技术社区,与千万技术人共成长

专业的中文 IT 技术社区,与千万技术人共成长

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

客服 返回顶部