文章目录
1.没有重复项数字的全排列
给出一组数字，返回该组数字的所有排列
例如：
[1,2,3]的所有排列如下
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1].
（以数字在数组中的位置靠前为优先级，按字典序排列输出。）
数据范围：数字个数 0 < n \le 60<n≤6
要求：空间复杂度 O(n!)O(n!) ，时间复杂度 O(n!）O(n!）
输入：[1,2,3]
返回值：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
class Solution:
def permute(self , num: List[int]) -> List[List[int]]:
# write code here
if not num: return None
num.sort()
res=[]
self.recall(0,num,res)
return res
def recall(self,first,num1,res):# 这个first给了才能确保现在是第几个 太难了 给我我也写不出来
if first == len(num1)-1:
res.append(num1)
else:
for i in range(first, len(num1)):
num1[i], num1[first] = num1[first], num1[i]
num2 = num1[:]
self.recall(first+1, num2, res)
借助下一题的另一种方法
class Solution:
def permute(self , num: List[int]) -> List[List[int]]:
# write code here
if not num: return None
res = []
num.sort()
def backtracck(num,temp):# 这个也好难
if not num:
res.append(temp)
return
for i in range(len(num)):
backtracck(num[:i] + num[i+1:], temp+[num[i]])# num[:0]=[]
backtracck(num, [])
return res
2.有重复项数字的全排列
给出一组可能包含重复项的数字，返回该组数字的所有排列。结果以字典序升序排列。
数据范围： 0 < n \le 80<n≤8 ，数组中的值满足 -1 \le val \le 5−1≤val≤5
要求：空间复杂度 O(n!)O(n!)，时间复杂度 O(n!)O(n!)
输入：[1,1,2]
返回值：[[1,1,2],[1,2,1],[2,1,1]]
class Solution:
def permuteUnique(self , num: List[int]) -> List[List[int]]:
# write code here
if not num: return None
res = []
num.sort()
def backtracck(num,temp):# 这个也好难
if not num:
res.append(temp)
return
for i in range(len(num)):
if i>0 and num[i] == num[i-1]:
continue
backtracck(num[:i] + num[i+1:], temp+[num[i]])# num[:0]=[]
backtracck(num, [])
return res
3.岛屿数量（类似在找最大联通路径
给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。
例如：
输入
[
[1,1,0,0,0],
[0,1,0,1,1],
[0,0,0,1,1],
[0,0,0,0,0],
[0,0,1,1,1]
]
对应的输出为3
(注：存储的01数据其实是字符’0’,‘1’)
输入：[
[1,1,0,0,0],
[0,1,0,1,1],
[0,0,0,1,1],
[0,0,0,0,0],
[0,0,1,1,1]
]
返回值：3
class Solution:
def solve(self , grid: List[List[str]]) -> int:
# write code here
res,n,m=0,len(grid),len(grid[0])
def replace(i,j):
if 0<=i<n and 0<=j<m:
if grid[i][j]=='1':# 这个判断不能删掉 删掉的话 递归就太多了
# 虽然我在for里边已经直到他是1了 但是后面调用的时候不知道
grid[i][j]='0'
replace(i-1, j)
replace(i+1, j)
replace(i, j-1)
replace(i, j+1)
num =0
for i in range(n):
for j in range(m):
if grid[i][j] == '1':
num += 1
replace(i, j)
return num
4.字符串的排列（这道题和排数组一样
输入一个长度为 n 字符串，打印出该字符串中字符的所有排列，你可以以任意顺序返回这个字符串数组。
例如输入字符串ABC,则输出由字符A,B,C所能排列出来的所有字符串ABC,ACB,BAC,BCA,CBA和CAB。
数据范围：n < 10n<10
要求：空间复杂度 O(n!)O(n!)，时间复杂度 O(n!)O(n!)
输入描述：
输入一个字符串,长度不超过10,字符只包括大小写字母。
示例1
输入：“ab”
返回值：[“ab”,“ba”]
返回[“ba”,“ab”]也是正确的
class Solution:
def Permutation(self , str: str) -> List[str]:
# write code here
# 先求出可能出现的第一个字符 然后求第二个字符可能出现的情况
# 简而言之就是 固定 变化 固定 变化
# 那么我们就是可以用递归的
# 但是有可能会有相同的 所以选择不同的时候 交换 这样会比较简单
#（借助一个set 放现有的存在的元素 这样可以用xx in判断
n=len(str)
res=[]
queue=list(str)# 因为字符串是不可交换的 所以先要把他转换为列表
# 固定第X位上的字符
def fix(x):# 简单点就是说这个是在固定第x个值
# 递归结束的条件
if x==n-1:
res.append(''.join(queue))
return
seen=set()
for i in range(x,n):# 当前x位和后面所有的交换
if queue[i] in seen:continue# 如果已经存在了 那么这次就不用管了
seen.add(queue[i])# 因为是集合 所以就add
queue[x] ,queue[i]=queue[i] ,queue[x]# 先交换
fix(x+1)# 交换完就开始递归下一位
queue[i] ,queue[x]=queue[x] ,queue[i]# 交换了 肯定还得交换回来 不然就会奇怪
fix(0)
return res
5.N 皇后问题
N 皇后问题是指在 n * n 的棋盘上要摆 n 个皇后，
要求：任何两个皇后不同行，不同列也不在同一条斜线上，
求给一个整数 n ，返回 n 皇后的摆法数。
数据范围: 1≤n≤9
要求：空间复杂度 O(1)，时间复杂度 O(n!)
例如当输入4时，对应的返回值为2，
对应的两种四皇后摆位如下图所示：
输入：1
返回值：1
输入：8
返回值：92
6.
7.
