13.1 Backtracking algorithms¶
Backtracking algorithm is a method to solve problems by exhaustive search, where the core idea is to start from an initial state and brute force all possible solutions, recording the correct ones until a solution is found or all possible choices are exhausted without finding a solution.
Backtracking typically employs "depth-first search" to traverse the solution space. In the "Binary Tree" chapter, we mentioned that preorder, inorder, and postorder traversals are all depth-first searches. Next, we use preorder traversal to construct a backtracking problem to gradually understand the workings of the backtracking algorithm.
Example One
Given a binary tree, search and record all nodes with a value of \(7\), please return a list of nodes.
For this problem, we traverse this tree in preorder and check if the current node's value is \(7\). If it is, we add the node's value to the result list res. The relevant process is shown in the following diagram and code:
preorder_traversal_i_compact.rs
/* 前序遍历：例题一 */
fn pre_order(res: &mut Vec<Rc<RefCell<TreeNode>>>, root: Option<Rc<RefCell<TreeNode>>>) {
if root.is_none() {
return;
}
if let Some(node) = root {
if node.borrow().val == 7 {
// 记录解
res.push(node.clone());
}
pre_order(res, node.borrow().left.clone());
pre_order(res, node.borrow().right.clone());
}
}
Code Visualization
Figure 13-1 Searching nodes in preorder traversal
13.1.1 Trying and retreating¶
The reason it is called backtracking is that the algorithm uses a "try" and "retreat" strategy when searching the solution space. When the algorithm encounters a state where it can no longer progress or fails to achieve a satisfying solution, it undoes the previous choice, reverts to the previous state, and tries other possible choices.
For Example One, visiting each node represents a "try", and passing a leaf node or returning to the parent node's return represents "retreat".
It's worth noting that retreat is not merely about function returns. We expand slightly on Example One for clarification.
Example Two
In a binary tree, search for all nodes with a value of \(7\) and please return the paths from the root node to these nodes.
Based on the code from Example One, we need to use a list path to record the visited node paths. When a node with a value of \(7\) is reached, we copy path and add it to the result list res. After the traversal, res holds all the solutions. The code is as shown:
preorder_traversal_ii_compact.go
/* 前序遍历：例题二 */
func preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
if root == nil {
return
}
// 尝试
*path = append(*path, root)
if root.Val.(int) == 7 {
// 记录解
*res = append(*res, append([]*TreeNode{}, *path...))
}
preOrderII(root.Left, res, path)
preOrderII(root.Right, res, path)
// 回退
*path = (*path)[:len(*path)-1]
}
preorder_traversal_ii_compact.ts
/* 前序遍历：例题二 */
function preOrder(
root: TreeNode | null,
path: TreeNode[],
res: TreeNode[][]
): void {
if (root === null) {
return;
}
// 尝试
path.push(root);
if (root.val === 7) {
// 记录解
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.pop();
}
preorder_traversal_ii_compact.dart
/* 前序遍历：例题二 */
void preOrder(
TreeNode? root,
List<TreeNode> path,
List<List<TreeNode>> res,
) {
if (root == null) {
return;
}
// 尝试
path.add(root);
if (root.val == 7) {
// 记录解
res.add(List.from(path));
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.removeLast();
}
preorder_traversal_ii_compact.rs
/* 前序遍历：例题二 */
fn pre_order(
res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
path: &mut Vec<Rc<RefCell<TreeNode>>>,
root: Option<Rc<RefCell<TreeNode>>>,
) {
if root.is_none() {
return;
}
if let Some(node) = root {
// 尝试
path.push(node.clone());
if node.borrow().val == 7 {
// 记录解
res.push(path.clone());
}
pre_order(res, path, node.borrow().left.clone());
pre_order(res, path, node.borrow().right.clone());
// 回退
path.remove(path.len() - 1);
}
}
preorder_traversal_ii_compact.c
/* 前序遍历：例题二 */
void preOrder(TreeNode *root) {
if (root == NULL) {
return;
}
// 尝试
path[pathSize++] = root;
if (root->val == 7) {
// 记录解
for (int i = 0; i < pathSize; ++i) {
res[resSize][i] = path[i];
}
resSize++;
}
preOrder(root->left);
preOrder(root->right);
// 回退
pathSize--;
}
Code Visualization
In each "try", we record the path by adding the current node to path; before "retreating", we need to pop the node from path to restore the state before this attempt.
Observe the process shown in Figure 13-2, we can understand trying and retreating as "advancing" and "undoing", two operations that are reverse to each other.
Figure 13-2 Trying and retreating
13.1.2 Pruning¶
Complex backtracking problems usually involve one or more constraints, which are often used for "pruning".
Example Three
In a binary tree, search for all nodes with a value of \(7\) and return the paths from the root to these nodes, requiring that the paths do not contain nodes with a value of \(3\).
To meet the above constraints, we need to add a pruning operation: during the search process, if a node with a value of \(3\) is encountered, it returns early, discontinuing further search. The code is as shown:
preorder_traversal_iii_compact.cs
/* 前序遍历：例题三 */
void PreOrder(TreeNode? root) {
// 剪枝
if (root == null || root.val == 3) {
return;
}
// 尝试
path.Add(root);
if (root.val == 7) {
// 记录解
res.Add(new List<TreeNode>(path));
}
PreOrder(root.left);
PreOrder(root.right);
// 回退
path.RemoveAt(path.Count - 1);
}
preorder_traversal_iii_compact.go
/* 前序遍历：例题三 */
func preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
// 剪枝
if root == nil || root.Val == 3 {
return
}
// 尝试
*path = append(*path, root)
if root.Val.(int) == 7 {
// 记录解
*res = append(*res, append([]*TreeNode{}, *path...))
}
preOrderIII(root.Left, res, path)
preOrderIII(root.Right, res, path)
// 回退
*path = (*path)[:len(*path)-1]
}
preorder_traversal_iii_compact.ts
/* 前序遍历：例题三 */
function preOrder(
root: TreeNode | null,
path: TreeNode[],
res: TreeNode[][]
): void {
// 剪枝
if (root === null || root.val === 3) {
return;
}
// 尝试
path.push(root);
if (root.val === 7) {
// 记录解
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.pop();
}
preorder_traversal_iii_compact.dart
/* 前序遍历：例题三 */
void preOrder(
TreeNode? root,
List<TreeNode> path,
List<List<TreeNode>> res,
) {
if (root == null || root.val == 3) {
return;
}
// 尝试
path.add(root);
if (root.val == 7) {
// 记录解
res.add(List.from(path));
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// 回退
path.removeLast();
}
preorder_traversal_iii_compact.rs
/* 前序遍历：例题三 */
fn pre_order(
res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
path: &mut Vec<Rc<RefCell<TreeNode>>>,
root: Option<Rc<RefCell<TreeNode>>>,
) {
// 剪枝
if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {
return;
}
if let Some(node) = root {
// 尝试
path.push(node.clone());
if node.borrow().val == 7 {
// 记录解
res.push(path.clone());
}
pre_order(res, path, node.borrow().left.clone());
pre_order(res, path, node.borrow().right.clone());
// 回退
path.remove(path.len() - 1);
}
}
preorder_traversal_iii_compact.c
/* 前序遍历：例题三 */
void preOrder(TreeNode *root) {
// 剪枝
if (root == NULL || root->val == 3) {
return;
}
// 尝试
path[pathSize++] = root;
if (root->val == 7) {
// 记录解
for (int i = 0; i < pathSize; i++) {
res[resSize][i] = path[i];
}
resSize++;
}
preOrder(root->left);
preOrder(root->right);
// 回退
pathSize--;
}
preorder_traversal_iii_compact.kt
/* 前序遍历：例题三 */
fun preOrder(root: TreeNode?) {
// 剪枝
if (root == null || root._val == 3) {
return
}
// 尝试
path!!.add(root)
if (root._val == 7) {
// 记录解
res!!.add(path!!.toMutableList())
}
preOrder(root.left)
preOrder(root.right)
// 回退
path!!.removeAt(path!!.size - 1)
}
Code Visualization
"Pruning" is a very vivid noun. As shown in the diagram below, in the search process, we "cut off" the search branches that do not meet the constraints, avoiding many meaningless attempts, thus enhancing the search efficiency.
Figure 13-3 Pruning based on constraints
13.1.3 Framework code¶
Next, we attempt to distill the main framework of "trying, retreating, and pruning" from backtracking to enhance the code's universality.
In the following framework code, state represents the current state of the problem, choices represents the choices available under the current state:
def backtrack(state: State, choices: list[choice], res: list[state]):
"""Backtracking algorithm framework"""
# Check if it's a solution
if is_solution(state):
# Record the solution
record_solution(state, res)
# Stop searching
return
# Iterate through all choices
for choice in choices:
# Pruning: check if the choice is valid
if is_valid(state, choice):
# Try: make a choice, update the state
make_choice(state, choice)
backtrack(state, choices, res)
# Retreat: undo the choice, revert to the previous state
undo_choice(state, choice)
/* Backtracking algorithm framework */
void backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for (Choice choice : choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
void backtrack(State state, List<Choice> choices, List<State> res) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for (Choice choice : choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
void Backtrack(State state, List<Choice> choices, List<State> res) {
// Check if it's a solution
if (IsSolution(state)) {
// Record the solution
RecordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
foreach (Choice choice in choices) {
// Pruning: check if the choice is valid
if (IsValid(state, choice)) {
// Try: make a choice, update the state
MakeChoice(state, choice);
Backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
UndoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
func backtrack(state *State, choices []Choice, res *[]State) {
// Check if it's a solution
if isSolution(state) {
// Record the solution
recordSolution(state, res)
// Stop searching
return
}
// Iterate through all choices
for _, choice := range choices {
// Pruning: check if the choice is valid
if isValid(state, choice) {
// Try: make a choice, update the state
makeChoice(state, choice)
backtrack(state, choices, res)
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice)
}
}
}
/* Backtracking algorithm framework */
func backtrack(state: inout State, choices: [Choice], res: inout [State]) {
// Check if it's a solution
if isSolution(state: state) {
// Record the solution
recordSolution(state: state, res: &res)
// Stop searching
return
}
// Iterate through all choices
for choice in choices {
// Pruning: check if the choice is valid
if isValid(state: state, choice: choice) {
// Try: make a choice, update the state
makeChoice(state: &state, choice: choice)
backtrack(state: &state, choices: choices, res: &res)
// Retreat: undo the choice, revert to the previous state
undoChoice(state: &state, choice: choice)
}
}
}
/* Backtracking algorithm framework */
function backtrack(state, choices, res) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for (let choice of choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
function backtrack(state: State, choices: Choice[], res: State[]): void {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for (let choice of choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
void backtrack(State state, List<Choice>, List<State> res) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for (Choice choice in choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice);
}
}
}
/* Backtracking algorithm framework */
fn backtrack(state: &mut State, choices: &Vec<Choice>, res: &mut Vec<State>) {
// Check if it's a solution
if is_solution(state) {
// Record the solution
record_solution(state, res);
// Stop searching
return;
}
// Iterate through all choices
for choice in choices {
// Pruning: check if the choice is valid
if is_valid(state, choice) {
// Try: make a choice, update the state
make_choice(state, choice);
backtrack(state, choices, res);
// Retreat: undo the choice, revert to the previous state
undo_choice(state, choice);
}
}
}
/* Backtracking algorithm framework */
void backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res, numRes);
// Stop searching
return;
}
// Iterate through all choices
for (int i = 0; i < numChoices; i++) {
// Pruning: check if the choice is valid
if (isValid(state, &choices[i])) {
// Try: make a choice, update the state
makeChoice(state, &choices[i]);
backtrack(state, choices, numChoices, res, numRes);
// Retreat: undo the choice, revert to the previous state
undoChoice(state, &choices[i]);
}
}
}
/* Backtracking algorithm framework */
fun backtrack(state: State?, choices: List<Choice?>, res: List<State?>?) {
// Check if it's a solution
if (isSolution(state)) {
// Record the solution
recordSolution(state, res)
// Stop searching
return
}
// Iterate through all choices
for (choice in choices) {
// Pruning: check if the choice is valid
if (isValid(state, choice)) {
// Try: make a choice, update the state
makeChoice(state, choice)
backtrack(state, choices, res)
// Retreat: undo the choice, revert to the previous state
undoChoice(state, choice)
}
}
}
Next, we solve Example Three based on the framework code. The state is the node traversal path, choices are the current node's left and right children, and the result res is the list of paths:
preorder_traversal_iii_template.py
def is_solution(state: list[TreeNode]) -> bool:
"""判断当前状态是否为解"""
return state and state[-1].val == 7
def record_solution(state: list[TreeNode], res: list[list[TreeNode]]):
"""记录解"""
res.append(list(state))
def is_valid(state: list[TreeNode], choice: TreeNode) -> bool:
"""判断在当前状态下，该选择是否合法"""
return choice is not None and choice.val != 3
def make_choice(state: list[TreeNode], choice: TreeNode):
"""更新状态"""
state.append(choice)
def undo_choice(state: list[TreeNode], choice: TreeNode):
"""恢复状态"""
state.pop()
def backtrack(
state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]
):
"""回溯算法：例题三"""
# 检查是否为解
if is_solution(state):
# 记录解
record_solution(state, res)
# 遍历所有选择
for choice in choices:
# 剪枝：检查选择是否合法
if is_valid(state, choice):
# 尝试：做出选择，更新状态
make_choice(state, choice)
# 进行下一轮选择
backtrack(state, [choice.left, choice.right], res)
# 回退：撤销选择，恢复到之前的状态
undo_choice(state, choice)
preorder_traversal_iii_template.cpp
/* 判断当前状态是否为解 */
bool isSolution(vector<TreeNode *> &state) {
return !state.empty() && state.back()->val == 7;
}
/* 记录解 */
void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {
res.push_back(state);
}
/* 判断在当前状态下，该选择是否合法 */
bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
return choice != nullptr && choice->val != 3;
}
/* 更新状态 */
void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.push_back(choice);
}
/* 恢复状态 */
void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.pop_back();
}
/* 回溯算法：例题三 */
void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (TreeNode *choice : choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
vector<TreeNode *> nextChoices{choice->left, choice->right};
backtrack(state, nextChoices, res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice);
}
}
}
preorder_traversal_iii_template.java
/* 判断当前状态是否为解 */
boolean isSolution(List<TreeNode> state) {
return !state.isEmpty() && state.get(state.size() - 1).val == 7;
}
/* 记录解 */
void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
res.add(new ArrayList<>(state));
}
/* 判断在当前状态下，该选择是否合法 */
boolean isValid(List<TreeNode> state, TreeNode choice) {
return choice != null && choice.val != 3;
}
/* 更新状态 */
void makeChoice(List<TreeNode> state, TreeNode choice) {
state.add(choice);
}
/* 恢复状态 */
void undoChoice(List<TreeNode> state, TreeNode choice) {
state.remove(state.size() - 1);
}
/* 回溯算法：例题三 */
void backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (TreeNode choice : choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
backtrack(state, Arrays.asList(choice.left, choice.right), res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice);
}
}
}
preorder_traversal_iii_template.cs
/* 判断当前状态是否为解 */
bool IsSolution(List<TreeNode> state) {
return state.Count != 0 && state[^1].val == 7;
}
/* 记录解 */
void RecordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
res.Add(new List<TreeNode>(state));
}
/* 判断在当前状态下，该选择是否合法 */
bool IsValid(List<TreeNode> state, TreeNode choice) {
return choice != null && choice.val != 3;
}
/* 更新状态 */
void MakeChoice(List<TreeNode> state, TreeNode choice) {
state.Add(choice);
}
/* 恢复状态 */
void UndoChoice(List<TreeNode> state, TreeNode choice) {
state.RemoveAt(state.Count - 1);
}
/* 回溯算法：例题三 */
void Backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
// 检查是否为解
if (IsSolution(state)) {
// 记录解
RecordSolution(state, res);
}
// 遍历所有选择
foreach (TreeNode choice in choices) {
// 剪枝：检查选择是否合法
if (IsValid(state, choice)) {
// 尝试：做出选择，更新状态
MakeChoice(state, choice);
// 进行下一轮选择
Backtrack(state, [choice.left!, choice.right!], res);
// 回退：撤销选择，恢复到之前的状态
UndoChoice(state, choice);
}
}
}
preorder_traversal_iii_template.go
/* 判断当前状态是否为解 */
func isSolution(state *[]*TreeNode) bool {
return len(*state) != 0 && (*state)[len(*state)-1].Val == 7
}
/* 记录解 */
func recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {
*res = append(*res, append([]*TreeNode{}, *state...))
}
/* 判断在当前状态下，该选择是否合法 */
func isValid(state *[]*TreeNode, choice *TreeNode) bool {
return choice != nil && choice.Val != 3
}
/* 更新状态 */
func makeChoice(state *[]*TreeNode, choice *TreeNode) {
*state = append(*state, choice)
}
/* 恢复状态 */
func undoChoice(state *[]*TreeNode, choice *TreeNode) {
*state = (*state)[:len(*state)-1]
}
/* 回溯算法：例题三 */
func backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {
// 检查是否为解
if isSolution(state) {
// 记录解
recordSolution(state, res)
}
// 遍历所有选择
for _, choice := range *choices {
// 剪枝：检查选择是否合法
if isValid(state, choice) {
// 尝试：做出选择，更新状态
makeChoice(state, choice)
// 进行下一轮选择
temp := make([]*TreeNode, 0)
temp = append(temp, choice.Left, choice.Right)
backtrackIII(state, &temp, res)
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice)
}
}
}
preorder_traversal_iii_template.swift
/* 判断当前状态是否为解 */
func isSolution(state: [TreeNode]) -> Bool {
!state.isEmpty && state.last!.val == 7
}
/* 记录解 */
func recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {
res.append(state)
}
/* 判断在当前状态下，该选择是否合法 */
func isValid(state: [TreeNode], choice: TreeNode?) -> Bool {
choice != nil && choice!.val != 3
}
/* 更新状态 */
func makeChoice(state: inout [TreeNode], choice: TreeNode) {
state.append(choice)
}
/* 恢复状态 */
func undoChoice(state: inout [TreeNode], choice: TreeNode) {
state.removeLast()
}
/* 回溯算法：例题三 */
func backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {
// 检查是否为解
if isSolution(state: state) {
recordSolution(state: state, res: &res)
}
// 遍历所有选择
for choice in choices {
// 剪枝：检查选择是否合法
if isValid(state: state, choice: choice) {
// 尝试：做出选择，更新状态
makeChoice(state: &state, choice: choice)
// 进行下一轮选择
backtrack(state: &state, choices: [choice.left, choice.right].compactMap { $0 }, res: &res)
// 回退：撤销选择，恢复到之前的状态
undoChoice(state: &state, choice: choice)
}
}
}
preorder_traversal_iii_template.js
/* 判断当前状态是否为解 */
function isSolution(state) {
return state && state[state.length - 1]?.val === 7;
}
/* 记录解 */
function recordSolution(state, res) {
res.push([...state]);
}
/* 判断在当前状态下，该选择是否合法 */
function isValid(state, choice) {
return choice !== null && choice.val !== 3;
}
/* 更新状态 */
function makeChoice(state, choice) {
state.push(choice);
}
/* 恢复状态 */
function undoChoice(state) {
state.pop();
}
/* 回溯算法：例题三 */
function backtrack(state, choices, res) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (const choice of choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
backtrack(state, [choice.left, choice.right], res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state);
}
}
}
preorder_traversal_iii_template.ts
/* 判断当前状态是否为解 */
function isSolution(state: TreeNode[]): boolean {
return state && state[state.length - 1]?.val === 7;
}
/* 记录解 */
function recordSolution(state: TreeNode[], res: TreeNode[][]): void {
res.push([...state]);
}
/* 判断在当前状态下，该选择是否合法 */
function isValid(state: TreeNode[], choice: TreeNode): boolean {
return choice !== null && choice.val !== 3;
}
/* 更新状态 */
function makeChoice(state: TreeNode[], choice: TreeNode): void {
state.push(choice);
}
/* 恢复状态 */
function undoChoice(state: TreeNode[]): void {
state.pop();
}
/* 回溯算法：例题三 */
function backtrack(
state: TreeNode[],
choices: TreeNode[],
res: TreeNode[][]
): void {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (const choice of choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
backtrack(state, [choice.left, choice.right], res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state);
}
}
}
preorder_traversal_iii_template.dart
/* 判断当前状态是否为解 */
bool isSolution(List<TreeNode> state) {
return state.isNotEmpty && state.last.val == 7;
}
/* 记录解 */
void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
res.add(List.from(state));
}
/* 判断在当前状态下，该选择是否合法 */
bool isValid(List<TreeNode> state, TreeNode? choice) {
return choice != null && choice.val != 3;
}
/* 更新状态 */
void makeChoice(List<TreeNode> state, TreeNode? choice) {
state.add(choice!);
}
/* 恢复状态 */
void undoChoice(List<TreeNode> state, TreeNode? choice) {
state.removeLast();
}
/* 回溯算法：例题三 */
void backtrack(
List<TreeNode> state,
List<TreeNode?> choices,
List<List<TreeNode>> res,
) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res);
}
// 遍历所有选择
for (TreeNode? choice in choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice);
// 进行下一轮选择
backtrack(state, [choice!.left, choice.right], res);
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice);
}
}
}
preorder_traversal_iii_template.rs
/* 判断当前状态是否为解 */
fn is_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>) -> bool {
return !state.is_empty() && state.get(state.len() - 1).unwrap().borrow().val == 7;
}
/* 记录解 */
fn record_solution(
state: &mut Vec<Rc<RefCell<TreeNode>>>,
res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
) {
res.push(state.clone());
}
/* 判断在当前状态下，该选择是否合法 */
fn is_valid(_: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) -> bool {
return choice.borrow().val != 3;
}
/* 更新状态 */
fn make_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) {
state.push(choice);
}
/* 恢复状态 */
fn undo_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, _: Rc<RefCell<TreeNode>>) {
state.remove(state.len() - 1);
}
/* 回溯算法：例题三 */
fn backtrack(
state: &mut Vec<Rc<RefCell<TreeNode>>>,
choices: &mut Vec<Rc<RefCell<TreeNode>>>,
res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,
) {
// 检查是否为解
if is_solution(state) {
// 记录解
record_solution(state, res);
}
// 遍历所有选择
for choice in choices {
// 剪枝：检查选择是否合法
if is_valid(state, choice.clone()) {
// 尝试：做出选择，更新状态
make_choice(state, choice.clone());
// 进行下一轮选择
backtrack(
state,
&mut vec![
choice.borrow().left.clone().unwrap(),
choice.borrow().right.clone().unwrap(),
],
res,
);
// 回退：撤销选择，恢复到之前的状态
undo_choice(state, choice.clone());
}
}
}
preorder_traversal_iii_template.c
/* 判断当前状态是否为解 */
bool isSolution(void) {
return pathSize > 0 && path[pathSize - 1]->val == 7;
}
/* 记录解 */
void recordSolution(void) {
for (int i = 0; i < pathSize; i++) {
res[resSize][i] = path[i];
}
resSize++;
}
/* 判断在当前状态下，该选择是否合法 */
bool isValid(TreeNode *choice) {
return choice != NULL && choice->val != 3;
}
/* 更新状态 */
void makeChoice(TreeNode *choice) {
path[pathSize++] = choice;
}
/* 恢复状态 */
void undoChoice(void) {
pathSize--;
}
/* 回溯算法：例题三 */
void backtrack(TreeNode *choices[2]) {
// 检查是否为解
if (isSolution()) {
// 记录解
recordSolution();
}
// 遍历所有选择
for (int i = 0; i < 2; i++) {
TreeNode *choice = choices[i];
// 剪枝：检查选择是否合法
if (isValid(choice)) {
// 尝试：做出选择，更新状态
makeChoice(choice);
// 进行下一轮选择
TreeNode *nextChoices[2] = {choice->left, choice->right};
backtrack(nextChoices);
// 回退：撤销选择，恢复到之前的状态
undoChoice();
}
}
}
preorder_traversal_iii_template.kt
/* 判断当前状态是否为解 */
fun isSolution(state: MutableList<TreeNode?>): Boolean {
return state.isNotEmpty() && state[state.size - 1]?._val == 7
}
/* 记录解 */
fun recordSolution(state: MutableList<TreeNode?>?, res: MutableList<MutableList<TreeNode?>?>) {
res.add(state!!.toMutableList())
}
/* 判断在当前状态下，该选择是否合法 */
fun isValid(state: MutableList<TreeNode?>?, choice: TreeNode?): Boolean {
return choice != null && choice._val != 3
}
/* 更新状态 */
fun makeChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {
state.add(choice)
}
/* 恢复状态 */
fun undoChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {
state.removeLast()
}
/* 回溯算法：例题三 */
fun backtrack(
state: MutableList<TreeNode?>,
choices: MutableList<TreeNode?>,
res: MutableList<MutableList<TreeNode?>?>
) {
// 检查是否为解
if (isSolution(state)) {
// 记录解
recordSolution(state, res)
}
// 遍历所有选择
for (choice in choices) {
// 剪枝：检查选择是否合法
if (isValid(state, choice)) {
// 尝试：做出选择，更新状态
makeChoice(state, choice)
// 进行下一轮选择
backtrack(state, mutableListOf(choice!!.left, choice.right), res)
// 回退：撤销选择，恢复到之前的状态
undoChoice(state, choice)
}
}
}
Code Visualization
As per the requirements, after finding a node with a value of \(7\), the search should continue, thus the return statement after recording the solution should be removed. The following diagram compares the search processes with and without retaining the return statement.
Figure 13-4 Comparison of retaining and removing the return in the search process
Compared to the implementation based on preorder traversal, the code implementation based on the backtracking algorithm framework seems verbose, but it has better universality. In fact, many backtracking problems can be solved within this framework. We just need to define state and choices according to the specific problem and implement the methods in the framework.
13.1.4 Common terminology¶
To analyze algorithmic problems more clearly, we summarize the meanings of commonly used terminology in backtracking algorithms and provide corresponding examples from Example Three as shown in Table 13-1.
Table 13-1 Common backtracking algorithm terminology
| Term | Definition | Example Three |
|---|---|---|
| Solution (solution) | A solution is an answer that satisfies specific conditions of the problem, which may have one or more | All paths from the root node to node \(7\) that meet the constraint |
| Constraint (constraint) | Constraints are conditions in the problem that limit the feasibility of solutions, often used for pruning | Paths do not contain node \(3\) |
| State (state) | State represents the situation of the problem at a certain moment, including choices made | Current visited node path, i.e., path node list |
| Attempt (attempt) | An attempt is the process of exploring the solution space based on available choices, including making choices, updating the state, and checking if it's a solution | Recursively visiting left (right) child nodes, adding nodes to path, checking if the node's value is \(7\) |
| Backtracking (backtracking) | Backtracking refers to the action of undoing previous choices and returning to the previous state when encountering states that do not meet the constraints | When passing leaf nodes, ending node visits, encountering nodes with a value of \(3\), terminating the search, and function return |
| Pruning (pruning) | Pruning is a method to avoid meaningless search paths based on the characteristics and constraints of the problem, which can enhance search efficiency | When encountering a node with a value of \(3\), no further search is continued |
Tip
Concepts like problems, solutions, states, etc., are universal, and are involved in divide and conquer, backtracking, dynamic programming, and greedy algorithms, among others.
13.1.5 Advantages and limitations¶
The backtracking algorithm is essentially a depth-first search algorithm that attempts all possible solutions until a satisfying solution is found. The advantage of this method is that it can find all possible solutions, and with reasonable pruning operations, it can be highly efficient.
However, when dealing with large-scale or complex problems, the operational efficiency of backtracking may be difficult to accept.
- Time: Backtracking algorithms usually need to traverse all possible states in the state space, which can reach exponential or factorial time complexity.
- Space: In recursive calls, it is necessary to save the current state (such as paths, auxiliary variables for pruning, etc.). When the depth is very large, the space requirement may become significant.
Even so, backtracking remains the best solution for certain search problems and constraint satisfaction problems. For these problems, since it is unpredictable which choices can generate valid solutions, we must traverse all possible choices. In this case, the key is how to optimize efficiency, with common efficiency optimization methods being two types.
- Pruning: Avoid searching paths that definitely will not produce a solution, thus saving time and space.
- Heuristic search: Introduce some strategies or estimates during the search process to prioritize the paths that are most likely to produce valid solutions.
13.1.6 Typical backtracking problems¶
Backtracking algorithms can be used to solve many search problems, constraint satisfaction problems, and combinatorial optimization problems.
Search problems: The goal of these problems is to find solutions that meet specific conditions.
- Full permutation problem: Given a set, find all possible permutations and combinations of it.
- Subset sum problem: Given a set and a target sum, find all subsets of the set that sum to the target.
- Tower of Hanoi problem: Given three rods and a series of different-sized discs, the goal is to move all the discs from one rod to another, moving only one disc at a time, and never placing a larger disc on a smaller one.
Constraint satisfaction problems: The goal of these problems is to find solutions that satisfy all the constraints.
- \(n\) queens: Place \(n\) queens on an \(n \times n\) chessboard so that they do not attack each other.
- Sudoku: Fill a \(9 \times 9\) grid with the numbers \(1\) to \(9\), ensuring that the numbers do not repeat in each row, each column, and each \(3 \times 3\) subgrid.
- Graph coloring problem: Given an undirected graph, color each vertex with the fewest possible colors so that adjacent vertices have different colors.
Combinatorial optimization problems: The goal of these problems is to find the optimal solution within a combination space that meets certain conditions.
- 0-1 knapsack problem: Given a set of items and a backpack, each item has a certain value and weight. The goal is to choose items to maximize the total value within the backpack's capacity limit.
- Traveling salesman problem: In a graph, starting from one point, visit all other points exactly once and then return to the starting point, seeking the shortest path.
- Maximum clique problem: Given an undirected graph, find the largest complete subgraph, i.e., a subgraph where any two vertices are connected by an edge.
Please note that for many combinatorial optimization problems, backtracking is not the optimal solution.
- The 0-1 knapsack problem is usually solved using dynamic programming to achieve higher time efficiency.
- The traveling salesman is a well-known NP-Hard problem, commonly solved using genetic algorithms and ant colony algorithms, among others.
- The maximum clique problem is a classic problem in graph theory, which can be solved using greedy algorithms and other heuristic methods.