?>
+ ) {
+ // 检查是否为解
+ 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)
+ }
+ }
+ }
+ ```
+
+=== "Ruby"
+
+ ```ruby title="preorder_traversal_iii_template.rb"
+ [class]{}-[func]{is_solution}
+
+ [class]{}-[func]{record_solution}
+
+ [class]{}-[func]{is_valid}
+
+ [class]{}-[func]{make_choice}
+
+ [class]{}-[func]{undo_choice}
+
+ [class]{}-[func]{backtrack}
+ ```
+
+=== "Zig"
+
+ ```zig title="preorder_traversal_iii_template.zig"
+ [class]{}-[func]{isSolution}
+
+ [class]{}-[func]{recordSolution}
+
+ [class]{}-[func]{isValid}
+
+ [class]{}-[func]{makeChoice}
+
+ [class]{}-[func]{undoChoice}
+
+ [class]{}-[func]{backtrack}
+ ```
+
+??? pythontutor "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.
+
+{ class="animation-figure" }
+
+ 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 the 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.
diff --git a/en/docs/chapter_backtracking/index.md b/en/docs/chapter_backtracking/index.md
new file mode 100644
index 000000000..7ebd7946e
--- /dev/null
+++ b/en/docs/chapter_backtracking/index.md
@@ -0,0 +1,22 @@
+---
+comments: true
+icon: material/map-marker-path
+---
+
+# Chapter 13. Backtracking
+
+{ class="cover-image" }
+
+!!! abstract
+
+ Like explorers in a maze, we may encounter difficulties on our path forward.
+
+ The power of backtracking allows us to start over, keep trying, and eventually find the exit to the light.
+
+## Chapter contents
+
+- [13.1 Backtracking algorithms](backtracking_algorithm.md)
+- [13.2 Permutation problem](permutations_problem.md)
+- [13.3 Subset sum problem](subset_sum_problem.md)
+- [13.4 n queens problem](n_queens_problem.md)
+- [13.5 Summary](summary.md)
diff --git a/en/docs/chapter_backtracking/n_queens_problem.md b/en/docs/chapter_backtracking/n_queens_problem.md
new file mode 100644
index 000000000..cf8dad3af
--- /dev/null
+++ b/en/docs/chapter_backtracking/n_queens_problem.md
@@ -0,0 +1,732 @@
+---
+comments: true
+---
+
+# 13.4 n queens problem
+
+!!! question
+
+ According to the rules of chess, a queen can attack pieces in the same row, column, or on a diagonal line. Given $n$ queens and an $n \times n$ chessboard, find arrangements where no two queens can attack each other.
+
+As shown in the Figure 13-15 , when $n = 4$, there are two solutions. From the perspective of the backtracking algorithm, an $n \times n$ chessboard has $n^2$ squares, presenting all possible choices `choices`. The state of the chessboard `state` changes continuously as each queen is placed.
+
+{ class="animation-figure" }
+
+ Figure 13-15 Solution to the 4 queens problem
+
+The following image shows the three constraints of this problem: **multiple queens cannot be on the same row, column, or diagonal**. It is important to note that diagonals are divided into the main diagonal `\` and the secondary diagonal `/`.
+
+{ class="animation-figure" }
+
+ Figure 13-16 Constraints of the n queens problem
+
+### 1. Row-by-row placing strategy
+
+As the number of queens equals the number of rows on the chessboard, both being $n$, it is easy to conclude: **each row on the chessboard allows and only allows one queen to be placed**.
+
+This means that we can adopt a row-by-row placing strategy: starting from the first row, place one queen per row until the last row is reached.
+
+The image below shows the row-by-row placing process for the 4 queens problem. Due to space limitations, the image only expands one search branch of the first row, and prunes any placements that do not meet the column and diagonal constraints.
+
+{ class="animation-figure" }
+
+ Figure 13-17 Row-by-row placing strategy
+
+Essentially, **the row-by-row placing strategy serves as a pruning function**, avoiding all search branches that would place multiple queens in the same row.
+
+### 2. Column and diagonal pruning
+
+To satisfy column constraints, we can use a boolean array `cols` of length $n$ to track whether a queen occupies each column. Before each placement decision, `cols` is used to prune the columns that already have queens, and it is dynamically updated during backtracking.
+
+How about the diagonal constraints? Let the row and column indices of a cell on the chessboard be $(row, col)$. By selecting a specific main diagonal, we notice that the difference $row - col$ is the same for all cells on that diagonal, **meaning that $row - col$ is a constant value on that diagonal**.
+
+Thus, if two cells satisfy $row_1 - col_1 = row_2 - col_2$, they are definitely on the same main diagonal. Using this pattern, we can utilize the array `diags1` shown below to track whether a queen is on any main diagonal.
+
+Similarly, **the sum $row + col$ is a constant value for all cells on a secondary diagonal**. We can also use the array `diags2` to handle secondary diagonal constraints.
+
+{ class="animation-figure" }
+
+ Figure 13-18 Handling column and diagonal constraints
+
+### 3. Code implementation
+
+Please note, in an $n$-dimensional matrix, the range of $row - col$ is $[-n + 1, n - 1]$, and the range of $row + col$ is $[0, 2n - 2]$, thus the number of both main and secondary diagonals is $2n - 1$, meaning the length of both arrays `diags1` and `diags2` is $2n - 1$.
+
+=== "Python"
+
+ ```python title="n_queens.py"
+ def backtrack(
+ row: int,
+ n: int,
+ state: list[list[str]],
+ res: list[list[list[str]]],
+ cols: list[bool],
+ diags1: list[bool],
+ diags2: list[bool],
+ ):
+ """回溯算法：n 皇后"""
+ # 当放置完所有行时，记录解
+ if row == n:
+ res.append([list(row) for row in state])
+ return
+ # 遍历所有列
+ for col in range(n):
+ # 计算该格子对应的主对角线和次对角线
+ diag1 = row - col + n - 1
+ diag2 = row + col
+ # 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if not cols[col] and not diags1[diag1] and not diags2[diag2]:
+ # 尝试：将皇后放置在该格子
+ state[row][col] = "Q"
+ cols[col] = diags1[diag1] = diags2[diag2] = True
+ # 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2)
+ # 回退：将该格子恢复为空位
+ state[row][col] = "#"
+ cols[col] = diags1[diag1] = diags2[diag2] = False
+
+ def n_queens(n: int) -> list[list[list[str]]]:
+ """求解 n 皇后"""
+ # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ state = [["#" for _ in range(n)] for _ in range(n)]
+ cols = [False] * n # 记录列是否有皇后
+ diags1 = [False] * (2 * n - 1) # 记录主对角线上是否有皇后
+ diags2 = [False] * (2 * n - 1) # 记录次对角线上是否有皇后
+ res = []
+ backtrack(0, n, state, res, cols, diags1, diags2)
+
+ return res
+ ```
+
+=== "C++"
+
+ ```cpp title="n_queens.cpp"
+ /* 回溯算法：n 皇后 */
+ void backtrack(int row, int n, vector> &state, vector>> &res, vector &cols,
+ vector &diags1, vector &diags2) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ res.push_back(state);
+ return;
+ }
+ // 遍历所有列
+ for (int col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ int diag1 = row - col + n - 1;
+ int diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = "Q";
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = "#";
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ vector>> nQueens(int n) {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ vector> state(n, vector(n, "#"));
+ vector cols(n, false); // 记录列是否有皇后
+ vector diags1(2 * n - 1, false); // 记录主对角线上是否有皇后
+ vector diags2(2 * n - 1, false); // 记录次对角线上是否有皇后
+ vector>> res;
+
+ backtrack(0, n, state, res, cols, diags1, diags2);
+
+ return res;
+ }
+ ```
+
+=== "Java"
+
+ ```java title="n_queens.java"
+ /* 回溯算法：n 皇后 */
+ void backtrack(int row, int n, List> state, List>> res,
+ boolean[] cols, boolean[] diags1, boolean[] diags2) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ List> copyState = new ArrayList<>();
+ for (List sRow : state) {
+ copyState.add(new ArrayList<>(sRow));
+ }
+ res.add(copyState);
+ return;
+ }
+ // 遍历所有列
+ for (int col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ int diag1 = row - col + n - 1;
+ int diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state.get(row).set(col, "Q");
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state.get(row).set(col, "#");
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ List>> nQueens(int n) {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ List> state = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ List row = new ArrayList<>();
+ for (int j = 0; j < n; j++) {
+ row.add("#");
+ }
+ state.add(row);
+ }
+ boolean[] cols = new boolean[n]; // 记录列是否有皇后
+ boolean[] diags1 = new boolean[2 * n - 1]; // 记录主对角线上是否有皇后
+ boolean[] diags2 = new boolean[2 * n - 1]; // 记录次对角线上是否有皇后
+ List>> res = new ArrayList<>();
+
+ backtrack(0, n, state, res, cols, diags1, diags2);
+
+ return res;
+ }
+ ```
+
+=== "C#"
+
+ ```csharp title="n_queens.cs"
+ /* 回溯算法：n 皇后 */
+ void Backtrack(int row, int n, List> state, List>> res,
+ bool[] cols, bool[] diags1, bool[] diags2) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ List> copyState = [];
+ foreach (List sRow in state) {
+ copyState.Add(new List(sRow));
+ }
+ res.Add(copyState);
+ return;
+ }
+ // 遍历所有列
+ for (int col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ int diag1 = row - col + n - 1;
+ int diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = "Q";
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ Backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = "#";
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ List>> NQueens(int n) {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ List> state = [];
+ for (int i = 0; i < n; i++) {
+ List row = [];
+ for (int j = 0; j < n; j++) {
+ row.Add("#");
+ }
+ state.Add(row);
+ }
+ bool[] cols = new bool[n]; // 记录列是否有皇后
+ bool[] diags1 = new bool[2 * n - 1]; // 记录主对角线上是否有皇后
+ bool[] diags2 = new bool[2 * n - 1]; // 记录次对角线上是否有皇后
+ List>> res = [];
+
+ Backtrack(0, n, state, res, cols, diags1, diags2);
+
+ return res;
+ }
+ ```
+
+=== "Go"
+
+ ```go title="n_queens.go"
+ /* 回溯算法：n 皇后 */
+ func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+ // 当放置完所有行时，记录解
+ if row == n {
+ newState := make([][]string, len(*state))
+ for i, _ := range newState {
+ newState[i] = make([]string, len((*state)[0]))
+ copy(newState[i], (*state)[i])
+
+ }
+ *res = append(*res, newState)
+ }
+ // 遍历所有列
+ for col := 0; col < n; col++ {
+ // 计算该格子对应的主对角线和次对角线
+ diag1 := row - col + n - 1
+ diag2 := row + col
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+ // 尝试：将皇后放置在该格子
+ (*state)[row][col] = "Q"
+ (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+ // 放置下一行
+ backtrack(row+1, n, state, res, cols, diags1, diags2)
+ // 回退：将该格子恢复为空位
+ (*state)[row][col] = "#"
+ (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ func nQueens(n int) [][][]string {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ state := make([][]string, n)
+ for i := 0; i < n; i++ {
+ row := make([]string, n)
+ for i := 0; i < n; i++ {
+ row[i] = "#"
+ }
+ state[i] = row
+ }
+ // 记录列是否有皇后
+ cols := make([]bool, n)
+ diags1 := make([]bool, 2*n-1)
+ diags2 := make([]bool, 2*n-1)
+ res := make([][][]string, 0)
+ backtrack(0, n, &state, &res, &cols, &diags1, &diags2)
+ return res
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="n_queens.swift"
+ /* 回溯算法：n 皇后 */
+ func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
+ // 当放置完所有行时，记录解
+ if row == n {
+ res.append(state)
+ return
+ }
+ // 遍历所有列
+ for col in 0 ..< n {
+ // 计算该格子对应的主对角线和次对角线
+ let diag1 = row - col + n - 1
+ let diag2 = row + col
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = "Q"
+ cols[col] = true
+ diags1[diag1] = true
+ diags2[diag2] = true
+ // 放置下一行
+ backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+ // 回退：将该格子恢复为空位
+ state[row][col] = "#"
+ cols[col] = false
+ diags1[diag1] = false
+ diags2[diag2] = false
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ func nQueens(n: Int) -> [[[String]]] {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ var state = Array(repeating: Array(repeating: "#", count: n), count: n)
+ var cols = Array(repeating: false, count: n) // 记录列是否有皇后
+ var diags1 = Array(repeating: false, count: 2 * n - 1) // 记录主对角线上是否有皇后
+ var diags2 = Array(repeating: false, count: 2 * n - 1) // 记录次对角线上是否有皇后
+ var res: [[[String]]] = []
+
+ backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+
+ return res
+ }
+ ```
+
+=== "JS"
+
+ ```javascript title="n_queens.js"
+ /* 回溯算法：n 皇后 */
+ function backtrack(row, n, state, res, cols, diags1, diags2) {
+ // 当放置完所有行时，记录解
+ if (row === n) {
+ res.push(state.map((row) => row.slice()));
+ return;
+ }
+ // 遍历所有列
+ for (let col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ const diag1 = row - col + n - 1;
+ const diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = 'Q';
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = '#';
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ function nQueens(n) {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ const state = Array.from({ length: n }, () => Array(n).fill('#'));
+ const cols = Array(n).fill(false); // 记录列是否有皇后
+ const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线上是否有皇后
+ const diags2 = Array(2 * n - 1).fill(false); // 记录次对角线上是否有皇后
+ const res = [];
+
+ backtrack(0, n, state, res, cols, diags1, diags2);
+ return res;
+ }
+ ```
+
+=== "TS"
+
+ ```typescript title="n_queens.ts"
+ /* 回溯算法：n 皇后 */
+ function backtrack(
+ row: number,
+ n: number,
+ state: string[][],
+ res: string[][][],
+ cols: boolean[],
+ diags1: boolean[],
+ diags2: boolean[]
+ ): void {
+ // 当放置完所有行时，记录解
+ if (row === n) {
+ res.push(state.map((row) => row.slice()));
+ return;
+ }
+ // 遍历所有列
+ for (let col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ const diag1 = row - col + n - 1;
+ const diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = 'Q';
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = '#';
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ function nQueens(n: number): string[][][] {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ const state = Array.from({ length: n }, () => Array(n).fill('#'));
+ const cols = Array(n).fill(false); // 记录列是否有皇后
+ const diags1 = Array(2 * n - 1).fill(false); // 记录主对角线上是否有皇后
+ const diags2 = Array(2 * n - 1).fill(false); // 记录次对角线上是否有皇后
+ const res: string[][][] = [];
+
+ backtrack(0, n, state, res, cols, diags1, diags2);
+ return res;
+ }
+ ```
+
+=== "Dart"
+
+ ```dart title="n_queens.dart"
+ /* 回溯算法：n 皇后 */
+ void backtrack(
+ int row,
+ int n,
+ List> state,
+ List>> res,
+ List cols,
+ List diags1,
+ List diags2,
+ ) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ List> copyState = [];
+ for (List sRow in state) {
+ copyState.add(List.from(sRow));
+ }
+ res.add(copyState);
+ return;
+ }
+ // 遍历所有列
+ for (int col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ int diag1 = row - col + n - 1;
+ int diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = "Q";
+ cols[col] = true;
+ diags1[diag1] = true;
+ diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = "#";
+ cols[col] = false;
+ diags1[diag1] = false;
+ diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ List>> nQueens(int n) {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ List> state = List.generate(n, (index) => List.filled(n, "#"));
+ List cols = List.filled(n, false); // 记录列是否有皇后
+ List diags1 = List.filled(2 * n - 1, false); // 记录主对角线上是否有皇后
+ List diags2 = List.filled(2 * n - 1, false); // 记录次对角线上是否有皇后
+ List>> res = [];
+
+ backtrack(0, n, state, res, cols, diags1, diags2);
+
+ return res;
+ }
+ ```
+
+=== "Rust"
+
+ ```rust title="n_queens.rs"
+ /* 回溯算法：n 皇后 */
+ fn backtrack(
+ row: usize,
+ n: usize,
+ state: &mut Vec>,
+ res: &mut Vec>>,
+ cols: &mut [bool],
+ diags1: &mut [bool],
+ diags2: &mut [bool],
+ ) {
+ // 当放置完所有行时，记录解
+ if row == n {
+ let mut copy_state: Vec> = Vec::new();
+ for s_row in state.clone() {
+ copy_state.push(s_row);
+ }
+ res.push(copy_state);
+ return;
+ }
+ // 遍历所有列
+ for col in 0..n {
+ // 计算该格子对应的主对角线和次对角线
+ let diag1 = row + n - 1 - col;
+ let diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+ // 尝试：将皇后放置在该格子
+ state.get_mut(row).unwrap()[col] = "Q".into();
+ (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);
+ // 放置下一行
+ backtrack(row + 1, n, state, res, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state.get_mut(row).unwrap()[col] = "#".into();
+ (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ fn n_queens(n: usize) -> Vec>> {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ let mut state: Vec> = Vec::new();
+ for _ in 0..n {
+ let mut row: Vec = Vec::new();
+ for _ in 0..n {
+ row.push("#".into());
+ }
+ state.push(row);
+ }
+ let mut cols = vec![false; n]; // 记录列是否有皇后
+ let mut diags1 = vec![false; 2 * n - 1]; // 记录主对角线上是否有皇后
+ let mut diags2 = vec![false; 2 * n - 1]; // 记录次对角线上是否有皇后
+ let mut res: Vec>> = Vec::new();
+
+ backtrack(
+ 0,
+ n,
+ &mut state,
+ &mut res,
+ &mut cols,
+ &mut diags1,
+ &mut diags2,
+ );
+
+ res
+ }
+ ```
+
+=== "C"
+
+ ```c title="n_queens.c"
+ /* 回溯算法：n 皇后 */
+ void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],
+ bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ res[*resSize] = (char **)malloc(sizeof(char *) * n);
+ for (int i = 0; i < n; ++i) {
+ res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));
+ strcpy(res[*resSize][i], state[i]);
+ }
+ (*resSize)++;
+ return;
+ }
+ // 遍历所有列
+ for (int col = 0; col < n; col++) {
+ // 计算该格子对应的主对角线和次对角线
+ int diag1 = row - col + n - 1;
+ int diag2 = row + col;
+ // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
+ if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+ // 尝试：将皇后放置在该格子
+ state[row][col] = 'Q';
+ cols[col] = diags1[diag1] = diags2[diag2] = true;
+ // 放置下一行
+ backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);
+ // 回退：将该格子恢复为空位
+ state[row][col] = '#';
+ cols[col] = diags1[diag1] = diags2[diag2] = false;
+ }
+ }
+ }
+
+ /* 求解 n 皇后 */
+ char ***nQueens(int n, int *returnSize) {
+ char state[MAX_SIZE][MAX_SIZE];
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ for (int i = 0; i < n; ++i) {
+ for (int j = 0; j < n; ++j) {
+ state[i][j] = '#';
+ }
+ state[i][n] = '\0';
+ }
+ bool cols[MAX_SIZE] = {false}; // 记录列是否有皇后
+ bool diags1[2 * MAX_SIZE - 1] = {false}; // 记录主对角线上是否有皇后
+ bool diags2[2 * MAX_SIZE - 1] = {false}; // 记录次对角线上是否有皇后
+
+ char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);
+ *returnSize = 0;
+ backtrack(0, n, state, res, returnSize, cols, diags1, diags2);
+ return res;
+ }
+ ```
+
+=== "Kotlin"
+
+ ```kotlin title="n_queens.kt"
+ /* 回溯算法：n 皇后 */
+ fun backtrack(
+ row: Int,
+ n: Int,
+ state: MutableList>,
+ res: MutableList>?>,
+ cols: BooleanArray,
+ diags1: BooleanArray,
+ diags2: BooleanArray
+ ) {
+ // 当放置完所有行时，记录解
+ if (row == n) {
+ val copyState = mutableListOf>()
+ for (sRow in state) {
+ copyState.add(sRow.toMutableList())
+ }
+ res.add(copyState)
+ return
+ }
+ // 遍历所有列
+ for (col in 0..>?> {
+ // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+ val state = mutableListOf>()
+ for (i in 0..()
+ for (j in 0..>?>()
+
+ backtrack(0, n, state, res, cols, diags1, diags2)
+
+ return res
+ }
+ ```
+
+=== "Ruby"
+
+ ```ruby title="n_queens.rb"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{n_queens}
+ ```
+
+=== "Zig"
+
+ ```zig title="n_queens.zig"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{nQueens}
+ ```
+
+??? pythontutor "Code Visualization"
+
+
+
+
+Placing $n$ queens row-by-row, considering column constraints, from the first row to the last row there are $n$, $n-1$, $\dots$, $2$, $1$ choices, using $O(n!)$ time. When recording a solution, it is necessary to copy the matrix `state` and add it to `res`, with the copying operation using $O(n^2)$ time. Therefore, **the overall time complexity is $O(n! \cdot n^2)$**. In practice, pruning based on diagonal constraints can significantly reduce the search space, thus often the search efficiency is better than the above time complexity.
+
+Array `state` uses $O(n^2)$ space, and arrays `cols`, `diags1`, and `diags2` each use $O(n)$ space. The maximum recursion depth is $n$, using $O(n)$ stack space. Therefore, **the space complexity is $O(n^2)$**.
diff --git a/en/docs/chapter_backtracking/permutations_problem.md b/en/docs/chapter_backtracking/permutations_problem.md
new file mode 100644
index 000000000..62322c7ab
--- /dev/null
+++ b/en/docs/chapter_backtracking/permutations_problem.md
@@ -0,0 +1,1068 @@
+---
+comments: true
+---
+
+# 13.2 Permutation problem
+
+The permutation problem is a typical application of the backtracking algorithm. It is defined as finding all possible arrangements of elements from a given set (such as an array or string).
+
+The Table 13-2 lists several example data, including the input arrays and their corresponding permutations.
+
+ Table 13-2 Permutation examples
+
+
+
+| Input array | Permutations |
+| :---------- | :----------------------------------------------------------------- |
+| $[1]$ | $[1]$ |
+| $[1, 2]$ | $[1, 2], [2, 1]$ |
+| $[1, 2, 3]$ | $[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]$ |
+
+
+
+## 13.2.1 Cases without equal elements
+
+!!! question
+
+ Enter an integer array without duplicate elements and return all possible permutations.
+
+From the perspective of the backtracking algorithm, **we can imagine the process of generating permutations as a series of choices**. Suppose the input array is $[1, 2, 3]$, if we first choose $1$, then $3$, and finally $2$, we obtain the permutation $[1, 3, 2]$. Backtracking means undoing a choice and then continuing to try other choices.
+
+From the code perspective, the candidate set `choices` contains all elements of the input array, and the state `state` contains elements that have been selected so far. Please note that each element can only be chosen once, **thus all elements in `state` must be unique**.
+
+As shown in the following figure, we can unfold the search process into a recursive tree, where each node represents the current state `state`. Starting from the root node, after three rounds of choices, we reach the leaf nodes, each corresponding to a permutation.
+
+{ class="animation-figure" }
+
+ Figure 13-5 Permutation recursive tree
+
+### 1. Pruning of repeated choices
+
+To ensure that each element is selected only once, we consider introducing a boolean array `selected`, where `selected[i]` indicates whether `choices[i]` has been selected. We base our pruning operations on this array:
+
+- After making the choice `choice[i]`, we set `selected[i]` to $\text{True}$, indicating it has been chosen.
+- When iterating through the choice list `choices`, skip all nodes that have already been selected, i.e., prune.
+
+As shown in the following figure, suppose we choose 1 in the first round, 3 in the second round, and 2 in the third round, we need to prune the branch of element 1 in the second round and elements 1 and 3 in the third round.
+
+{ class="animation-figure" }
+
+ Figure 13-6 Permutation pruning example
+
+Observing the above figure, this pruning operation reduces the search space size from $O(n^n)$ to $O(n!)$.
+
+### 2. Code implementation
+
+After understanding the above information, we can "fill in the blanks" in the framework code. To shorten the overall code, we do not implement individual functions within the framework code separately, but expand them in the `backtrack()` function:
+
+=== "Python"
+
+ ```python title="permutations_i.py"
+ def backtrack(
+ state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+ ):
+ """回溯算法：全排列 I"""
+ # 当状态长度等于元素数量时，记录解
+ if len(state) == len(choices):
+ res.append(list(state))
+ return
+ # 遍历所有选择
+ for i, choice in enumerate(choices):
+ # 剪枝：不允许重复选择元素
+ if not selected[i]:
+ # 尝试：做出选择，更新状态
+ selected[i] = True
+ state.append(choice)
+ # 进行下一轮选择
+ backtrack(state, choices, selected, res)
+ # 回退：撤销选择，恢复到之前的状态
+ selected[i] = False
+ state.pop()
+
+ def permutations_i(nums: list[int]) -> list[list[int]]:
+ """全排列 I"""
+ res = []
+ backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+ return res
+ ```
+
+=== "C++"
+
+ ```cpp title="permutations_i.cpp"
+ /* 回溯算法：全排列 I */
+ void backtrack(vector &state, const vector &choices, vector &selected, vector> &res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size() == choices.size()) {
+ res.push_back(state);
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.size(); i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.push_back(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop_back();
+ }
+ }
+ }
+
+ /* 全排列 I */
+ vector> permutationsI(vector nums) {
+ vector state;
+ vector selected(nums.size(), false);
+ vector> res;
+ backtrack(state, nums, selected, res);
+ return res;
+ }
+ ```
+
+=== "Java"
+
+ ```java title="permutations_i.java"
+ /* 回溯算法：全排列 I */
+ void backtrack(List state, int[] choices, boolean[] selected, List> res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size() == choices.length) {
+ res.add(new ArrayList(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.add(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.remove(state.size() - 1);
+ }
+ }
+ }
+
+ /* 全排列 I */
+ List> permutationsI(int[] nums) {
+ List> res = new ArrayList>();
+ backtrack(new ArrayList(), nums, new boolean[nums.length], res);
+ return res;
+ }
+ ```
+
+=== "C#"
+
+ ```csharp title="permutations_i.cs"
+ /* 回溯算法：全排列 I */
+ void Backtrack(List state, int[] choices, bool[] selected, List> res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.Count == choices.Length) {
+ res.Add(new List(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.Length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.Add(choice);
+ // 进行下一轮选择
+ Backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.RemoveAt(state.Count - 1);
+ }
+ }
+ }
+
+ /* 全排列 I */
+ List> PermutationsI(int[] nums) {
+ List> res = [];
+ Backtrack([], nums, new bool[nums.Length], res);
+ return res;
+ }
+ ```
+
+=== "Go"
+
+ ```go title="permutations_i.go"
+ /* 回溯算法：全排列 I */
+ func backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+ // 当状态长度等于元素数量时，记录解
+ if len(*state) == len(*choices) {
+ newState := append([]int{}, *state...)
+ *res = append(*res, newState)
+ }
+ // 遍历所有选择
+ for i := 0; i < len(*choices); i++ {
+ choice := (*choices)[i]
+ // 剪枝：不允许重复选择元素
+ if !(*selected)[i] {
+ // 尝试：做出选择，更新状态
+ (*selected)[i] = true
+ *state = append(*state, choice)
+ // 进行下一轮选择
+ backtrackI(state, choices, selected, res)
+ // 回退：撤销选择，恢复到之前的状态
+ (*selected)[i] = false
+ *state = (*state)[:len(*state)-1]
+ }
+ }
+ }
+
+ /* 全排列 I */
+ func permutationsI(nums []int) [][]int {
+ res := make([][]int, 0)
+ state := make([]int, 0)
+ selected := make([]bool, len(nums))
+ backtrackI(&state, &nums, &selected, &res)
+ return res
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="permutations_i.swift"
+ /* 回溯算法：全排列 I */
+ func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+ // 当状态长度等于元素数量时，记录解
+ if state.count == choices.count {
+ res.append(state)
+ return
+ }
+ // 遍历所有选择
+ for (i, choice) in choices.enumerated() {
+ // 剪枝：不允许重复选择元素
+ if !selected[i] {
+ // 尝试：做出选择，更新状态
+ selected[i] = true
+ state.append(choice)
+ // 进行下一轮选择
+ backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false
+ state.removeLast()
+ }
+ }
+ }
+
+ /* 全排列 I */
+ func permutationsI(nums: [Int]) -> [[Int]] {
+ var state: [Int] = []
+ var selected = Array(repeating: false, count: nums.count)
+ var res: [[Int]] = []
+ backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+ return res
+ }
+ ```
+
+=== "JS"
+
+ ```javascript title="permutations_i.js"
+ /* 回溯算法：全排列 I */
+ function backtrack(state, choices, selected, res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length === choices.length) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ choices.forEach((choice, i) => {
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop();
+ }
+ });
+ }
+
+ /* 全排列 I */
+ function permutationsI(nums) {
+ const res = [];
+ backtrack([], nums, Array(nums.length).fill(false), res);
+ return res;
+ }
+ ```
+
+=== "TS"
+
+ ```typescript title="permutations_i.ts"
+ /* 回溯算法：全排列 I */
+ function backtrack(
+ state: number[],
+ choices: number[],
+ selected: boolean[],
+ res: number[][]
+ ): void {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length === choices.length) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ choices.forEach((choice, i) => {
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop();
+ }
+ });
+ }
+
+ /* 全排列 I */
+ function permutationsI(nums: number[]): number[][] {
+ const res: number[][] = [];
+ backtrack([], nums, Array(nums.length).fill(false), res);
+ return res;
+ }
+ ```
+
+=== "Dart"
+
+ ```dart title="permutations_i.dart"
+ /* 回溯算法：全排列 I */
+ void backtrack(
+ List state,
+ List choices,
+ List selected,
+ List> res,
+ ) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length == choices.length) {
+ res.add(List.from(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.add(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.removeLast();
+ }
+ }
+ }
+
+ /* 全排列 I */
+ List> permutationsI(List nums) {
+ List> res = [];
+ backtrack([], nums, List.filled(nums.length, false), res);
+ return res;
+ }
+ ```
+
+=== "Rust"
+
+ ```rust title="permutations_i.rs"
+ /* 回溯算法：全排列 I */
+ fn backtrack(mut state: Vec, choices: &[i32], selected: &mut [bool], res: &mut Vec>) {
+ // 当状态长度等于元素数量时，记录解
+ if state.len() == choices.len() {
+ res.push(state);
+ return;
+ }
+ // 遍历所有选择
+ for i in 0..choices.len() {
+ let choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if !selected[i] {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state.clone(), choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.remove(state.len() - 1);
+ }
+ }
+ }
+
+ /* 全排列 I */
+ fn permutations_i(nums: &mut [i32]) -> Vec> {
+ let mut res = Vec::new(); // 状态（子集）
+ backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+ res
+ }
+ ```
+
+=== "C"
+
+ ```c title="permutations_i.c"
+ /* 回溯算法：全排列 I */
+ void backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {
+ // 当状态长度等于元素数量时，记录解
+ if (stateSize == choicesSize) {
+ res[*resSize] = (int *)malloc(choicesSize * sizeof(int));
+ for (int i = 0; i < choicesSize; i++) {
+ res[*resSize][i] = state[i];
+ }
+ (*resSize)++;
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choicesSize; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true;
+ state[stateSize] = choice;
+ // 进行下一轮选择
+ backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ }
+ }
+ }
+
+ /* 全排列 I */
+ int **permutationsI(int *nums, int numsSize, int *returnSize) {
+ int *state = (int *)malloc(numsSize * sizeof(int));
+ bool *selected = (bool *)malloc(numsSize * sizeof(bool));
+ for (int i = 0; i < numsSize; i++) {
+ selected[i] = false;
+ }
+ int **res = (int **)malloc(MAX_SIZE * sizeof(int *));
+ *returnSize = 0;
+
+ backtrack(state, 0, nums, numsSize, selected, res, returnSize);
+
+ free(state);
+ free(selected);
+
+ return res;
+ }
+ ```
+
+=== "Kotlin"
+
+ ```kotlin title="permutations_i.kt"
+ /* 回溯算法：全排列 I */
+ fun backtrack(
+ state: MutableList,
+ choices: IntArray,
+ selected: BooleanArray,
+ res: MutableList?>
+ ) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size == choices.size) {
+ res.add(state.toMutableList())
+ return
+ }
+ // 遍历所有选择
+ for (i in choices.indices) {
+ val choice = choices[i]
+ // 剪枝：不允许重复选择元素
+ if (!selected[i]) {
+ // 尝试：做出选择，更新状态
+ selected[i] = true
+ state.add(choice)
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res)
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false
+ state.removeAt(state.size - 1)
+ }
+ }
+ }
+
+ /* 全排列 I */
+ fun permutationsI(nums: IntArray): MutableList?> {
+ val res = mutableListOf?>()
+ backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)
+ return res
+ }
+ ```
+
+=== "Ruby"
+
+ ```ruby title="permutations_i.rb"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{permutations_i}
+ ```
+
+=== "Zig"
+
+ ```zig title="permutations_i.zig"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{permutationsI}
+ ```
+
+??? pythontutor "Code Visualization"
+
+
+
+
+## 13.2.2 Considering cases with equal elements
+
+!!! question
+
+ Enter an integer array, **which may contain duplicate elements**, and return all unique permutations.
+
+Suppose the input array is $[1, 1, 2]$. To differentiate the two duplicate elements $1$, we mark the second $1$ as $\hat{1}$.
+
+As shown in the following figure, half of the permutations generated by the above method are duplicates.
+
+{ class="animation-figure" }
+
+ Figure 13-7 Duplicate permutations
+
+So, how do we eliminate duplicate permutations? Most directly, consider using a hash set to deduplicate permutation results. However, this is not elegant, **as branches generating duplicate permutations are unnecessary and should be identified and pruned in advance**, which can further improve algorithm efficiency.
+
+### 1. Pruning of equal elements
+
+Observing the following figure, in the first round, choosing $1$ or $\hat{1}$ results in identical permutations under both choices, thus we should prune $\hat{1}$.
+
+Similarly, after choosing $2$ in the first round, choosing $1$ and $\hat{1}$ in the second round also produces duplicate branches, so we should also prune $\hat{1}$ in the second round.
+
+Essentially, **our goal is to ensure that multiple equal elements are only selected once in each round of choices**.
+
+{ class="animation-figure" }
+
+ Figure 13-8 Duplicate permutations pruning
+
+### 2. Code implementation
+
+Based on the code from the previous problem, we consider initiating a hash set `duplicated` in each round of choices, used to record elements that have been tried in that round, and prune duplicate elements:
+
+=== "Python"
+
+ ```python title="permutations_ii.py"
+ def backtrack(
+ state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
+ ):
+ """回溯算法：全排列 II"""
+ # 当状态长度等于元素数量时，记录解
+ if len(state) == len(choices):
+ res.append(list(state))
+ return
+ # 遍历所有选择
+ duplicated = set[int]()
+ for i, choice in enumerate(choices):
+ # 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if not selected[i] and choice not in duplicated:
+ # 尝试：做出选择，更新状态
+ duplicated.add(choice) # 记录选择过的元素值
+ selected[i] = True
+ state.append(choice)
+ # 进行下一轮选择
+ backtrack(state, choices, selected, res)
+ # 回退：撤销选择，恢复到之前的状态
+ selected[i] = False
+ state.pop()
+
+ def permutations_ii(nums: list[int]) -> list[list[int]]:
+ """全排列 II"""
+ res = []
+ backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
+ return res
+ ```
+
+=== "C++"
+
+ ```cpp title="permutations_ii.cpp"
+ /* 回溯算法：全排列 II */
+ void backtrack(vector &state, const vector &choices, vector &selected, vector> &res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size() == choices.size()) {
+ res.push_back(state);
+ return;
+ }
+ // 遍历所有选择
+ unordered_set duplicated;
+ for (int i = 0; i < choices.size(); i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
+ // 尝试：做出选择，更新状态
+ duplicated.emplace(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.push_back(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop_back();
+ }
+ }
+ }
+
+ /* 全排列 II */
+ vector> permutationsII(vector nums) {
+ vector state;
+ vector selected(nums.size(), false);
+ vector> res;
+ backtrack(state, nums, selected, res);
+ return res;
+ }
+ ```
+
+=== "Java"
+
+ ```java title="permutations_ii.java"
+ /* 回溯算法：全排列 II */
+ void backtrack(List state, int[] choices, boolean[] selected, List> res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size() == choices.length) {
+ res.add(new ArrayList(state));
+ return;
+ }
+ // 遍历所有选择
+ Set duplicated = new HashSet();
+ for (int i = 0; i < choices.length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.contains(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.add(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.add(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.remove(state.size() - 1);
+ }
+ }
+ }
+
+ /* 全排列 II */
+ List> permutationsII(int[] nums) {
+ List> res = new ArrayList>();
+ backtrack(new ArrayList(), nums, new boolean[nums.length], res);
+ return res;
+ }
+ ```
+
+=== "C#"
+
+ ```csharp title="permutations_ii.cs"
+ /* 回溯算法：全排列 II */
+ void Backtrack(List state, int[] choices, bool[] selected, List> res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.Count == choices.Length) {
+ res.Add(new List(state));
+ return;
+ }
+ // 遍历所有选择
+ HashSet duplicated = [];
+ for (int i = 0; i < choices.Length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.Contains(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.Add(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.Add(choice);
+ // 进行下一轮选择
+ Backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.RemoveAt(state.Count - 1);
+ }
+ }
+ }
+
+ /* 全排列 II */
+ List> PermutationsII(int[] nums) {
+ List> res = [];
+ Backtrack([], nums, new bool[nums.Length], res);
+ return res;
+ }
+ ```
+
+=== "Go"
+
+ ```go title="permutations_ii.go"
+ /* 回溯算法：全排列 II */
+ func backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+ // 当状态长度等于元素数量时，记录解
+ if len(*state) == len(*choices) {
+ newState := append([]int{}, *state...)
+ *res = append(*res, newState)
+ }
+ // 遍历所有选择
+ duplicated := make(map[int]struct{}, 0)
+ for i := 0; i < len(*choices); i++ {
+ choice := (*choices)[i]
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if _, ok := duplicated[choice]; !ok && !(*selected)[i] {
+ // 尝试：做出选择，更新状态
+ // 记录选择过的元素值
+ duplicated[choice] = struct{}{}
+ (*selected)[i] = true
+ *state = append(*state, choice)
+ // 进行下一轮选择
+ backtrackII(state, choices, selected, res)
+ // 回退：撤销选择，恢复到之前的状态
+ (*selected)[i] = false
+ *state = (*state)[:len(*state)-1]
+ }
+ }
+ }
+
+ /* 全排列 II */
+ func permutationsII(nums []int) [][]int {
+ res := make([][]int, 0)
+ state := make([]int, 0)
+ selected := make([]bool, len(nums))
+ backtrackII(&state, &nums, &selected, &res)
+ return res
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="permutations_ii.swift"
+ /* 回溯算法：全排列 II */
+ func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+ // 当状态长度等于元素数量时，记录解
+ if state.count == choices.count {
+ res.append(state)
+ return
+ }
+ // 遍历所有选择
+ var duplicated: Set = []
+ for (i, choice) in choices.enumerated() {
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if !selected[i], !duplicated.contains(choice) {
+ // 尝试：做出选择，更新状态
+ duplicated.insert(choice) // 记录选择过的元素值
+ selected[i] = true
+ state.append(choice)
+ // 进行下一轮选择
+ backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false
+ state.removeLast()
+ }
+ }
+ }
+
+ /* 全排列 II */
+ func permutationsII(nums: [Int]) -> [[Int]] {
+ var state: [Int] = []
+ var selected = Array(repeating: false, count: nums.count)
+ var res: [[Int]] = []
+ backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+ return res
+ }
+ ```
+
+=== "JS"
+
+ ```javascript title="permutations_ii.js"
+ /* 回溯算法：全排列 II */
+ function backtrack(state, choices, selected, res) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length === choices.length) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ const duplicated = new Set();
+ choices.forEach((choice, i) => {
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.has(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.add(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop();
+ }
+ });
+ }
+
+ /* 全排列 II */
+ function permutationsII(nums) {
+ const res = [];
+ backtrack([], nums, Array(nums.length).fill(false), res);
+ return res;
+ }
+ ```
+
+=== "TS"
+
+ ```typescript title="permutations_ii.ts"
+ /* 回溯算法：全排列 II */
+ function backtrack(
+ state: number[],
+ choices: number[],
+ selected: boolean[],
+ res: number[][]
+ ): void {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length === choices.length) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ const duplicated = new Set();
+ choices.forEach((choice, i) => {
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.has(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.add(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.pop();
+ }
+ });
+ }
+
+ /* 全排列 II */
+ function permutationsII(nums: number[]): number[][] {
+ const res: number[][] = [];
+ backtrack([], nums, Array(nums.length).fill(false), res);
+ return res;
+ }
+ ```
+
+=== "Dart"
+
+ ```dart title="permutations_ii.dart"
+ /* 回溯算法：全排列 II */
+ void backtrack(
+ List state,
+ List choices,
+ List selected,
+ List> res,
+ ) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.length == choices.length) {
+ res.add(List.from(state));
+ return;
+ }
+ // 遍历所有选择
+ Set duplicated = {};
+ for (int i = 0; i < choices.length; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.contains(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.add(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.add(choice);
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.removeLast();
+ }
+ }
+ }
+
+ /* 全排列 II */
+ List> permutationsII(List nums) {
+ List> res = [];
+ backtrack([], nums, List.filled(nums.length, false), res);
+ return res;
+ }
+ ```
+
+=== "Rust"
+
+ ```rust title="permutations_ii.rs"
+ /* 回溯算法：全排列 II */
+ fn backtrack(mut state: Vec, choices: &[i32], selected: &mut [bool], res: &mut Vec>) {
+ // 当状态长度等于元素数量时，记录解
+ if state.len() == choices.len() {
+ res.push(state);
+ return;
+ }
+ // 遍历所有选择
+ let mut duplicated = HashSet::::new();
+ for i in 0..choices.len() {
+ let choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if !selected[i] && !duplicated.contains(&choice) {
+ // 尝试：做出选择，更新状态
+ duplicated.insert(choice); // 记录选择过的元素值
+ selected[i] = true;
+ state.push(choice);
+ // 进行下一轮选择
+ backtrack(state.clone(), choices, selected, res);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ state.remove(state.len() - 1);
+ }
+ }
+ }
+
+ /* 全排列 II */
+ fn permutations_ii(nums: &mut [i32]) -> Vec> {
+ let mut res = Vec::new();
+ backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);
+ res
+ }
+ ```
+
+=== "C"
+
+ ```c title="permutations_ii.c"
+ /* 回溯算法：全排列 II */
+ void backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {
+ // 当状态长度等于元素数量时，记录解
+ if (stateSize == choicesSize) {
+ res[*resSize] = (int *)malloc(choicesSize * sizeof(int));
+ for (int i = 0; i < choicesSize; i++) {
+ res[*resSize][i] = state[i];
+ }
+ (*resSize)++;
+ return;
+ }
+ // 遍历所有选择
+ bool duplicated[MAX_SIZE] = {false};
+ for (int i = 0; i < choicesSize; i++) {
+ int choice = choices[i];
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated[choice]) {
+ // 尝试：做出选择，更新状态
+ duplicated[choice] = true; // 记录选择过的元素值
+ selected[i] = true;
+ state[stateSize] = choice;
+ // 进行下一轮选择
+ backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false;
+ }
+ }
+ }
+
+ /* 全排列 II */
+ int **permutationsII(int *nums, int numsSize, int *returnSize) {
+ int *state = (int *)malloc(numsSize * sizeof(int));
+ bool *selected = (bool *)malloc(numsSize * sizeof(bool));
+ for (int i = 0; i < numsSize; i++) {
+ selected[i] = false;
+ }
+ int **res = (int **)malloc(MAX_SIZE * sizeof(int *));
+ *returnSize = 0;
+
+ backtrack(state, 0, nums, numsSize, selected, res, returnSize);
+
+ free(state);
+ free(selected);
+
+ return res;
+ }
+ ```
+
+=== "Kotlin"
+
+ ```kotlin title="permutations_ii.kt"
+ /* 回溯算法：全排列 II */
+ fun backtrack(
+ state: MutableList,
+ choices: IntArray,
+ selected: BooleanArray,
+ res: MutableList?>
+ ) {
+ // 当状态长度等于元素数量时，记录解
+ if (state.size == choices.size) {
+ res.add(state.toMutableList())
+ return
+ }
+ // 遍历所有选择
+ val duplicated = HashSet()
+ for (i in choices.indices) {
+ val choice = choices[i]
+ // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+ if (!selected[i] && !duplicated.contains(choice)) {
+ // 尝试：做出选择，更新状态
+ duplicated.add(choice) // 记录选择过的元素值
+ selected[i] = true
+ state.add(choice)
+ // 进行下一轮选择
+ backtrack(state, choices, selected, res)
+ // 回退：撤销选择，恢复到之前的状态
+ selected[i] = false
+ state.removeAt(state.size - 1)
+ }
+ }
+ }
+
+ /* 全排列 II */
+ fun permutationsII(nums: IntArray): MutableList?> {
+ val res = mutableListOf?>()
+ backtrack(mutableListOf(), nums, BooleanArray(nums.size), res)
+ return res
+ }
+ ```
+
+=== "Ruby"
+
+ ```ruby title="permutations_ii.rb"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{permutations_ii}
+ ```
+
+=== "Zig"
+
+ ```zig title="permutations_ii.zig"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{permutationsII}
+ ```
+
+??? pythontutor "Code Visualization"
+
+
+
+
+Assuming all elements are distinct from each other, there are $n!$ (factorial) permutations of $n$ elements; when recording results, it is necessary to copy a list of length $n$, using $O(n)$ time. **Thus, the time complexity is $O(n!n)$**.
+
+The maximum recursion depth is $n$, using $O(n)$ frame space. `Selected` uses $O(n)$ space. At any one time, there can be up to $n$ `duplicated`, using $O(n^2)$ space. **Therefore, the space complexity is $O(n^2)$**.
+
+### 3. Comparison of the two pruning methods
+
+Please note, although both `selected` and `duplicated` are used for pruning, their targets are different.
+
+- **Repeated choice pruning**: There is only one `selected` throughout the search process. It records which elements are currently in the state, aiming to prevent an element from appearing repeatedly in `state`.
+- **Equal element pruning**: Each round of choices (each call to the `backtrack` function) contains a `duplicated`. It records which elements have been chosen in the current traversal (`for` loop), aiming to ensure equal elements are selected only once.
+
+The following figure shows the scope of the two pruning conditions. Note, each node in the tree represents a choice, and the nodes from the root to the leaf form a permutation.
+
+{ class="animation-figure" }
+
+ Figure 13-9 Scope of the two pruning conditions
diff --git a/en/docs/chapter_backtracking/subset_sum_problem.md b/en/docs/chapter_backtracking/subset_sum_problem.md
new file mode 100644
index 000000000..9b82f9bf1
--- /dev/null
+++ b/en/docs/chapter_backtracking/subset_sum_problem.md
@@ -0,0 +1,1623 @@
+---
+comments: true
+---
+
+# 13.3 Subset sum problem
+
+## 13.3.1 Case without duplicate elements
+
+!!! question
+
+ Given an array of positive integers `nums` and a target positive integer `target`, find all possible combinations such that the sum of the elements in the combination equals `target`. The given array has no duplicate elements, and each element can be chosen multiple times. Please return these combinations as a list, which should not contain duplicate combinations.
+
+For example, for the input set $\{3, 4, 5\}$ and target integer $9$, the solutions are $\{3, 3, 3\}, \{4, 5\}$. Note the following two points.
+
+- Elements in the input set can be chosen an unlimited number of times.
+- Subsets do not distinguish the order of elements, for example $\{4, 5\}$ and $\{5, 4\}$ are the same subset.
+
+### 1. Reference permutation solution
+
+Similar to the permutation problem, we can imagine the generation of subsets as a series of choices, updating the "element sum" in real-time during the choice process. When the element sum equals `target`, the subset is recorded in the result list.
+
+Unlike the permutation problem, **elements in this problem can be chosen an unlimited number of times**, thus there is no need to use a `selected` boolean list to record whether an element has been chosen. We can make minor modifications to the permutation code to initially solve the problem:
+
+=== "Python"
+
+ ```python title="subset_sum_i_naive.py"
+ def backtrack(
+ state: list[int],
+ target: int,
+ total: int,
+ choices: list[int],
+ res: list[list[int]],
+ ):
+ """回溯算法：子集和 I"""
+ # 子集和等于 target 时，记录解
+ if total == target:
+ res.append(list(state))
+ return
+ # 遍历所有选择
+ for i in range(len(choices)):
+ # 剪枝：若子集和超过 target ，则跳过该选择
+ if total + choices[i] > target:
+ continue
+ # 尝试：做出选择，更新元素和 total
+ state.append(choices[i])
+ # 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res)
+ # 回退：撤销选择，恢复到之前的状态
+ state.pop()
+
+ def subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:
+ """求解子集和 I（包含重复子集）"""
+ state = [] # 状态（子集）
+ total = 0 # 子集和
+ res = [] # 结果列表（子集列表）
+ backtrack(state, target, total, nums, res)
+ return res
+ ```
+
+=== "C++"
+
+ ```cpp title="subset_sum_i_naive.cpp"
+ /* 回溯算法：子集和 I */
+ void backtrack(vector &state, int target, int total, vector &choices, vector> &res) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ res.push_back(state);
+ return;
+ }
+ // 遍历所有选择
+ for (size_t i = 0; i < choices.size(); i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.push_back(choices[i]);
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.pop_back();
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ vector> subsetSumINaive(vector &nums, int target) {
+ vector state; // 状态（子集）
+ int total = 0; // 子集和
+ vector> res; // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "Java"
+
+ ```java title="subset_sum_i_naive.java"
+ /* 回溯算法：子集和 I */
+ void backtrack(List state, int target, int total, int[] choices, List> res) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ res.add(new ArrayList<>(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.length; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.add(choices[i]);
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.remove(state.size() - 1);
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ List> subsetSumINaive(int[] nums, int target) {
+ List state = new ArrayList<>(); // 状态（子集）
+ int total = 0; // 子集和
+ List> res = new ArrayList<>(); // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "C#"
+
+ ```csharp title="subset_sum_i_naive.cs"
+ /* 回溯算法：子集和 I */
+ void Backtrack(List state, int target, int total, int[] choices, List> res) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ res.Add(new List(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.Length; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.Add(choices[i]);
+ // 进行下一轮选择
+ Backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.RemoveAt(state.Count - 1);
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ List> SubsetSumINaive(int[] nums, int target) {
+ List state = []; // 状态（子集）
+ int total = 0; // 子集和
+ List> res = []; // 结果列表（子集列表）
+ Backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "Go"
+
+ ```go title="subset_sum_i_naive.go"
+ /* 回溯算法：子集和 I */
+ func backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {
+ // 子集和等于 target 时，记录解
+ if target == total {
+ newState := append([]int{}, *state...)
+ *res = append(*res, newState)
+ return
+ }
+ // 遍历所有选择
+ for i := 0; i < len(*choices); i++ {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if total+(*choices)[i] > target {
+ continue
+ }
+ // 尝试：做出选择，更新元素和 total
+ *state = append(*state, (*choices)[i])
+ // 进行下一轮选择
+ backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)
+ // 回退：撤销选择，恢复到之前的状态
+ *state = (*state)[:len(*state)-1]
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ func subsetSumINaive(nums []int, target int) [][]int {
+ state := make([]int, 0) // 状态（子集）
+ total := 0 // 子集和
+ res := make([][]int, 0) // 结果列表（子集列表）
+ backtrackSubsetSumINaive(total, target, &state, &nums, &res)
+ return res
+ }
+ ```
+
+=== "Swift"
+
+ ```swift title="subset_sum_i_naive.swift"
+ /* 回溯算法：子集和 I */
+ func backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {
+ // 子集和等于 target 时，记录解
+ if total == target {
+ res.append(state)
+ return
+ }
+ // 遍历所有选择
+ for i in choices.indices {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if total + choices[i] > target {
+ continue
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.append(choices[i])
+ // 进行下一轮选择
+ backtrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)
+ // 回退：撤销选择，恢复到之前的状态
+ state.removeLast()
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ func subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {
+ var state: [Int] = [] // 状态（子集）
+ let total = 0 // 子集和
+ var res: [[Int]] = [] // 结果列表（子集列表）
+ backtrack(state: &state, target: target, total: total, choices: nums, res: &res)
+ return res
+ }
+ ```
+
+=== "JS"
+
+ ```javascript title="subset_sum_i_naive.js"
+ /* 回溯算法：子集和 I */
+ function backtrack(state, target, total, choices, res) {
+ // 子集和等于 target 时，记录解
+ if (total === target) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ for (let i = 0; i < choices.length; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.push(choices[i]);
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.pop();
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ function subsetSumINaive(nums, target) {
+ const state = []; // 状态（子集）
+ const total = 0; // 子集和
+ const res = []; // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "TS"
+
+ ```typescript title="subset_sum_i_naive.ts"
+ /* 回溯算法：子集和 I */
+ function backtrack(
+ state: number[],
+ target: number,
+ total: number,
+ choices: number[],
+ res: number[][]
+ ): void {
+ // 子集和等于 target 时，记录解
+ if (total === target) {
+ res.push([...state]);
+ return;
+ }
+ // 遍历所有选择
+ for (let i = 0; i < choices.length; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.push(choices[i]);
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.pop();
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ function subsetSumINaive(nums: number[], target: number): number[][] {
+ const state = []; // 状态（子集）
+ const total = 0; // 子集和
+ const res = []; // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "Dart"
+
+ ```dart title="subset_sum_i_naive.dart"
+ /* 回溯算法：子集和 I */
+ void backtrack(
+ List state,
+ int target,
+ int total,
+ List choices,
+ List> res,
+ ) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ res.add(List.from(state));
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choices.length; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.add(choices[i]);
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.removeLast();
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ List> subsetSumINaive(List nums, int target) {
+ List state = []; // 状态（子集）
+ int total = 0; // 元素和
+ List> res = []; // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res);
+ return res;
+ }
+ ```
+
+=== "Rust"
+
+ ```rust title="subset_sum_i_naive.rs"
+ /* 回溯算法：子集和 I */
+ fn backtrack(
+ mut state: Vec,
+ target: i32,
+ total: i32,
+ choices: &[i32],
+ res: &mut Vec>,
+ ) {
+ // 子集和等于 target 时，记录解
+ if total == target {
+ res.push(state);
+ return;
+ }
+ // 遍历所有选择
+ for i in 0..choices.len() {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if total + choices[i] > target {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.push(choices[i]);
+ // 进行下一轮选择
+ backtrack(state.clone(), target, total + choices[i], choices, res);
+ // 回退：撤销选择，恢复到之前的状态
+ state.pop();
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ fn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec> {
+ let state = Vec::new(); // 状态（子集）
+ let total = 0; // 子集和
+ let mut res = Vec::new(); // 结果列表（子集列表）
+ backtrack(state, target, total, nums, &mut res);
+ res
+ }
+ ```
+
+=== "C"
+
+ ```c title="subset_sum_i_naive.c"
+ /* 回溯算法：子集和 I */
+ void backtrack(int target, int total, int *choices, int choicesSize) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ for (int i = 0; i < stateSize; i++) {
+ res[resSize][i] = state[i];
+ }
+ resColSizes[resSize++] = stateSize;
+ return;
+ }
+ // 遍历所有选择
+ for (int i = 0; i < choicesSize; i++) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue;
+ }
+ // 尝试：做出选择，更新元素和 total
+ state[stateSize++] = choices[i];
+ // 进行下一轮选择
+ backtrack(target, total + choices[i], choices, choicesSize);
+ // 回退：撤销选择，恢复到之前的状态
+ stateSize--;
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ void subsetSumINaive(int *nums, int numsSize, int target) {
+ resSize = 0; // 初始化解的数量为0
+ backtrack(target, 0, nums, numsSize);
+ }
+ ```
+
+=== "Kotlin"
+
+ ```kotlin title="subset_sum_i_naive.kt"
+ /* 回溯算法：子集和 I */
+ fun backtrack(
+ state: MutableList,
+ target: Int,
+ total: Int,
+ choices: IntArray,
+ res: MutableList?>
+ ) {
+ // 子集和等于 target 时，记录解
+ if (total == target) {
+ res.add(state.toMutableList())
+ return
+ }
+ // 遍历所有选择
+ for (i in choices.indices) {
+ // 剪枝：若子集和超过 target ，则跳过该选择
+ if (total + choices[i] > target) {
+ continue
+ }
+ // 尝试：做出选择，更新元素和 total
+ state.add(choices[i])
+ // 进行下一轮选择
+ backtrack(state, target, total + choices[i], choices, res)
+ // 回退：撤销选择，恢复到之前的状态
+ state.removeAt(state.size - 1)
+ }
+ }
+
+ /* 求解子集和 I（包含重复子集） */
+ fun subsetSumINaive(nums: IntArray, target: Int): MutableList?> {
+ val state = mutableListOf() // 状态（子集）
+ val total = 0 // 子集和
+ val res = mutableListOf?>() // 结果列表（子集列表）
+ backtrack(state, target, total, nums, res)
+ return res
+ }
+ ```
+
+=== "Ruby"
+
+ ```ruby title="subset_sum_i_naive.rb"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{subset_sum_i_naive}
+ ```
+
+=== "Zig"
+
+ ```zig title="subset_sum_i_naive.zig"
+ [class]{}-[func]{backtrack}
+
+ [class]{}-[func]{subsetSumINaive}
+ ```
+
+??? pythontutor "Code Visualization"
+
+