Release Rust code to documents. (#656)

docs/chapter_backtracking/backtracking_algorithm.md

@@ -76,6 +76,12 @@
     [class]{}-[func]{preOrder}
     ```
 
+=== "Rust"
+
+    ```rust title="preorder_traversal_i_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
 ![在前序遍历中搜索节点](backtracking_algorithm.assets/preorder_find_nodes.png)
 
 ## 尝试与回退
@@ -158,6 +164,12 @@
     [class]{}-[func]{preOrder}
     ```
 
+=== "Rust"
+
+    ```rust title="preorder_traversal_ii_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
 在每次“尝试”中，我们通过将当前节点添加进 `path` 来记录路径；而在“回退”前，我们需要将该节点从 `path` 中弹出，**以恢复本次尝试之前的状态**。
 
 观察该过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。
@@ -271,6 +283,12 @@
     [class]{}-[func]{preOrder}
     ```
 
+=== "Rust"
+
+    ```rust title="preorder_traversal_iii_compact.rs"
+    [class]{}-[func]{pre_order}
+    ```
+
 剪枝是一个非常形象的名词。在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而实现搜索效率的提高。
 
 ![根据约束条件剪枝](backtracking_algorithm.assets/preorder_find_constrained_paths.png)
@@ -543,6 +561,12 @@
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 接下来，我们基于框架代码来解决例题三。状态 `state` 为节点遍历路径，选择 `choices` 为当前节点的左子节点和右子节点，结果 `res` 是路径列表。
 
 === "Java"
@@ -721,6 +745,22 @@
     [class]{}-[func]{backtrack}
     ```
 
+=== "Rust"
+
+    ```rust title="preorder_traversal_iii_template.rs"
+    [class]{}-[func]{is_solution}
+
+    [class]{}-[func]{record_solution}
+
+    [class]{}-[func]{is_valid}
+
+    [class]{}-[func]{make_choice}
+
+    [class]{}-[func]{undo_choice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
 根据题意，当找到值为 7 的节点后应该继续搜索，**因此我们需要将记录解之后的 `return` 语句删除**。下图对比了保留或删除 `return` 语句的搜索过程。
 
 ![保留与删除 return 的搜索过程对比](backtracking_algorithm.assets/backtrack_remove_return_or_not.png)

docs/chapter_backtracking/n_queens_problem.md

@@ -128,6 +128,14 @@
     [class]{}-[func]{nQueens}
     ```
 
+=== "Rust"
+
+    ```rust title="n_queens.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{n_queens}
+    ```
+
 逐行放置 $n$ 次，考虑列约束，则从第一行到最后一行分别有 $n, n-1, \cdots, 2, 1$ 个选择，**因此时间复杂度为 $O(n!)$** 。实际上，根据对角线约束的剪枝也能够大幅地缩小搜索空间，因而搜索效率往往优于以上时间复杂度。
 
 数组 `state` 使用 $O(n^2)$ 空间，数组 `cols` , `diags1` , `diags2` 皆使用 $O(n)$ 空间。最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。因此，**空间复杂度为 $O(n^2)$** 。

docs/chapter_backtracking/permutations_problem.md

@@ -133,6 +133,14 @@
     [class]{}-[func]{permutationsI}
     ```
 
+=== "Rust"
+
+    ```rust title="permutations_i.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_i}
+    ```
+
 ## 考虑相等元素的情况
 
 !!! question
@@ -249,6 +257,14 @@
     [class]{}-[func]{permutationsII}
     ```
 
+=== "Rust"
+
+    ```rust title="permutations_ii.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_ii}
+    ```
+
 假设元素两两之间互不相同，则 $n$ 个元素共有 $n!$  种排列（阶乘）；在记录结果时，需要复制长度为 $n$ 的列表，使用 $O(n)$ 时间。因此，**时间复杂度为 $O(n!n)$** 。
 
 最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。`selected` 使用 $O(n)$ 空间。同一时刻最多共有 $n$ 个 `duplicated` ，使用 $O(n^2)$ 空间。**因此空间复杂度为 $O(n^2)$** 。

docs/chapter_backtracking/subset_sum_problem.md

@@ -105,6 +105,14 @@
     [class]{}-[func]{subsetSumINaive}
     ```
 
+=== "Rust"
+
+    ```rust title="subset_sum_i_naive.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i_naive}
+    ```
+
 向以上代码输入数组 $[3, 4, 5]$ 和目标元素 $9$ ，输出结果为 $[3, 3, 3], [4, 5], [5, 4]$ 。**虽然成功找出了所有和为 $9$ 的子集，但其中存在重复的子集 $[4, 5]$ 和 $[5, 4]$** 。
 
 这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如下图所示，先选 $4$ 后选 $5$ 与先选 $5$ 后选 $4$ 是两个不同的分支，但两者对应同一个子集。
@@ -230,6 +238,14 @@
     [class]{}-[func]{subsetSumI}
     ```
 
+=== "Rust"
+
+    ```rust title="subset_sum_i.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i}
+    ```
+
 如下图所示，为将数组 $[3, 4, 5]$ 和目标元素 $9$ 输入到以上代码后的整体回溯过程。
 
 ![子集和 I 回溯过程](subset_sum_problem.assets/subset_sum_i.png)
@@ -342,6 +358,14 @@
     [class]{}-[func]{subsetSumII}
     ```
 
+=== "Rust"
+
+    ```rust title="subset_sum_ii.rs"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_ii}
+    ```
+
 下图展示了数组 $[4, 4, 5]$ 和目标元素 $9$ 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。
 
 ![子集和 II 回溯过程](subset_sum_problem.assets/subset_sum_ii.png)