93. 复原 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 地址。给定一个只包含数字的字符串
s
,用以表示一个 IP 地址,返回所有可能的有效 IP 地址,这些地址可以通过在s
中插入'.'
来形成。你 不能 重新排序或删除s
中的任何数字。你可以按 任何 顺序返回答案。示例 1:
输入:s = "25525511135" 输出:["255.255.11.135","255.255.111.35"]示例 2:
输入:s = "0000" 输出:["0.0.0.0"]示例 3:
输入:s = "101023" 输出:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]提示:
1 <= s.length <= 20
s
仅由数字组成
class Solution(object):
def restoreIpAddresses(self, s):
"""
:type s: str
:rtype: List[str]
time: O(N)
最坏情况下,我们需要考虑字符串中所有可能的4-segment combinations,
即每个segment长度可为1、2、3。总共有 3 * 3 * 3 * 3 = 81 种分割方式。
每种分割方式都需要O(N)时间来生成和保存这个字符串,因此总时间复杂度为O(N)。
space: O(1)
储所有可能的IP地址需要的额外空间,最多有81种有效的IP地址,
所以空间复杂度为O(1)(常数级别)。
"""
output = []
def backtracking(first = 0, curr = [], sum_dot = 0):
# base case:
if sum_dot > 4:
return
if first == len(s) and sum_dot == 4:
output.append('.'.join(curr))
return
for i in range(first, min(len(s),first+3)):
segment = s[first:i + 1]
# Check for leading zeros and integer range
if (len(segment) > 1 and segment[0] == '0') or int(segment) > 255:
continue
curr.append(segment)
sum_dot += 1
backtracking(i+1, curr, sum_dot)
sum_dot -= 1
curr.pop()
backtracking()
return output
78. 子集
给你一个整数数组
nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1:
输入:nums = [1,2,3] 输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]示例 2:
输入:nums = [0] 输出:[[],[0]]提示:
1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums
中的所有元素 互不相同
class Solution(object):
def subsets(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
time: O(n * 2 ^ n)
该算法的时间复杂度主要取决于解的数量,即输出列表output的大小
。对于一个长度为n的数组,其幂集(所有可能的子集)的大小为 2 ^ n,
因此,填充output列表的时间复杂度为 O(2 ^ n)
对于每个子集,我们需要 O(n) 的时间来复制它(即curr[:]操作)。
space: O(2 ^ n)
输出列表output需要 O(2 ^ n)的空间。
除了输出之外,算法使用 O(n) 的递归调用栈空间。
"""
output = []
def backtracking(first = 0, curr = []):
# base:
output.append(curr[:])
if first == len(nums):
return
for i in range(first, len(nums)):
curr.append(nums[i])
backtracking(i + 1, curr)
curr.pop()
backtracking()
return output
90. 子集 II
给你一个整数数组
nums
,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
输入:nums = [1,2,2] 输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]示例 2:
输入:nums = [0] 输出:[[],[0]]提示:
1 <= nums.length <= 10
-10 <= nums[i] <= 10
class Solution(object):
def subsetsWithDup(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
time: O(n * 2 ^ n)
排序:O(nlogn)
递归:
该算法的时间复杂度主要取决于解的数量,即输出列表output的大小。对
于一个长度为n的数组,其幂集(所有可能的子集)的大小为 2 ^ n,
因此,填充output列表的时间复杂度为 O(2 ^ n)。
创建子集副本:对于每个子集,我们需要 O(n) 的时间来复制它(即curr[:]操作)。
space: O(2 ^ n)
输出列表output需要 O(2 ^ n)的空间。
除了输出之外,算法使用 O(n) 的递归调用栈空间。
"""
nums.sort()
output = []
def backtracking(first = 0, curr = []):
# base case
output.append(curr[:])
for i in range(first, len(nums)):
if i > first and nums[i] == nums[i-1]:
continue
curr.append(nums[i])
backtracking(i+1, curr)
curr.pop()
backtracking()
return output