zig : upgrade codes && rust : add codes for chapter_searching and chapter_dynamic_programming. (#591)

* zig : update zig codes

* rust : add codes for linear_search and hashing_search

* rust : add codes for linear_search and hashing_search

* rust : add codes for chapter_dynamic_programming

codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs

@@ -0,0 +1,37 @@
+/*
+ * File: climbing_stairs_backtrack.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 回溯 */
+fn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {
+    // 当爬到第 n 阶时，方案数量加 1
+    if state == n { res[0] = res[0] + 1; }
+    // 遍历所有选择
+    for &choice in choices {
+        // 剪枝：不允许越过第 n 阶
+        if state + choice > n { break; }
+        // 尝试：做出选择，更新状态
+        backtrack(choices, state + choice, n, res);
+        // 回退
+    }
+}
+
+/* 爬楼梯：回溯 */
+fn climbing_stairs_backtrack(n: usize) -> i32 {
+    let choices = vec![ 1, 2 ]; // 可选择向上爬 1 或 2 阶
+    let state = 0; // 从第 0 阶开始爬
+    let mut res = Vec::new();
+    res.push(0); // 使用 res[0] 记录方案数量
+    backtrack(&choices, state, n as i32, &mut res);
+    res[0]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_backtrack(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs

@@ -0,0 +1,31 @@
+/*
+ * File: climbing_stairs_constraint_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 带约束爬楼梯：动态规划 */
+fn climbing_stairs_constraint_dp(n: usize) -> i32 {
+    if n == 1 || n == 2 { return n as i32 };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![vec![-1; 3]; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1][1] = 1;
+    dp[1][2] = 0;
+    dp[2][1] = 0;
+    dp[2][2] = 1;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i][1] = dp[i - 1][2];
+        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+    }
+    dp[n][1] + dp[n][2]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_constraint_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs

@@ -0,0 +1,27 @@
+/*
+ * File: climbing_stairs_dfs.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 搜索 */
+fn dfs(i: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 { return i as i32 };
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1) + dfs(i - 2);
+    count
+}
+
+/* 爬楼梯：搜索 */
+fn climbing_stairs_dfs(n: usize) -> i32 {
+    dfs(n) 
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs

@@ -0,0 +1,33 @@
+/*
+ * File: climbing_stairs_dfs_mem.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 记忆化搜索 */
+fn dfs(i: usize, mem: &mut [i32]) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 { return i as i32};
+    // 若存在记录 dp[i] ，则直接返回之
+    if mem[i] != -1 { return mem[i] };
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1, mem) + dfs(i - 2, mem);
+    // 记录 dp[i]
+    mem[i] = count;
+    count
+}
+
+/* 爬楼梯：记忆化搜索 */
+fn climbing_stairs_dfs_mem(n: usize) -> i32 {
+    // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+    let mut mem = vec![-1; n + 1];
+    dfs(n, &mut mem)
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs_mem(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs

@@ -0,0 +1,44 @@
+/*
+ * File: climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 爬楼梯：动态规划 */
+fn climbing_stairs_dp(n: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if n == 1 || n == 2 { return n as i32 };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = 1;
+    dp[2] = 2;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    dp[n]
+}
+
+/* 爬楼梯：状态压缩后的动态规划 */
+fn climbing_stairs_dp_comp(n: usize) -> i32 {
+    if n == 1 || n == 2 { return n as i32 };
+    let (mut a, mut b) = (1, 2);
+    for _ in 3..=n {
+        let tmp = b;
+        b = a + b;
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+
+    let res = climbing_stairs_dp_comp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs

@@ -0,0 +1,48 @@
+/*
+ * File: min_cost_climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+ use std::cmp;
+
+/* 爬楼梯最小代价：动态规划 */
+fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 { return cost[n] };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = cost[1];
+    dp[2] = cost[2];
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    dp[n]
+}
+
+/* 爬楼梯最小代价：状态压缩后的动态规划 */
+fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 { return cost[n] };
+    let (mut a, mut b) = (cost[1], cost[2]);
+    for i in 3..=n {
+        let tmp = b;
+        b = cmp::min(a, tmp) + cost[i];
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let cost = [ 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 ];
+    println!("输入楼梯的代价列表为 {:?}", &cost);
+
+    let res = min_cost_climbing_stairs_dp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+
+    let res = min_cost_climbing_stairs_dp_comp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+}