CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-24 10:33:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2024-05-06 14:40:36 +08:00
parent 7e7eb6047a
commit 5c7d2c7f17
54 changed files with 3456 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
en/docs/chapter_backtracking/backtracking_algorithm.md
View File

@@ -12,7 +12,7 @@ Backtracking typically employs "depth-first search" to traverse the solution spa
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:
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 Figure 13-1:
=== "Python"
@@ -31,7 +31,18 @@ For this problem, we traverse this tree in preorder and check if the current nod
=== "C++"
```cpp title="preorder_traversal_i_compact.cpp"
[class]{}-[func]{preOrder}
/* Pre-order traversal: Example one */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
}
if (root->val == 7) {
// Record solution
res.push_back(root);
}
preOrder(root->left);
preOrder(root->right);
}
```
=== "Java"
@@ -156,7 +167,22 @@ Based on the code from Example One, we need to use a list `path` to record the v
=== "C++"
```cpp title="preorder_traversal_ii_compact.cpp"
[class]{}-[func]{preOrder}
/* Pre-order traversal: Example two */
void preOrder(TreeNode *root) {
if (root == nullptr) {
return;
}
// Attempt
path.push_back(root);
if (root->val == 7) {
// Record solution
res.push_back(path);
}
preOrder(root->left);
preOrder(root->right);
// Retract
path.pop_back();
}
```
=== "Java"
@@ -317,7 +343,23 @@ To meet the above constraints, **we need to add a pruning operation**: during th
=== "C++"
```cpp title="preorder_traversal_iii_compact.cpp"
[class]{}-[func]{preOrder}
/* Pre-order traversal: Example three */
void preOrder(TreeNode *root) {
// Pruning
if (root == nullptr || root->val == 3) {
return;
}
// Attempt
path.push_back(root);
if (root->val == 7) {
// Record solution
res.push_back(path);
}
preOrder(root->left);
preOrder(root->right);
// Retract
path.pop_back();
}
```
=== "Java"
@@ -408,7 +450,7 @@ To meet the above constraints, **we need to add a pruning operation**: during th
[class]{}-[func]{preOrder}
```
"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.
"Pruning" is a very vivid noun. As shown in Figure 13-3, 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.
![Pruning based on constraints](backtracking_algorithm.assets/preorder_find_constrained_paths.png){ class="animation-figure" }
@@ -788,17 +830,52 @@ Next, we solve Example Three based on the framework code. The `state` is the nod
=== "C++"
```cpp title="preorder_traversal_iii_template.cpp"
[class]{}-[func]{isSolution}
/* Determine if the current state is a solution */
bool isSolution(vector<TreeNode *> &state) {
return !state.empty() && state.back()->val == 7;
}
[class]{}-[func]{recordSolution}
/* Record solution */
void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {
res.push_back(state);
}
[class]{}-[func]{isValid}
/* Determine if the choice is legal under the current state */
bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
return choice != nullptr && choice->val != 3;
}
[class]{}-[func]{makeChoice}
/* Update state */
void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.push_back(choice);
}
[class]{}-[func]{undoChoice}
/* Restore state */
void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
state.pop_back();
}
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Example three */
void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
// Check if it's a solution
if (isSolution(state)) {
// Record solution
recordSolution(state, res);
}
// Traverse all choices
for (TreeNode *choice : choices) {
// Pruning: check if the choice is legal
if (isValid(state, choice)) {
// Attempt: make a choice, update the state
makeChoice(state, choice);
// Proceed to the next round of selection
vector<TreeNode *> nextChoices{choice->left, choice->right};
backtrack(state, nextChoices, res);
// Retract: undo the choice, restore to the previous state
undoChoice(state, choice);
}
}
}
```
=== "Java"
@@ -1027,7 +1104,7 @@ Next, we solve Example Three based on the framework code. The `state` is the nod
[class]{}-[func]{backtrack}
```
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.
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**. Figure 13-4 compares the search processes with and without retaining the `return` statement.
![Comparison of retaining and removing the return in the search process](backtracking_algorithm.assets/backtrack_remove_return_or_not.png){ class="animation-figure" }

41
en/docs/chapter_backtracking/n_queens_problem.md
View File

@@ -101,9 +101,46 @@ Please note, in an $n$-dimensional matrix, the range of $row - col$ is $[-n + 1,
=== "C++"
```cpp title="n_queens.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: n queens */
void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
vector<bool> &diags1, vector<bool> &diags2) {
// When all rows are placed, record the solution
if (row == n) {
res.push_back(state);
return;
}
// Traverse all columns
for (int col = 0; col < n; col++) {
// Calculate the main and minor diagonals corresponding to the cell
int diag1 = row - col + n - 1;
int diag2 = row + col;
// Pruning: do not allow queens on the column, main diagonal, or minor diagonal of the cell
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
// Attempt: place the queen in the cell
state[row][col] = "Q";
cols[col] = diags1[diag1] = diags2[diag2] = true;
// Place the next row
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// Retract: restore the cell to an empty spot
state[row][col] = "#";
cols[col] = diags1[diag1] = diags2[diag2] = false;
}
}
}
[class]{}-[func]{nQueens}
/* Solve n queens */
vector<vector<vector<string>>> nQueens(int n) {
// Initialize an n*n size chessboard, where 'Q' represents the queen and '#' represents an empty spot
vector<vector<string>> state(n, vector<string>(n, "#"));
vector<bool> cols(n, false); // Record columns with queens
vector<bool> diags1(2 * n - 1, false); // Record main diagonals with queens
vector<bool> diags2(2 * n - 1, false); // Record minor diagonals with queens
vector<vector<vector<string>>> res;
backtrack(0, n, state, res, cols, diags1, diags2);
return res;
}
```
=== "Java"

68
en/docs/chapter_backtracking/permutations_problem.md
View File

@@ -89,9 +89,38 @@ After understanding the above information, we can "fill in the blanks" in the fr
=== "C++"
```cpp title="permutations_i.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Permutation I */
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
// When the state length equals the number of elements, record the solution
if (state.size() == choices.size()) {
res.push_back(state);
return;
}
// Traverse all choices
for (int i = 0; i < choices.size(); i++) {
int choice = choices[i];
// Pruning: do not allow repeated selection of elements
if (!selected[i]) {
// Attempt: make a choice, update the state
selected[i] = true;
state.push_back(choice);
// Proceed to the next round of selection
backtrack(state, choices, selected, res);
// Retract: undo the choice, restore to the previous state
selected[i] = false;
state.pop_back();
}
}
}
[class]{}-[func]{permutationsI}
/* Permutation I */
vector<vector<int>> permutationsI(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
vector<vector<int>> res;
backtrack(state, nums, selected, res);
return res;
}
```
=== "Java"
@@ -285,9 +314,40 @@ Based on the code from the previous problem, we consider initiating a hash set `
=== "C++"
```cpp title="permutations_ii.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Permutation II */
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
// When the state length equals the number of elements, record the solution
if (state.size() == choices.size()) {
res.push_back(state);
return;
}
// Traverse all choices
unordered_set<int> duplicated;
for (int i = 0; i < choices.size(); i++) {
int choice = choices[i];
// Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements
if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
// Attempt: make a choice, update the state
duplicated.emplace(choice); // Record selected element values
selected[i] = true;
state.push_back(choice);
// Proceed to the next round of selection
backtrack(state, choices, selected, res);
// Retract: undo the choice, restore to the previous state
selected[i] = false;
state.pop_back();
}
}
}
[class]{}-[func]{permutationsII}
/* Permutation II */
vector<vector<int>> permutationsII(vector<int> nums) {
vector<int> state;
vector<bool> selected(nums.size(), false);
vector<vector<int>> res;
backtrack(state, nums, selected, res);
return res;
}
```
=== "Java"

104
en/docs/chapter_backtracking/subset_sum_problem.md
View File

@@ -60,9 +60,36 @@ Unlike the permutation problem, **elements in this problem can be chosen an unli
=== "C++"
```cpp title="subset_sum_i_naive.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Subset Sum I */
void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
// When the subset sum equals target, record the solution
if (total == target) {
res.push_back(state);
return;
}
// Traverse all choices
for (size_t i = 0; i < choices.size(); i++) {
// Pruning: if the subset sum exceeds target, skip that choice
if (total + choices[i] > target) {
continue;
}
// Attempt: make a choice, update elements and total
state.push_back(choices[i]);
// Proceed to the next round of selection
backtrack(state, target, total + choices[i], choices, res);
// Retract: undo the choice, restore to the previous state
state.pop_back();
}
}
[class]{}-[func]{subsetSumINaive}
/* Solve Subset Sum I (including duplicate subsets) */
vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
vector<int> state; // State (subset)
int total = 0; // Subset sum
vector<vector<int>> res; // Result list (subset list)
backtrack(state, target, total, nums, res);
return res;
}
```
=== "Java"
@@ -267,9 +294,39 @@ Besides, we have made the following two optimizations to the code.
=== "C++"
```cpp title="subset_sum_i.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Subset Sum I */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// When the subset sum equals target, record the solution
if (target == 0) {
res.push_back(state);
return;
}
// Traverse all choices
// Pruning two: start traversing from start to avoid generating duplicate subsets
for (int i = start; i < choices.size(); i++) {
// Pruning one: if the subset sum exceeds target, end the loop immediately
// This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target
if (target - choices[i] < 0) {
break;
}
// Attempt: make a choice, update target, start
state.push_back(choices[i]);
// Proceed to the next round of selection
backtrack(state, target - choices[i], choices, i, res);
// Retract: undo the choice, restore to the previous state
state.pop_back();
}
}
[class]{}-[func]{subsetSumI}
/* Solve Subset Sum I */
vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
vector<int> state; // State (subset)
sort(nums.begin(), nums.end()); // Sort nums
int start = 0; // Start point for traversal
vector<vector<int>> res; // Result list (subset list)
backtrack(state, target, nums, start, res);
return res;
}
```
=== "Java"
@@ -468,9 +525,44 @@ At the same time, **this question stipulates that each array element can only be
=== "C++"
```cpp title="subset_sum_ii.cpp"
[class]{}-[func]{backtrack}
/* Backtracking algorithm: Subset Sum II */
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
// When the subset sum equals target, record the solution
if (target == 0) {
res.push_back(state);
return;
}
// Traverse all choices
// Pruning two: start traversing from start to avoid generating duplicate subsets
// Pruning three: start traversing from start to avoid repeatedly selecting the same element
for (int i = start; i < choices.size(); i++) {
// Pruning one: if the subset sum exceeds target, end the loop immediately
// This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target
if (target - choices[i] < 0) {
break;
}
// Pruning four: if the element equals the left element, it indicates that the search branch is repeated, skip it
if (i > start && choices[i] == choices[i - 1]) {
continue;
}
// Attempt: make a choice, update target, start
state.push_back(choices[i]);
// Proceed to the next round of selection
backtrack(state, target - choices[i], choices, i + 1, res);
// Retract: undo the choice, restore to the previous state
state.pop_back();
}
}
[class]{}-[func]{subsetSumII}
/* Solve Subset Sum II */
vector<vector<int>> subsetSumII(vector<int> &nums, int target) {
vector<int> state; // State (subset)
sort(nums.begin(), nums.end()); // Sort nums
int start = 0; // Start point for traversal
vector<vector<int>> res; // Result list (subset list)
backtrack(state, target, nums, start, res);
return res;
}
```
=== "Java"