1、无重复字符串的排列组合。编写一种方法,计算某字符串的所有排列组合,字符串每个字符均不相同。
输入:S = "qwe"
输出:["qwe", "qew", "wqe", "weq", "ewq", "eqw"]
def backtrace(s):
if s == "":
res.append("".join(path))
return
for i in range(len(s)):
path.append(s[i])
backtrace(s[:i]+s[i+1:])
path.pop()
path = []
res = []
backtrace(S)
return res
2、有重复字符串的排列组合。编写一种方法,计算某字符串的所有排列组合。
输入:S = "qqe"
输出:["eqq","qeq","qqe"]
def backtrace(s):
if s == "":
res.append("".join(path))
return
for i in range(len(s)):
if i > 0 and s[i] == s[i-1]: continue
path.append(s[i])
backtrace(s[:i]+s[i+1:])
path.pop()
path = []
res = []
backtrace(S)
return res
3、给定一个不含重复数字的数组 nums
,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
res = []
path=[]
def backtrace(nums):
if not nums:
res.append(path[:])
return
for i in range(len(nums)):
path.append(nums[i])
backtrace(nums[:i] + nums[i+1:])
path.pop()
backtrace(nums)
return res
4、给定一个可包含重复数字的序列 nums
,按任意顺序 返回所有不重复的全排列。
输入:nums = [1,1,2]
输出:[[1,1,2],[1,2,1],[2,1,1]]
def recall(nums, subset):
if not nums:
res.append(subset[:])
return
for i in range(len(nums)):
if i > 0 and nums[i] == nums[i-1]: continue
subset.append(nums[i])
recall(nums[:i]+nums[i+1:],subset)
subset.pop()
res = []
nums.sort()
recall(nums, [])
return res
5、给你一个整数数组 nums
,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
输入:nums = [1,2,3]
输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
res = []
n = len(nums)
def backtrace(i, tmp):
res.append(tmp)
for j in range(i, n):
backtrace(j + 1,tmp + [nums[j]] )
backtrace(0, [])
return res
6、给你一个整数数组 nums ,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
res = []
n = len(nums)
nums.sort()
def backtrace(i, tmp):
res.append(tmp)
for j in range(i, n):
if j>i and nums[j]==nums[j-1]:continue
backtrace(j + 1,tmp + [nums[j]] )
backtrace(0, [])
return res
7、给定两个整数 n
和 k
,返回范围 [1, n]
中所有可能的 k
个数的组合。
你可以按 任何顺序 返回答案。
输入:n = 4, k = 2
输出:
[ [2,4],[3,4],[2,3],[1,2],[1,3],[1,4]]
res = []
def backtrace(i,tmp):
if len(tmp) == k:
res.append(tmp)
return
for j in range(i,n+1):
backtrace(j+1,tmp+[j])
backtrace(1,[])
return res
8、找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字。
输入: k = 3, n = 7
输出: [[1,2,4]]
res = []
def combination(candidates,target,res_list):
if target < 0:
return
if target == 0:
res.append(res_list)
for i,c in enumerate(candidates):
# 为了避免重复 (例如candiactes=[2,3,6,7],target=7,输出[[2,2,3],[3,2,2][7]])
# 传到的下一个candicate为candicates[i:]
combination(candidates[i:],target-c,res_list+[c])
combination(candidates,target,[])
return res
9、给定一个可能有重复数字的整数数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次,解集不能包含重复的组合。
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:[[1,1,6],[1,2,5],[1,7],[2,6]]
def backtrack(tmp, cur, index):
if cur > target:
return
if cur == target:
res.append(tmp)
return
for i in range(index, n):
if i > index and candidates[i] == candidates[i - 1]:
continue
backtrack(tmp + [candidates[i]], cur + candidates[i], i + 1)
res = []
n = len(candidates)
candidates.sort()
backtrack([], 0, 0)
return res
10、给定一个无重复元素的正整数数组 candidates 和一个正整数 target ,找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。
candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同,则两种组合是唯一的。
对于给定的输入,保证和为 target 的唯一组合数少于 150 个。
输入: candidates = [2,3,6,7], target = 7
输出: [[7],[2,2,3]]
def backtrace(i,temp,target):
if target<0:return
if target==0:
res.append(temp)
for j in range(i,len(candidates)):
backtrace(j,temp+[candidates[j]],target-candidates[j])
res=[]
candidates.sort()
backtrace(0,[],target)
return res
11、你有一套活字字模 tiles
,其中每个字模上都刻有一个字母 tiles[i]
。返回你可以印出的非空字母序列的数目。
注意:本题中,每个活字字模只能使用一次。
输入:"AAB"
输出:8
解释:可能的序列为 "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA"。
res = []
def backtrack(tiles, path):
if tiles == []:
return
for i in range(len(tiles)):
cur = tiles[i]
if (path + cur) not in res:
res.append(path + cur)
backtrack(tiles[:i] + tiles[i+1:], path + cur)
backtrack(tiles, '')
return len(res)
11、有重复字符串的排列组合。编写一种方法,计算某字符串的所有排列组合。
输入:s = "aab"
输出:[["a","a","b"],["aa","b"]]
12、数字 n
代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
res=[]
def backtrace(temp,left,right):
if len(temp) == 2 * n:
res.append(''.join(temp))
return
if left<n:
backtrace(temp+["("],left+1,right)
if right<left:
backtrace(temp+[")"],left,right+1)
backtrace([],0,0)
return res