47.排序II

1.跟46题一样只不过加一个树层去重

class Solution(object):
    def backtracking(self,nums,path,result,used):
        # recursion stop
        if len(path) == len(nums):
            # collect our set
            result.append(path[:])
            return 
        
        for i in range(len(nums)):
            if (i > 0 and nums[i] == nums[i-1] and used[i-1] == 0) or used[i]:
                continue
            # add element
            path.append(nums[i])
            used[i] = 1
            # recursion
            self.backtracking(nums,path,result,used)
            # backtracking
            path.pop()
            used[i] = 0

    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums.sort()
        used = [0] * len(nums)
        result = []

        self.backtracking(nums,[],result,used)
        return result
        

51. N-皇后

1. 同一行同一列，45°角度在nxn的棋盘不能出现同个皇后  

2. 每一层有个for循环遍历每一行(暴力破解想法)

3. nxn的话就是嵌套n层for循环所以我们要使用回溯

4. 每一行的长度就是数的宽度

伪代码

result //三维数组

void backtracking(chestboard,n,row){
    // 递归终止条件
    if row == n{
        // 遍历到最后一行说明到叶子节点，需要收取结果
        result.push_back(chesstboard)
    }


    // 递归单层条件
    for(i=0; i<n; i++){
        // 判断当前行数和当前位置是否是合法放皇后的位置
        // isValid是来做前行数和当前位置是否是合法放皇后的位置
        if(isValid(row,i,chessborad,n)){
            // 合法位置可以放皇后
            cheesborad[row][i] == 'Q';
            // 进入递归
            backtracking(chessboard,n,row+1)
            // 回溯
            chessborad[row][i] == ""
        }
    }
}

运行代码

class Solution:
    def solveNQueens(self, n):
        result = []  # 存储最终结果的二维字符串数组

        chessboard = ['.' * n for _ in range(n)]  # 初始化棋盘
        self.backtracking(n, 0, chessboard, result)  # 回溯求解
        return [[''.join(row) for row in solution] for solution in result]  # 返回结果集

    def backtracking(self, n, row, chessboard, result):
        if row == n:
            result.append(chessboard[:])  # 棋盘填满，将当前解加入结果集
            return

        for col in range(n):
            if self.isValid(row, col, chessboard):
                chessboard[row] = chessboard[row][:col] + 'Q' + chessboard[row][col+1:]  # 放置皇后
                self.backtracking(n, row + 1, chessboard, result)  # 递归到下一行
                chessboard[row] = chessboard[row][:col] + '.' + chessboard[row][col+1:]  # 回溯，撤销当前位置的皇后

    def isValid(self, row, col, chessboard):
        # 检查列
        for i in range(row):
            if chessboard[i][col] == 'Q':
                return False  # 当前列已经存在皇后，不合法

        # 检查 45 度角是否有皇后
        i, j = row - 1, col - 1
        while i >= 0 and j >= 0:
            if chessboard[i][j] == 'Q':
                return False  # 左上方向已经存在皇后，不合法
            i -= 1
            j -= 1

        # 检查 135 度角是否有皇后
        i, j = row - 1, col + 1
        while i >= 0 and j < len(chessboard):
            if chessboard[i][j] == 'Q':
                return False  # 右上方向已经存在皇后，不合法
            i -= 1
            j += 1

        return True  # 当前位置合法