From 53efd8d8c3cf8b500b72b7c2a4656f6836298fc1 Mon Sep 17 00:00:00 2001
From: Michael Xu <xzhseh@gmail.com>
Date: Tue, 18 Jul 2023 23:45:43 +0800
Subject: [PATCH] feat: add rust solution to lc problem: No.2448

---
 .../README.md                                 | 52 +++++++++++++++++++
 .../README_EN.md                              | 52 +++++++++++++++++++
 .../Solution.rs                               | 47 +++++++++++++++++
 3 files changed, 151 insertions(+)
 create mode 100644 solution/2400-2499/2448.Minimum Cost to Make Array Equal/Solution.rs

diff --git a/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README.md b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README.md
index 907e937a722d5..f63648e6a5967 100644
--- a/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README.md	
+++ b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README.md	
@@ -248,6 +248,58 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn min_cost(nums: Vec<i32>, cost: Vec<i32>) -> i64 {
+        let mut zip_vec: Vec<_> = nums.into_iter().zip(cost.into_iter()).collect();
+
+        // Sort the zip vector based on nums
+        zip_vec.sort_by(|lhs, rhs| {
+            lhs.0.cmp(&rhs.0)
+        });
+
+        let (nums, cost): (Vec<i32>, Vec<i32>) = zip_vec.into_iter().unzip();
+
+        let mut sum: i64 = 0;
+        for &c in &cost {
+            sum += c as i64 ;
+        }
+        let middle_cost = (sum + 1) / 2;
+        let mut cur_sum: i64 = 0;
+        let mut i = 0;
+        let n = nums.len();
+
+        while i < n {
+            if cost[i] as i64 + cur_sum >= middle_cost {
+                break;
+            }
+            cur_sum += cost[i] as i64;
+            i += 1;
+        }
+        
+        Self::compute_manhattan_dis(&nums, &cost, nums[i])
+    }
+
+    #[allow(dead_code)]
+    fn compute_manhattan_dis(v: &Vec<i32>, c: &Vec<i32>, e: i32) -> i64 {
+        let mut ret = 0;
+        let n = v.len();
+
+        for i in 0..n {
+            if v[i] == e {
+                continue;
+            }
+            ret += (v[i] - e).abs() as i64 * c[i] as i64;
+        }
+
+        ret
+    }
+}
+```
+
 ### **Go**
 
 ```go
diff --git a/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README_EN.md b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README_EN.md
index 9da0d7b510010..187e5b3fde7c2 100644
--- a/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README_EN.md	
+++ b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/README_EN.md	
@@ -206,6 +206,58 @@ public:
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    #[allow(dead_code)]
+    pub fn min_cost(nums: Vec<i32>, cost: Vec<i32>) -> i64 {
+        let mut zip_vec: Vec<_> = nums.into_iter().zip(cost.into_iter()).collect();
+
+        // Sort the zip vector based on nums
+        zip_vec.sort_by(|lhs, rhs| {
+            lhs.0.cmp(&rhs.0)
+        });
+
+        let (nums, cost): (Vec<i32>, Vec<i32>) = zip_vec.into_iter().unzip();
+
+        let mut sum: i64 = 0;
+        for &c in &cost {
+            sum += c as i64 ;
+        }
+        let middle_cost = (sum + 1) / 2;
+        let mut cur_sum: i64 = 0;
+        let mut i = 0;
+        let n = nums.len();
+
+        while i < n {
+            if cost[i] as i64 + cur_sum >= middle_cost {
+                break;
+            }
+            cur_sum += cost[i] as i64;
+            i += 1;
+        }
+        
+        Self::compute_manhattan_dis(&nums, &cost, nums[i])
+    }
+
+    #[allow(dead_code)]
+    fn compute_manhattan_dis(v: &Vec<i32>, c: &Vec<i32>, e: i32) -> i64 {
+        let mut ret = 0;
+        let n = v.len();
+
+        for i in 0..n {
+            if v[i] == e {
+                continue;
+            }
+            ret += (v[i] - e).abs() as i64 * c[i] as i64;
+        }
+
+        ret
+    }
+}
+```
+
 ### **Go**
 
 ```go
diff --git a/solution/2400-2499/2448.Minimum Cost to Make Array Equal/Solution.rs b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/Solution.rs
new file mode 100644
index 0000000000000..cbc87fdce60f6
--- /dev/null
+++ b/solution/2400-2499/2448.Minimum Cost to Make Array Equal/Solution.rs	
@@ -0,0 +1,47 @@
+impl Solution {
+    #[allow(dead_code)]
+    pub fn min_cost(nums: Vec<i32>, cost: Vec<i32>) -> i64 {
+        let mut zip_vec: Vec<_> = nums.into_iter().zip(cost.into_iter()).collect();
+
+        // Sort the zip vector based on nums
+        zip_vec.sort_by(|lhs, rhs| {
+            lhs.0.cmp(&rhs.0)
+        });
+
+        let (nums, cost): (Vec<i32>, Vec<i32>) = zip_vec.into_iter().unzip();
+
+        let mut sum: i64 = 0;
+        for &c in &cost {
+            sum += c as i64 ;
+        }
+        let middle_cost = (sum + 1) / 2;
+        let mut cur_sum: i64 = 0;
+        let mut i = 0;
+        let n = nums.len();
+
+        while i < n {
+            if cost[i] as i64 + cur_sum >= middle_cost {
+                break;
+            }
+            cur_sum += cost[i] as i64;
+            i += 1;
+        }
+        
+        Self::compute_manhattan_dis(&nums, &cost, nums[i])
+    }
+
+    #[allow(dead_code)]
+    fn compute_manhattan_dis(v: &Vec<i32>, c: &Vec<i32>, e: i32) -> i64 {
+        let mut ret = 0;
+        let n = v.len();
+
+        for i in 0..n {
+            if v[i] == e {
+                continue;
+            }
+            ret += (v[i] - e).abs() as i64 * c[i] as i64;
+        }
+
+        ret
+    }
+}
\ No newline at end of file