Add the initial translation of chapter "backtracking" (krahets#1323)

en/docs/chapter_backtracking/index.md

@@ -0,0 +1,9 @@
+# Backtracking
+
+![Backtracking](../assets/covers/chapter_backtracking.jpg)
+
+!!! 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.

en/docs/chapter_backtracking/n_queens_problem.md

@@ -0,0 +1,49 @@
+# 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 below, 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.
+
+![Solution to the 4 queens problem](n_queens_problem.assets/solution_4_queens.png)
+
+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 `/`.
+
+![Constraints of the n queens problem](n_queens_problem.assets/n_queens_constraints.png)
+
+### 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.
+
+![Row-by-row placing strategy](n_queens_problem.assets/n_queens_placing.png)
+
+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.
+
+### 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.
+
+![Handling column and diagonal constraints](n_queens_problem.assets/n_queens_cols_diagonals.png)
+
+### 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$.
+
+```src
+[file]{n_queens}-[class]{}-[func]{n_queens}
+```
+
+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)$**.

en/docs/chapter_backtracking/permutations_problem.md

@@ -0,0 +1,95 @@
+# 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 below lists several example data, including the input arrays and their corresponding permutations.
+
+<p align="center"> Table <id> &nbsp; Permutation examples </p>
+
+| 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]$ |
+
+## 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.
+
+![Permutation recursive tree](permutations_problem.assets/permutations_i.png)
+
+### 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.
+
+![Permutation pruning example](permutations_problem.assets/permutations_i_pruning.png)
+
+Observing the above figure, this pruning operation reduces the search space size from $O(n^n)$ to $O(n!)$.
+
+### 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:
+
+```src
+[file]{permutations_i}-[class]{}-[func]{permutations_i}
+```
+
+## 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.
+
+![Duplicate permutations](permutations_problem.assets/permutations_ii.png)
+
+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.
+
+### 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**.
+
+![Duplicate permutations pruning](permutations_problem.assets/permutations_ii_pruning.png)
+
+### 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:
+
+```src
+[file]{permutations_ii}-[class]{}-[func]{permutations_ii}
+```
+
+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)$**.
+
+### 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.
+
+![Scope of the two pruning conditions](permutations_problem.assets/permutations_ii_pruning_summary.png)

en/docs/chapter_backtracking/subset_sum_problem.md

@@ -0,0 +1,95 @@
+# Subset sum problem
+
+## 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.
+
+### 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:
+
+```src
+[file]{subset_sum_i_naive}-[class]{}-[func]{subset_sum_i_naive}
+```
+
+Inputting the array $[3, 4, 5]$ and target element $9$ into the above code yields the results $[3, 3, 3], [4, 5], [5, 4]$. **Although it successfully finds all subsets with a sum of $9$, it includes the duplicate subset $[4, 5]$ and $[5, 4]$**.
+
+This is because the search process distinguishes the order of choices, however, subsets do not distinguish the choice order. As shown in the following figure, choosing $4$ before $5$ and choosing $5$ before $4$ are different branches, but correspond to the same subset.
+
+![Subset search and pruning out of bounds](subset_sum_problem.assets/subset_sum_i_naive.png)
+
+To eliminate duplicate subsets, **a straightforward idea is to deduplicate the result list**. However, this method is very inefficient for two reasons.
+
+- When there are many array elements, especially when `target` is large, the search process produces a large number of duplicate subsets.
+- Comparing subsets (arrays) for differences is very time-consuming, requiring arrays to be sorted first, then comparing the differences of each element in the arrays.
+
+### Duplicate subset pruning
+
+**We consider deduplication during the search process through pruning**. Observing the following figure, duplicate subsets are generated when choosing array elements in different orders, for example in the following situations.
+
+1. When choosing $3$ in the first round and $4$ in the second round, all subsets containing these two elements are generated, denoted as $[3, 4, \dots]$.
+2. Later, when $4$ is chosen in the first round, **the second round should skip $3$** because the subset $[4, 3, \dots]$ generated by this choice completely duplicates the subset from step `1.`.
+
+In the search process, each layer's choices are tried one by one from left to right, so the more to the right a branch is, the more it is pruned.
+
+1. First two rounds choose $3$ and $5$, generating subset $[3, 5, \dots]$.
+2. First two rounds choose $4$ and $5$, generating subset $[4, 5, \dots]$.
+3. If $5$ is chosen in the first round, **then the second round should skip $3$ and $4$** as the subsets $[5, 3, \dots]$ and $[5, 4, \dots]$ completely duplicate the subsets described in steps `1.` and `2.`.
+
+![Different choice orders leading to duplicate subsets](subset_sum_problem.assets/subset_sum_i_pruning.png)
+
+In summary, given the input array $[x_1, x_2, \dots, x_n]$, the choice sequence in the search process should be $[x_{i_1}, x_{i_2}, \dots, x_{i_m}]$, which needs to satisfy $i_1 \leq i_2 \leq \dots \leq i_m$. **Any choice sequence that does not meet this condition will cause duplicates and should be pruned**.
+
+### Code implementation
+
+To implement this pruning, we initialize the variable `start`, which indicates the starting point for traversal. **After making the choice $x_{i}$, set the next round to start from index $i$**. This will ensure the choice sequence satisfies $i_1 \leq i_2 \leq \dots \leq i_m$, thereby ensuring the uniqueness of the subsets.
+
+Besides, we have made the following two optimizations to the code.
+
+- Before starting the search, sort the array `nums`. In the traversal of all choices, **end the loop directly when the subset sum exceeds `target`** as subsequent elements are larger and their subset sum will definitely exceed `target`.
+- Eliminate the element sum variable `total`, **by performing subtraction on `target` to count the element sum**. When `target` equals $0$, record the solution.
+
+```src
+[file]{subset_sum_i}-[class]{}-[func]{subset_sum_i}
+```
+
+The following figure shows the overall backtracking process after inputting the array $[3, 4, 5]$ and target element $9$ into the above code.
+
+![Subset sum I backtracking process](subset_sum_problem.assets/subset_sum_i.png)
+
+## Considering cases with 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 may contain duplicate elements, and each element can only be chosen once**. Please return these combinations as a list, which should not contain duplicate combinations.
+
+Compared to the previous question, **this question's input array may contain duplicate elements**, introducing new problems. For example, given the array $[4, \hat{4}, 5]$ and target element $9$, the existing code's output results in $[4, 5], [\hat{4}, 5]$, resulting in duplicate subsets.
+
+**The reason for this duplication is that equal elements are chosen multiple times in a certain round**. In the following figure, the first round has three choices, two of which are $4$, generating two duplicate search branches, thus outputting duplicate subsets; similarly, the two $4$s in the second round also produce duplicate subsets.
+
+![Duplicate subsets caused by equal elements](subset_sum_problem.assets/subset_sum_ii_repeat.png)
+
+### Equal element pruning
+
+To solve this issue, **we need to limit equal elements to being chosen only once per round**. The implementation is quite clever: since the array is sorted, equal elements are adjacent. This means that in a certain round of choices, if the current element is equal to its left-hand element, it means it has already been chosen, so skip the current element directly.
+
+At the same time, **this question stipulates that each array element can only be chosen once**. Fortunately, we can also use the variable `start` to meet this constraint: after making the choice $x_{i}$, set the next round to start from index $i + 1$ going forward. This not only eliminates duplicate subsets but also avoids repeated selection of elements.
+
+### Code implementation
+
+```src
+[file]{subset_sum_ii}-[class]{}-[func]{subset_sum_ii}
+```
+
+The following figure shows the backtracking process for the array $[4, 4, 5]$ and target element $9$, including four types of pruning operations. Please combine the illustration with the code comments to understand the entire search process and how each type of pruning operation works.
+
+![Subset sum II backtracking process](subset_sum_problem.assets/subset_sum_ii.png)