算法之回溯算法框架
回溯算法框架
前言
熟悉二叉树的同学都知道，二叉树遍历有三种：前序遍历、中序遍历以及后序遍历
不熟悉也不打紧，下面给你简单科普一下：
前序遍历的遍历顺序是：根节点–>左节点–>右节点
中序遍历的遍历顺序是：左节点–>根节点–>右节点
后序遍历的遍历顺序是：左节点–>右节点–>根节点
代码如下：
/* 基本的二叉树节点 */
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int value) : val(value), left(nullptr), right(nullptr) {}
};
void NodeAction(TreeNode *node) {
cout << node->val << endl;
}
// 前序遍历
void PreTraverse(TreeNode *root) {
if (root == nullptr) {
return;
}
NodeAction(root); // 当前节点需要做的操作，如：打印
PreTraverse(root->left);
PreTraverse(root->right);
}
// 中序遍历
void MiddleTraverse(TreeNode *root) {
if (root == nullptr) {
return;
}
MiddleTraverse(root->left);
NodeAction(root); // 当前节点需要做的操作，如：打印
MiddleTraverse(root->right);
}
// 后序遍历
void PostTraverse(TreeNode *root) {
if (root == nullptr) {
return;
}
PostTraverse(root->left);
PostTraverse(root->right);
NodeAction(root); // 当前节点需要做的操作，如：打印
}
从上面代码可以看出，二叉树的遍历核心思想是：递归、递归、递归！
算法分析
直接上干货，实际上回溯算法与二叉树遍历有异曲同工之妙！都是以递归为基础进行的，都是将一棵“树”完全遍历，也就是暴力穷举！但是回溯算法有个“做出选择”以及“撤销选择”的过程。
result = []
def backtrack(路径, 选择列表):
if 满足结束条件:
result.add(路径)
return
for 选择 in 选择列表:
做选择
backtrack(路径, 选择列表)
撤销选择
实际上回溯算法包含四大步骤就是：
- 路径列表
- 做出选择
- 撤销选择
- 终止条件
N 皇后问题
简单解释一下：给你一个 N×N 的棋盘，让你放置 N 个皇后，使得它们不能互相攻击。
PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。
如果将一个回溯问题看作是一棵决策树，回溯算法就是在这棵树上从上往下一层一层地做出选择，那N皇后这个问题本质实际上就是每一层的决策树表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。
直接套公式：
vector> res;
// 是否可以在 board[row][col] 放置皇后？
bool isValid(vector& board, int row, int col) {
int n = board.size();
// 检查列是否有皇后互相冲突
for (int i = 0; i < n; i++) {
if (board[i][col] == 'Q')
return false;
}
// 检查右上方是否有皇后互相冲突
for (int i = row - 1, j = col + 1;
i >= 0 && j < n; i--, j++) {
if (board[i][j] == 'Q')
return false;
}
// 检查左上方是否有皇后互相冲突
for (int i = row - 1, j = col - 1;
i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 'Q')
return false;
}
return true;
}
// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector& board, int row) {
// 触发结束条件
if (row == board.size()) {
res.push_back(board);
return;
}
int n = board[row].size();
for (int col = 0; col < n; col++) {
// 排除不合法选择
if (!isValid(board, row, col))
continue;
// 做选择
board[row][col] = 'Q';
// 进入下一行决策
backtrack(board, row + 1);
// 撤销选择
board[row][col] = '.';
}
}
// 输入棋盘边长 n，返回所有合法的放置
vector> solveNQueens(int n) {
// '.' 表示空，'Q' 表示皇后，初始化空棋盘。
vector board(n, string(n, '.'));
backtrack(board, 0);
return res;
}
从上面是不是能看得到二叉树遍历的身影？是就没错了！
回溯算法这种暴力遍历的方法导致的一个问题就是时间复杂度贼大。一般来说题目都会让你在适当的时候终止遍历，如上面的N皇后问题，一般来说，只需要你得出其中一种摆放方式即可。
将上面的代码添加适当的终止条件：
vector> res;
// 是否可以在 board[row][col] 放置皇后？
bool isValid(vector& board, int row, int col) {
int n = board.size();
// 检查列是否有皇后互相冲突
for (int i = 0; i < n; i++) {
if (board[i][col] == 'Q')
return false;
}
// 检查右上方是否有皇后互相冲突
for (int i = row - 1, j = col + 1;
i >= 0 && j < n; i--, j++) {
if (board[i][j] == 'Q')
return false;
}
// 检查左上方是否有皇后互相冲突
for (int i = row - 1, j = col - 1;
i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 'Q')
return false;
}
return true;
}
// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
bool backtrack(vector& board, int row) {
// 触发结束条件
if (row == board.size()) {
res.push_back(board);
return true;
}
int n = board[row].size();
for (int col = 0; col < n; col++) {
// 排除不合法选择
if (!isValid(board, row, col))
continue;
// 做选择
board[row][col] = 'Q';
// 进入下一行决策
if (backtrack(board, row + 1)) {
return true;
}
// 撤销选择
board[row][col] = '.';
}
return false;
}
// 输入棋盘边长 n，返回所有合法的放置
vector> solveNQueens(int n) {
// '.' 表示空，'Q' 表示皇后，初始化空棋盘。
vector board(n, string(n, '.'));
backtrack(board, 0);
return res;
}
总某种程度上来说，动态规划的一种暴力解就是回溯算法；一般来说单单只套用回溯算法的实用性题目是比较少的，都是需要在某个情况做出适当的调整~