《博主简介》

小伙伴们好,我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。
更多学习资源,可关注公-仲-hao:【阿旭算法与机器学习】,共同学习交流~
感谢小伙伴们点赞、关注!

组合总和1

classSolution:

defcombinationSum(self,candidates:List[int],target:int)->List[List[int]]:

defDFS(candidates,target,start,track):

ifsum(track)==target:

res.append(track.copy())

return

ifsum(track)>target:

return

fori inrange(start,len(candidates)):

track.append(candidates[i])

DFS(candidates,target, i,track)

track.pop()

res =[]

DFS(candidates,target,0,[])

returnres

元素可以重复使用,进入下一层时从i开始。元素不能重复使用时,进入下一层时从i+1卡开始。

组合总和2

classSolution:

defcombinationSum2(self,candidates:List[int],target:int)->List[List[int]]:

defDFS(candidates,target,start,track):

ifsum(track)>target:

return

ifsum(track)==target:

res.append(track.copy())

fori inrange(start,len(candidates)):

# 忽略掉同一层中重复的选项,上述for循环为本层的可选择列表

ifi 1>=start andcandidates[i1]==candidates[i]:

continue

track.append(candidates[i])

DFS(candidates,target,i+1,track)

track.pop()

res =[]

candidates.sort()

DFS(candidates,target,0,[])

returnres

注:当题目中说明所给序列可能包含重复的组合或者子集时,解题套路是要先对原数组进行排序,并且在回溯的写法中,要加上对重复元素跳过的判断,即:

# if(i>startIndex)

# {

# if(candidates[i]==candidates[i-1])

# continue;

# }

# 其它的写题做法和回溯是一样的,可以加上剪枝判断,回溯中也要对sum一并进行回溯。

#for 循环枚举出选项时,加入下面判断,忽略掉同一层重复的选项,避免产生重复的组合。比如[1,2,2,2,5]中,选了第一个 2,变成 [1,2],第一个 2 的下一选项也是 2,跳过它,因为选它,就还是 [1,2]

关键总结:

  1. 如果元素可以重复使用,进入下一层时从i开始。元素不能重复使用时,进入下一层时从i+1开始。
  2. 当题目中说明所给序列可能包含重复的组合或者子集时,解题套路是要先对原数组进行排序,并且在回溯的写法中,要加上对重复元素跳过的判断

全排列1

classSolution:

defpermute(self,nums:List[int])->List[List[int]]:

defbacktrack(nums,track):

iflen(nums)==len(track):

res.append(track.copy())

return

fori innums:

# 排除不合法的选择,即不能选择已经在track中的元素

ifi intrack:

continue

track.append(i)

backtrack(nums,track)

track.pop()

res =[]

backtrack(nums,[])

returnres

全排列问题1与组合问题1的主要差别在于:

1.是否需要使用start参数来进行下一层开始选择元素的标识。

2.全排列问题,需要ifi intrack: continue,剔除上次选择的元素。

全排列2

classSolution:

defpermuteUnique(self,nums:List[int])->List[List[int]]:

defDFS(nums,track,used):

iflen(track)==len(nums):

res.append(track.copy())

return

fori inrange(len(nums)):#https://leetcode-cn.com/problems/permutations-ii/solution/47-quan-pai-lie-iiche-di-li-jie-pai-lie-zhong-de-q/

#这里理解used[i – 1]非常重要

# // used[i – 1] == true,说明同一树枝上nums[i – 1]使用过,在同一个递归栈内,试用过的都是Ture

# // used[i – 1] == false,说明同一树层nums[i – 1]使用过,因为回溯会使上一个元素重新变为False

# // 如果同一树层nums[i – 1]使用过则直接跳过

ifi >0andnums[i]==nums[i1]andused[i1]==False:

continue

ifused[i]==False:

used[i]=True

track.append(nums[i])

DFS(nums,track,used)

track.pop()

used[i]=False

res =[]

nums.sort()

used =[Falsefori inrange(len(nums))]

DFS(nums,[],used)

returnres

注:上述组合总和2与全排列2,去重的条件有一点点差别,主要原因是排列的话需要考虑前后位置差异,而组合的话不需要考虑位置差异。

组合的去重条件:

# 忽略掉同一层中重复的选项,上述for循环为本层的可选择列表

ifi 1>=start andcandidates[i1]==candidates[i]:

排列的去重条件:

ifi >0andnums[i]==nums[i1]andused[i1]==False:

彻底理解排列中的去重问题】详解

思路

这道题目和46.全排列的区别在与给定一个可包含重复数字的序列,要返回所有不重复的全排列。

这里就涉及到去重了。

要注意全排列是要取树的叶子节点的,如果是子集问题,就取树上的所有节点。

这个去重为什么很难理解呢,所谓去重,其实就是使用过的元素不能重复选取这么一说好像很简单!

但是什么又是“使用过”,我们把排列问题抽象为树形结构之后,“使用过”在这个树形结构上是有两个维度的,一个维度是同一树枝上使用过,一个维度是同一树层上使用过。

没有理解这两个层面上的“使用过”是造成大家没有彻底理解去重的根本原因。

那么排列问题,既可以在同一树层上的“使用过”来去重,也可以在同一树枝上的“使用过”来去重!

理解这一本质,很多疑点就迎刃而解了。

还要强调的是去重一定要对元素经行排序,这样我们才方便通过相邻的节点来判断是否重复使用了

首先把示例中的[1,1,2] (为了方便举例,已经排序),抽象为一棵树,然后在同一树层上对nums[i-1]使用过的话,进行去重如图:

图中我们对同一树层,前一位(也就是nums[i-1])如果使用过,那么就进行去重。

拓展

大家发现,去重最为关键的代码为:

if (i > 0 && nums[i] == nums[i – 1] && used[i – 1] == false) {

continue;

}

可是如果把used[i – 1] == true 也是正确的,去重代码如下:

if (i > 0 && nums[i] == nums[i – 1] && used[i – 1] == true) {

continue;

}

这是为什么呢,就是上面我刚说的,如果要对树层中前一位去重,就用used[i – 1] == false,如果要对树枝前一位去重用用used[i – 1] == true。

对于排列问题,树层上去重和树枝上去重,都是可以的,但是树层上去重效率更高!

这么说是不是有点抽象?

来来来,我就用输入: [1,1,1] 来举一个例子。

树层上去重(used[i – 1] == false),的树形结构如下:

树枝上去重(used[i – 1] == true)的树型结构如下:

大家应该很清晰的看到,树层上去重非常彻底,效率很高,树枝上去重虽然最后可能得到答案,但是多做了很多无用搜索。

子集(组合问题

classSolution:

defsubsets(self,nums:List[int])->List[List[int]]:

defbacktrack(nums,track,start):

res.append(track.copy())

ifstart >=len(nums):

return

fori inrange(start,len(nums)):

track.append(nums[i])

backtrack(nums,track,i +1)

track.pop()

res =[]

backtrack(nums,[],0)

returnres

子集2(组合问题)

classSolution:

defsubsetsWithDup(self,nums:List[int])->List[List[int]]:

defbacktrack(nums,start,track):

res.append(track.copy())

fori inrange(start,len(nums)):

ifi1>=start andnums[i]==nums[i1]:#同层去重

continue

track.append(nums[i])

backtrack(nums,i+1,track)

track.pop()

res=[]

nums.sort()

backtrack(nums,0,[])

returnres

字符串排列排列问题且涉及去重

原始字符串可能存在重复字符’aab’—‘aba’,’baa’

classSolution:

defpermutation(self,s:str)->List[str]:

defbacktrack(s,cur_s):

iflen(cur_s)==len(s):

res.append(cur_s)

return

fori inrange(len(s)):

ifi >0ands[i]==s[i1]andvisited[i1]==False: #同层去重

continue

ifvisited[i]==False:

visited[i]=True

backtrack(s,cur_s +s[i])

visited[i]=False

res =[]

visited =[Falsefor_ inrange(len(s))]

s =.join(sorted(list(s)))

backtrack(s,)

returnres

写法二

classSolution:

defpermutation(self,s:str)->List[str]:

defbacktrack(s,path):

ifnots:

res.append(path)

seen =set()

fori inrange(len(s)):

ifs[i]inseen:continue #同层去重

seen.add(s[i])

#传递的字符串去除了当前选择的字符s[:i]+s[i+1:]

backtrack(s[:i]+s[i+1:],path +s[i])

res =[]

backtrack(s,“”)

returnres

关于本篇文章大家有任何建议或意见,欢迎在评论区留言交流!

觉得不错的小伙伴,感谢点赞、关注加收藏哦!

欢迎关注下方GZH:阿旭算法与机器学习,共同学习交流~