feat: add rust solution to lc problems: No.2303,2304

- No.2303.Calculate Amount Paid in Taxes
- No.2304.Minimum Path Cost in a Grid

Author: YangFong

solution/2300-2399/2303.Calculate Amount Paid in Taxes/README.md

@@ -170,6 +170,25 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn calculate_tax(brackets: Vec<Vec<i32>>, income: i32) -> f64 {
+        let mut res = 0f64;
+        let mut pre = 0i32;
+        for bracket in brackets.iter() {
+            res += f64::from(income.min(bracket[0]) - pre) * f64::from(bracket[1]) * 0.01;
+            if income <= bracket[0] {
+                break;
+            }
+            pre = bracket[0];
+        }
+        res
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2300-2399/2303.Calculate Amount Paid in Taxes/README_EN.md

@@ -161,6 +161,25 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn calculate_tax(brackets: Vec<Vec<i32>>, income: i32) -> f64 {
+        let mut res = 0f64;
+        let mut pre = 0i32;
+        for bracket in brackets.iter() {
+            res += f64::from(income.min(bracket[0]) - pre) * f64::from(bracket[1]) * 0.01;
+            if income <= bracket[0] {
+                break;
+            }
+            pre = bracket[0];
+        }
+        res
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2300-2399/2303.Calculate Amount Paid in Taxes/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn calculate_tax(brackets: Vec<Vec<i32>>, income: i32) -> f64 {
+        let mut res = 0f64;
+        let mut pre = 0i32;
+        for bracket in brackets.iter() {
+            res += f64::from(income.min(bracket[0]) - pre) * f64::from(bracket[1]) * 0.01;
+            if income <= bracket[0] {
+                break;
+            }
+            pre = bracket[0];
+        }
+        res
+    }
+}

solution/2300-2399/2304.Minimum Path Cost in a Grid/README.md

@@ -190,6 +190,34 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn min_path_cost(grid: Vec<Vec<i32>>, move_cost: Vec<Vec<i32>>) -> i32 {
+        let (m, n) = (grid.len(), grid[0].len());
+        let mut dp = vec![0; n];
+        for i in 0..m - 1 {
+            let mut counter = vec![i32::MAX; n];
+            for j in 0..n {
+                let val = grid[i][j];
+                for k in 0..n {
+                    counter[k] = counter[k].min(val + move_cost[val as usize][k] + dp[j]);
+                }
+            }
+            for j in 0..n {
+                dp[j] = counter[j];
+            }
+        }
+        let mut res = i32::MAX;
+        for i in 0..n {
+            res = res.min(dp[i] + grid[m - 1][i]);
+        }
+        res
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2300-2399/2304.Minimum Path Cost in a Grid/README_EN.md

@@ -176,6 +176,34 @@ func min(a, b int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn min_path_cost(grid: Vec<Vec<i32>>, move_cost: Vec<Vec<i32>>) -> i32 {
+        let (m, n) = (grid.len(), grid[0].len());
+        let mut dp = vec![0; n];
+        for i in 0..m - 1 {
+            let mut counter = vec![i32::MAX; n];
+            for j in 0..n {
+                let val = grid[i][j];
+                for k in 0..n {
+                    counter[k] = counter[k].min(val + move_cost[val as usize][k] + dp[j]);
+                }
+            }
+            for j in 0..n {
+                dp[j] = counter[j];
+            }
+        }
+        let mut res = i32::MAX;
+        for i in 0..n {
+            res = res.min(dp[i] + grid[m - 1][i]);
+        }
+        res
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2300-2399/2304.Minimum Path Cost in a Grid/Solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn min_path_cost(grid: Vec<Vec<i32>>, move_cost: Vec<Vec<i32>>) -> i32 {
+        let (m, n) = (grid.len(), grid[0].len());
+        let mut dp = vec![0; n];
+        for i in 0..m - 1 {
+            let mut counter = vec![i32::MAX; n];
+            for j in 0..n {
+                let val = grid[i][j];
+                for k in 0..n {
+                    counter[k] = counter[k].min(val + move_cost[val as usize][k] + dp[j]);
+                }
+            }
+            for j in 0..n {
+                dp[j] = counter[j];
+            }
+        }
+        let mut res = i32::MAX;
+        for i in 0..n {
+            res = res.min(dp[i] + grid[m - 1][i]);
+        }
+        res
+    }
+}