leetcode刷题记录
  • Leetcode刷题记录
  • 191 - 227 基本计算器2
  • 48 - 第二高的薪水
  • 226 - 494 目标和
  • 76 - 各位相加
  • 56 - 第十行
  • 196 - 328 奇偶链表
  • 106 - 485最大连续1的个数
  • 168 - 240 搜索二维矩阵2 - 001
  • 55 - 有效电话号码
  • 2 TOW SUM Ⅱ
  • 149 - 213 打家劫舍2
  • 91 - 有效的完全平方数
  • 59 - 198 打家劫舍
  • 166 - 92 反转链表2
  • 110 - 581 最短无序连续子数组
  • 197 - 454 四数相加2
  • 75 - 二叉树的所有路径
  • 41 - 最小栈
  • 27 - 最小差值
  • 177 - 337 打家劫舍3
  • 228 - 994 腐烂的橘子
  • 71 - 用栈实现队列
  • 30 - 将有序数组转换为二叉搜索树
  • 143 - 89 格雷编码
  • 184 - 152 乘积最大子序列
  • 221 - 354 俄罗斯套娃信封问题
  • 124 - 2 两数相加
  • 205 - 287 寻找重复数
  • 83 - 猜数字游戏
  • 25 - 对称二叉树
  • 90 - 两个数组的交集2
  • 163 - 877 石子游戏
  • 123 - 617 合并二叉树
  • 227 - 377 组合总和 Ⅳ
  • 144 - 146 LRU缓存机制
  • 18 - 加一
  • 145 - 215 数组中第k个最大元素
  • 65 - 存在重复元素
  • 17 - 最后一个单词的长度
  • 69 - 2的幂
  • 133 - 47 全排列2
  • 161 - 322 零钱兑换
  • 200 - 297 二叉树的序列化和反序列化
  • 152 - 63 不同路径2
  • 210 - 279 完全平方数
  • 154 - 264 丑数2
  • 183 - 212 单词搜索2
  • 22 - 删除排序链表中的重复元素
  • 100 - 左叶子之和
  • 128 - 16 最接近的三数之和
  • 204 - 162 寻找峰值
  • 190 - 239 滑动窗口最大值
  • 79 - 第一个错误版本
  • 178 - 52 n皇后2
  • 131 - 415 字符串相加
  • 8-最长公共前缀
  • 5-整数反转Reverse Integer
  • 159 - 120 三角形最小路径和
  • 64 - 反转链表
  • 21 - 爬楼梯
  • 36 - 买卖股票的最佳时机
  • 188 - 378 有序矩阵中第k小的元素
  • 135 - 54 螺旋矩阵
  • 24 - 相同的树
  • 33 - 路径总和
  • 202 - 179 最大数
  • 142 - 40 组合总和2
  • 104 - 414第三大的数
  • 180 - 140 单词拆分2
  • 129 - 33 搜索旋转排序数组
  • 225 - 474 一和零
  • 84 - 区域和检索- 数组不可变
  • 74 - 有效的字母异位词
  • 86 - 4的幂
  • 34 - 杨辉三角
  • 138 - 62 不同路径
  • 98 - 第n个数字
  • 85 - 3的幂
  • 49 - 超过经理收入的员工
  • 116 - 1025 除数博弈
  • 31 - 平衡二叉树
  • 97 - 判断子序列
  • 73 - 删除列表中的节点
  • 3-Two Sum IV - Input is a BST
  • 15 - 报数
  • 89 - 两个数组的交集
  • 167 - 74 搜索二维矩阵 - 001
  • 187 - 295 数据流的中位数
  • 164 - 72 编辑距离
  • 194 - 150 逆波兰表达式求值
  • 115 - 665 非递减数列
  • 81 - 单词规律
  • 139 - 78 子集
  • 150 - 148 排序链表
  • 140 - 90 子集2
  • 136 - 59 螺旋矩阵2
  • 16 - 最大子序和
  • 19 - 二进制求和
  • 12 - 移除元素
  • 112 - 628 三个数的最大乘积
  • 51 - 从不订购的客户
  • 39 - 只出现一次的数字
  • 189 - 347 前k个高频元素
  • 181 - 208 实现前缀树Trie
  • 35 - 杨辉三角2
  • 209 - 128 最长连续序列
  • 217 - 134 加油站
  • 147 - 230 二叉树搜索树中第k小的元素
  • 207 - 395 至少有K个重复字符的最长子串
  • git自动提交脚本
  • 212 - 127 单词接龙
  • 214 - 207 课程表
  • 117 - 661 图片平滑器
  • 186 - 334 递增的三元子序列
  • 105 - 448找到数组中消失的数字
  • 43 - excel表列名称
  • 113 - 643 子数组最大平均数1
  • 63 - 同构字符串
  • 7-罗马数字转整数
  • 195 - 138 复制带随机指针的链表
  • 107 - 532数组中的k-diff数对
  • 58 - 上升的温度
  • 141 - 39 组合总和
  • 182 - 79 单词搜索
  • 101 - 数字转换为16进制数
  • 125 - 5 最长回文子串
  • 23 - 合并两个有序数组
  • 40 - 环形链表
  • 95 - 字符串中的第一个唯一字符
  • 114 - 746使用最小花费爬楼梯
  • 37 - 买卖股票的最佳时机2
  • 132 - 46 全排列
  • 29 - 二叉树的层次遍历2
  • 77 - 丑数
  • 66 - 存在重复元素2
  • 68 - 翻转二叉树
  • 137 - 61 旋转链表
  • 60 - 快乐数
  • 54 - 位1的个数
  • 93 - 猜数字大小
  • 11 - 删除排序数组中的重复项
  • 134 - 51 N皇后
  • 99 - 二进制手表
  • 215 - 210 课程表 II
  • 224 - 518 零钱兑换 II
  • 127 - 11 盛最多水的容器
  • leetcode笔记
  • 4-3sum
  • 50 - 查找重复的电子邮箱
  • 176 - 621 任务调度器
  • 103 - fizz buzz
  • 220 - 188 买卖股票的最佳时机 IV
  • 82 - Nim游戏
  • 213 - 200 岛屿数量
  • 72 - 二叉树的最近公共祖先
  • 87 - 反转字符串
  • 78 - 缺失数字
  • 118 - 437 路径综合3
  • 121 - 538 把二叉树转换为累加树
  • 20 - x的平方根
  • 126 - 8 字符串转换整数
  • 157 - 464 我能赢吗
  • 158 - 42 接雨水
  • 80 - 移动零
  • 122 - 543 二叉树的直径
  • 199 - 380 常数时间插入、删除和获取随机元素
  • 背包九讲
  • 9-有效的括号
  • 47 - 组合两个表
  • 1 两数之和(Two Sum)
  • 62 - 计数质数
  • 88 - 反转字符串中的元音字母
  • 14 - 搜索插入位置
  • 28 - 二叉树层次遍历1
  • 119 - 461 汉明距离
  • 70 - 回文链表
  • 32 - 二叉树的最小深度
  • 46 - 阶乘后的零
  • 120 - 557 反转字符串中的单词3
  • 170 - 154 寻找旋转排序数组中的最小值2 - 006
  • 57 - 删除重复的电子邮箱
  • 53 - 颠倒二进制位
  • 223 - 132 分割回文串
  • 146 - 238 除自身外数组的乘积
  • 109 - 566重塑矩阵
  • 45 - excel表序列号
  • 174 - 1004 最大连续1的个数3
  • 171 - 替换空格 - 002
  • 179 - 131 分割回文串
  • 198 - 18 四数之和
  • 6-回文数
  • 52 - 旋转数组
  • 172 - 151 翻转字符串里面的单词 - 044
  • 192 - 224 基本计算器
  • 173 - 567 字符串的排列 027
  • 208 - 124 二叉树中的最大路径和
  • 13 - 实现strStr()
  • 42 - 相交链表
  • 169 - 153 寻找旋转排序数组最小值 - 006
  • 108 - 561数组拆分
  • 211 - 329 矩阵中的最长递增路径
  • 153 - 64 最小路径和
  • 225 - 416 分割等和子集
  • 222 - 486 预测赢家
  • 203 - 324 摆动排序2
  • 175 - 260 只出现一次的数字3 - 040
  • 155 - 96 不同的二叉搜索树
  • 165 - 887 鸡蛋掉落
  • 102 - 最长回文串
  • 193 - 341 扁平化嵌套列表迭代器
  • 10 - 合并两个有序链表
  • 162 - 300 最长上升子序列
  • 160 - 139 单词拆分
  • 151 - 236 二叉树的最近公共祖先
  • 44 - 求众数
  • 185 - 384 打乱数组
  • 216 - 149 直线上最多的点数
  • 61 - 移除链表元素
  • 218 - 91 解码方法
  • 67 - 用队列实现栈
  • 219 - 123 买卖股票的最佳时机
  • 比赛
  • 92 - 两整数之和
  • 130 - 43 字符串相乘
  • 96 - 找不同
  • 111 - 605种花问题
  • 201 - 218 天际线问题
  • 26 - 二叉树的最大深度
  • 206 - 315 计算右侧小于当前元素的个数
  • 94 - 赎金信
  • 38 - 验证回文串
  • 148 - 142 环形链表2
  • 156 - 95 不同的二叉搜索树2
Powered by GitBook
On this page
  • 题目
  • 解答
  • 全排列为例
  • n皇后
  • n皇后2

Was this helpful?

178 - 52 n皇后2

Previous79 - 第一个错误版本Next131 - 415 字符串相加

Last updated 5 years ago

Was this helpful?

题目

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。

img

上图为 8 皇后问题的一种解法。

给定一个整数 n,返回 n 皇后不同的解决方案的数量。

示例:

输入: 4 输出: 2 解释: 4 皇后问题存在如下两个不同的解法。 [ [".Q..", // 解法 1 "...Q", "Q...", "..Q."],

["..Q.", // 解法 2 "Q...", "...Q", ".Q.."] ]

解答

解决一个回溯问题,实际上就是一个决策树的遍历过程。你只需要思考 3 个问题:

1、路径:也就是已经做出的选择。

2、选择列表:也就是你当前可以做的选择。

3、结束条件:也就是到达决策树底层,无法再做选择的条件。

全排列为例

我们定义的backtrack函数其实就像一个指针,在这棵树上游走,同时要正确维护每个节点的属性:剩余选择和已走路径。每当走到树的底层,其「路径」就是一个全排列。

各种搜索问题其实都是树的遍历问题,而多叉树的遍历框架就是这样

前序遍历的代码在进入某一个节点之前的那个时间点执行,后序遍历代码在离开某个节点之后的那个时间点执行。

不管怎么优化,时间复杂度都不可能低于 O(N!),因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点,不像动态规划存在重叠子问题可以优化,回溯算法就是纯暴力穷举,复杂度一般都很高。

n皇后

决策树的每一层表示棋盘上的每一行;每个节点可以做出的选择是,在该行的任意一列放置一个皇后。

python的数组似乎是浅拷贝,因此board生成之后就全部都被修改了。。

var solveNQueens = function(n) {
  if (n === 0) {
    return []
  }
  let res = []
  let board = []
  for (let i = 0; i < n; i++) {
    let tmp = []
    for (let j = 0; j < n; j++) {
      tmp.push(".")
    }
    board.push(tmp)
  }

  const valid = function(board, row, col) {
    for (let i = 0; i < n; i++) {
      if (board[i][col] === "Q") {
        return false
      }
    }
    for (let i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
      if (board[i][j] === "Q") {
        return false
      }
    }
    for (let i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
      if (board[i][j] === "Q") {
        return false
      }
    }
    return true
  }
  const backtrack = function(board, row) {
    if (row === n) {
      tmp = []
      for (const item of board) {
        tmp.push(item.join(""))
      }
      res.push(tmp)
      return
    }
    for (let col = 0; col < n; col++) {
      if (!valid(board, row, col)) {
        continue
      }
      board[row][col] = "Q"
      backtrack(board, row + 1)
      board[row][col] = "."
    }
  }

  backtrack(board, 0)
  return res
};

Runtime: 68 ms, faster than 79.26% of JavaScript online submissions for N-Queens.

Memory Usage: 37.1 MB, less than 100.00% of JavaScript online submissions for N-Queens.

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        ans = []
        queens = [-1]*n
        columns = [True]*n+[False]
        back = [True]*n*2
        forward = [True]*n*2
        row = col = 0
        while True:
            if columns[col] and back[col-row+n] and forward[col+row]:
                queens[row] = col
                columns[col] = back[col-row+n] = forward[col+row] = False
                row += 1
                col = 0
                if row == n:
                    ans.append(['.'*q+'Q'+'.'*(n-q-1) for q in queens])
            else:
                if row == n or col == n:
                    if row == 0:
                        return ans
                    row -= 1
                    col = queens[row]
                    columns[col] = back[col-row+n] = forward[col+row] = True
                col += 1

Runtime: 48 ms, faster than 98.01% of Python3 online submissions for N-Queens.

Memory Usage: 13.1 MB, less than 100.00% of Python3 online submissions for N-Queens.

n皇后2

class Solution:
    def totalNQueens(self, n: int) -> int:
        diag1 = set()
        diag2 = set()
        usedCols = set()

        return self.helper(n, diag1, diag2, usedCols, 0)

    def helper(self, n, diag1, diag2, usedCols, row):
        if row == n:
            return 1

        solutions = 0

        for col in range(n):
            if row + col in diag1 or row - col in diag2 or col in usedCols:
                continue

            diag1.add(row + col)
            diag2.add(row - col)
            usedCols.add(col)

            solutions += self.helper(n, diag1, diag2, usedCols, row + 1)

            diag1.remove(row + col)
            diag2.remove(row - col)
            usedCols.remove(col)

        return solutions

Runtime: 48 ms, faster than 87.61% of Python3 online submissions for N-Queens II.

Memory Usage: 12.7 MB, less than 100.00% of Python3 online submissions for N-Queens II.

看不懂的位运算

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.res = 0

        def dfs(row, col, ld, rd):
            if row >= n:
                self.res += 1
                return
            bits = ~(col | ld | rd) & ((1 << n)-1)
            while bits > 0:
                pick = bits & -bits
                dfs(row+1, col | pick, (ld | pick) << 1, (rd | pick) >> 1)
                bits &= bits-1

        dfs(0, 0, 0, 0)
        return self.res

Runtime: 32 ms, faster than 99.09% of Python3 online submissions for N-Queens II.

Memory Usage: 12.8 MB, less than 100.00% of Python3 online submissions for N-Queens II.

image-20191221095220049
img
image-20191221095505611
img

)

https://leetcode-cn.com/problems/n-queens/solution/hui-su-suan-fa-xiang-jie-by-labuladong/
https://leetcode.com/problems/n-queens-ii/discuss/126533/Python-Backtracking-Solution-(Beats-97