[https://leetcode-cn.com/problems/permutations/solution/quan-pai-lie-by-leetcode-solution-2/](https://leetcode-cn.com/problems/permutations/solution/quan-pai-lie-by-leetcode-solution-2/)





![在这里插入图片描述](/static/img/images/01128.png)

```python
from typing import List
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def dfs(start):
            if start == n:
                sol.append(nums[:])
            for i in range(start, n):
                nums[start], nums[i] =  nums[i], nums[start]
                dfs( start+1 )
                nums[start], nums[i] =  nums[i], nums[start]
        sol = []
        n = len(nums)
        dfs(0)
        return sol
a = Solution()
print(a.permute([1, 2, 3]))
```

或者写成：
```
from typing import List
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def dfs(sol):
            if len(sol) == n:
                res.append(nums[:])
            for i in range(0, n):
                if used[i]: continue
                sol.append(nums[i])
                used[i] = 1
                dfs(sol)
                sol.pop()
                used[i] = 0
        res = []
        n = len(nums)
        used = [0 for _ in range(n)]
        dfs([])
        return res
print(Solution().permute([1, 2, 3]))
```



[https://leetcode-cn.com/problems/permutations-ii/solution/](https://leetcode-cn.com/problems/permutations-ii/solution/)

![在这里插入图片描述](/static/img/images/01129.png)

```python
from typing import List
class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        def dfs(sol):
            if len(sol) == n:
                res.append(sol[:])
                return
            for i in range(0, n):  # nums 不改变
                # print(i, used)
                if used[i]: continue  # 当前位置的元素被使用过
                if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]: continue  # 剪枝：新位置元素和上一个相同，并且上一个元素是没用过
                sol.append(nums[i])
                used[i] = 1
                dfs(sol)
                sol.pop()
                used[i] = 0
        res = []
        n = len(nums)
        nums.sort()
        used = [0 for i in range(n)]  # 全局，看看是第几层递归
        dfs([])
        # res=[tuple(i) for i in res]
        # return list(set(res))
        return res
print(Solution().permuteUnique([1, 1, 1]))
```

【算法题目】【DFS】全排列1,2

[https://leetcode-cn.com/problems/n-queens/solution/liang-chong-shi-xian-xiang-xi-tu-jie-51-n-huang-ho/](https://leetcode-cn.com/problems/n-queens/solution/liang-chong-shi-xian-xiang-xi-tu-jie-51-n-huang-ho/)






伪代码

```python
dfs函数(x) { 
    if x==n { //如果x等于n了，说明每行的皇后都放置完毕
        //将棋盘内容的快照保存下来
        return
    }
    for(y=0;i<n;++y) {
        if [x,y]这个位置是有效的，即横、竖、两个斜线都有没有被攻击 {
            将棋盘[x,y]位置设置为 Q
            dfs(x+1) 继续尝试下一行
            将棋盘[x,y]位置还原
        }
    }
}
```

python3
```python
class Solution(object):
    def solveNQueens(self, n):
        # 生成N*N的棋盘，填充棋盘，每个格子默认是''.''表示没有放置皇后
        arr = [["." for _ in range(n)] for _ in range(n)]  # 生成列表最好方式是采用列表推导式
        res = []  # 存放最终结果
        # 检查当前的行和列是否可以放置皇后
        def check(x: int, y: int):
            # 检查竖着的一列是否有皇后
            for i in range(x):
                if arr[i][y] == "Q":
                    return False
            # 检查左上的斜边是否有皇后
            i, j = x - 1, y - 1
            while i >= 0 and j >= 0:
                if arr[i][j] == "Q":
                    return False
                i, j = i - 1, j - 1
            # 检查左下的斜边是否有皇后
            i, j = x - 1, y + 1
            while i >= 0 and j < n:
                if arr[i][j] == "Q":
                    return False
                i, j = i - 1, j + 1
            # 检查右上的斜边是否有皇后
            i, j = x + 1, y - 1
            while i < n and j >= 0:
                if arr[i][j] == "Q":
                    return False
                i, j = i + 1, j - 1
            # 检查右下的斜边是否有皇后
            i, j = x + 1, y + 1
            while i < n and j < n:
                if arr[i][j] == "Q":
                    return False
                i, j = i + 1, j + 1
            return True
        def dfs(x):
            # x是从0开始计算的
            # 当x==n时所有行的皇后都放置完毕，此时记录结果
            if x == n:
                res.append(["".join(arr[i]) for i in range(n)])
                return
            # 遍历每一列
            for y in range(n):
                # 检查[x,y]这一坐标是否可以放置皇后
                # 如果满足条件，就放置皇后，并继续检查下一行
                if check(x, y):
                    arr[x][y] = "Q"  # 放上皇后
                    dfs(x + 1)  # 搜索下一行策略
                    arr[x][y] = "."  # 撤销皇后，y进入下一列搜索
        dfs(0)
        return res
print(len(Solution().solveNQueens(8)))
```

利用一个规律改进算法。之前check()是循环，效率不高。

python3
```python
class Solution(object):
    def solveNQueens(self, n):
        # 生成N*N的棋盘，填充棋盘，每个格子默认是''.''表示没有放置皇后
        arr = [["." for _ in range(n)] for _ in range(n)]  # 生成列表最好方式是采用列表推导式
        res = []  # 存放最终结果
        columns = set()
        hypotenuse1 = set()
        hypotenuse2 = set()
        # 检查当前的行和列是否可以放置皇后
        def check(x: int, y: int):
            if y in columns:
                return False
            if x - y in hypotenuse1:
                return False
            if x + y in hypotenuse2:
                return False
            return True
        def dfs(x):
            # x是从0开始计算的
            # 当x==n时所有行的皇后都放置完毕，此时记录结果
            if x == n:
                res.append(["".join(arr[i]) for i in range(n)])
                return
            # 遍历每一列
            for y in range(n):
                # 检查[x,y]这一坐标是否可以放置皇后
                # 如果满足条件，就放置皇后，并继续检查下一行
                if check(x, y):
                    columns.add(y)
                    hypotenuse1.add(x - y)
                    hypotenuse2.add(x + y)
                    arr[x][y] = "Q"  # 放上皇后
                    dfs(x + 1)  # 搜索下一行策略
                    arr[x][y] = "."  # 撤销皇后，y进入下一列搜索
                    columns.remove(y)
                    hypotenuse1.remove(x - y)
                    hypotenuse2.remove(x + y)
        dfs(0)
        return res
print(Solution().solveNQueens(8))
```

![在这里插入图片描述](/static/img/images/01130.png)

![在这里插入图片描述](/static/img/images/01131.png)

N皇后（递归+回溯）

# 36. 有效的数独 





![在这里插入图片描述](/static/img/images/01132.png)

python
```python
from typing import List
class Solution:
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        # init data
        rows = [{} for i in range(9)] # 字典 哈希表 列表第一个字典：rows[0]这个字典是第一行的键值信息
        columns = [{} for i in range(9)] # 字典 哈希表
        boxes = [{} for i in range(9)] # 字典 哈希表
        # validate a board
        for i in range(9):
            for j in range(9):
                num = board[i][j]  # 第i行  第j列  的元素
                if num != '.':
                    num = int(num)
                    box_index = (i // 3) * 3 + j // 3    # 在一个3*3方格里的index
                    # keep the current cell value
                    rows[i][num] = rows[i].get(num, 0) + 1  # 第i行的rows字典里找这个元素，找不到就是0，加1后变成1. 找得到加上1后就会大于1
                    columns[j][num] = columns[j].get(num, 0) + 1
                    boxes[box_index][num] = boxes[box_index].get(num, 0) + 1
                    # check if this value has been already seen before
                    if rows[i][num] > 1 or columns[j][num] > 1 or boxes[box_index][num] > 1:
                        return False
        return True
print(Solution().isValidSudoku([
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]  ]))
```

运行完毕后：

![在这里插入图片描述](/static/img/images/01133.png)

![在这里插入图片描述](/static/img/images/01134.png)

![在这里插入图片描述](/static/img/images/01135.png)

按健寻值的字典：

```python
rows = [{} for i in range(9)]
print(rows)
rows[0][1]=1
rows[0][3]=1
rows[1][1]=1
print(rows)
```

结果
```python
C:\Users\xd_du\Anaconda3\envs\py37\python.exe C:/Users/xd_du/PycharmProjects/wave/gendata.py
[{}, {}, {}, {}, {}, {}, {}, {}, {}]
[{1: 1, 3: 1}, {1: 1}, {}, {}, {}, {}, {}, {}, {}]
Process finished with exit code 0
```

# 37. 解数独

https://leetcode-cn.com/problems/sudoku-solver/solution/jie-shu-du-by-leetcode-solution/

![在这里插入图片描述](/static/img/images/01136.png)

```python
from typing import List
class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        def dfs(pos: int):
            nonlocal valid
            if pos == len(spaces):
                valid = True
                return
            i, j = spaces[pos]
            for digit in range(9):
                if line[i][digit] == column[j][digit] == block[i // 3][j // 3][digit] == False:
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True
                    board[i][j] = str(digit + 1)
                    dfs(pos + 1)   #递归
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = False
                if valid:
                    return
        line = [[False] * 9 for _ in range(9)]
        column = [[False] * 9 for _ in range(9)]
        block = [[[False] * 9 for _a in range(3)] for _b in range(3)]
        valid = False
        spaces = list()
        for i in range(9):
            for j in range(9):
                if board[i][j] == ".":
                    spaces.append((i, j))
                else:
                    digit = int(board[i][j]) - 1
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True
        dfs(0)
board = [
    ["5", "3", ".", ".", "7", ".", ".", ".", "."],
    ["6", ".", ".", "1", "9", "5", ".", ".", "."],
    [".", "9", "8", ".", ".", ".", ".", "6", "."],
    ["8", ".", ".", ".", "6", ".", ".", ".", "3"],
    ["4", ".", ".", "8", ".", "3", ".", ".", "1"],
    ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
    [".", "6", ".", ".", ".", ".", "2", "8", "."],
    [".", ".", ".", "4", "1", "9", ".", ".", "5"],
    [".", ".", ".", ".", "8", ".", ".", "7", "9"]]
Solution().solveSudoku(board)
for i in range(9):
    print(board[i])
```

```python
def check(matrix, row, col, value):
    """
    检测在(row,col)放value是否合适
    1.每行含1-9,不含重复值value
    2.每列含1-9,不含重复值value
    3.3*3区块含1-9,不含重复值value
    """
    # 检测每行
    for j in range(9):
        if matrix[row][j] == value:
            return False
    # 检测每列
    for i in range(9):
        if matrix[i][col] == value:
            return False
    # 检测元素所在3*3区域
    area_row = (row // 3) * 3
    area_col = (col // 3) * 3
    for i in range(area_row, area_row + 3):
        for j in range(area_col, area_col + 3):
            if matrix[i][j] == value:
                return False
    return True
def solveSudoku(matrix, count=0):
    """
    遍历每一个未填元素，遍历1-9替换为合适的数字
    """
    if (count == 81):  # 递归出口
        return True
    #行优先遍历
    row = count // 9  # 行标
    col = count % 9  # 列标
    if matrix[row][col] != 0:  # 已填充
        return solveSudoku(matrix, count=count + 1)
    else:  # 未填充
        for i in range(1, 10):
            if check(matrix, row, col, i):  # 找到可能的填充数
                matrix[row][col] = i
                if solveSudoku(matrix, count=count + 1):  # 是否可完成
                    return True  # 可完成
                # 不可完成
                matrix[row][col] = 0  # 回溯
        return False  # 不可完成
while True:
    try:
        matrix = []
        for i in range(9):
            matrix.append([int(i) for i in  input().split(' ')])#多维列表输入
        solveSudoku(matrix)
        for i in range(9):
            print( ' '.join(map(str, matrix[i])))
    except:
        break
```



# 生成一张标准数独地图

标准数独地图有17个数字提示，且是有唯一解的。

36. 有效的数独（遍历一次 9+9+9个字典 哈希） 37. 解数独

# 1 两数之和





https://leetcode-cn.com/problems/two-sum/

![在这里插入图片描述](/static/img/images/01137.png)

python

![在这里插入图片描述](/static/img/images/01138.png)

```python
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
```

# 2 三数之和

![在这里插入图片描述](/static/img/images/01139.png)

python
```python
from typing import List
class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        nums.sort()
        ans = list()
        # 枚举 a
        for first in range(n):  # 遍历所有元素
            # 需要和上一次枚举的数不相同
            if first > 0 and nums[first] == nums[first - 1]:
                continue
            # c 对应的指针初始指向数组的最右端
            third = n - 1
            target = -nums[first]
            # 枚举 b
            for second in range(first + 1, n):
                # 需要和上一次枚举的数不相同
                if second > first + 1 and nums[second] == nums[second - 1]:
                    continue
                # 需要保证 b 的指针在 c 的指针的左侧
                while second < third and nums[second] + nums[third] > target:
                    third -= 1
                # 如果指针重合，随着 b 后续的增加
                # 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if second == third:
                    break
                if nums[second] + nums[third] == target:
                    ans.append([nums[first], nums[second], nums[third]])
        return ans
print(Solution().threeSum([3, 5, 4, 4, -2, -2, -1, -3, -3]))
```

# 3 四数之和

https://leetcode-cn.com/problems/4sum/solution/si-shu-zhi-he-by-leetcode-solution/

![在这里插入图片描述](/static/img/images/01140.png)

1. 两数之和（哈希表） 15. 三数之和（双指针） 18. 四数之和

https://leetcode-cn.com/problems/container-with-most-water/





![在这里插入图片描述](/static/img/images/01141.png)

python

```python
class Solution:
    def maxArea(self, height) -> int:
        l, r = 0, len(height) - 1  # 左右指针
        ans = 0
        while l < r:  # 左右指针指向同一个元素的时候退出循环
            area = min(height[l], height[r]) * (r - l)  # 面积　＝　最短挡板　×　间距
            ans = max(ans, area)  # 答案只想要最大的面积
            if height[l] <= height[r]:  # 左挡板 小于 右挡板
                l += 1  # 左指针移动
            else:
                r -= 1  # 右指针移动
        return ans
print(Solution().maxArea([3, 5, 4]))
```

左右指针正确性：

（1）假设左指针指着height[0]不动；

（2）移动可行性：右指针指着height[-1]，此时面积假设为area1。如果右指针移动，指着height[-2]，此时面积假设为area2。间距的缩小，使得只有当height[-2]挡板大于之前的，才有可能找到更大的值。

（3）该移动哪一个指针？：左挡板 小于等于 右挡板，那么就移动左指针。

11. 盛最多水的容器 双指针

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。