From 51fb5c1c10fdd8c1379fd160de2edeb4a141d3b0 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Wed, 18 Jun 2025 07:12:35 +0800 Subject: [PATCH] feat: add rust solution to lc problem: No.2967 No.2967.Minimum Cost to Make Array Equalindromic --- .../README.md | 58 +++++++++++++++++++ .../README_EN.md | 58 +++++++++++++++++++ .../Solution.rs | 51 ++++++++++++++++ 3 files changed, 167 insertions(+) create mode 100644 solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/Solution.rs diff --git a/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README.md b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README.md index a5988bd60cbe9..8d7877887dd39 100644 --- a/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README.md +++ b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README.md @@ -308,6 +308,64 @@ function minimumCost(nums: number[]): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn minimum_cost(nums: Vec) -> i64 { + use std::sync::Once; + use std::cmp::min; + + static INIT: Once = Once::new(); + static mut PS: Vec = Vec::new(); + + INIT.call_once(|| { + let mut ps_local = Vec::with_capacity(2 * 100_000); + for i in 1..=100_000 { + let s = i.to_string(); + + let mut t1 = s.clone(); + t1 = t1.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t1).parse::().unwrap()); + + let mut t2 = s[0..s.len() - 1].to_string(); + t2 = t2.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t2).parse::().unwrap()); + } + ps_local.sort(); + unsafe { + PS = ps_local; + } + }); + + let mut nums = nums; + nums.sort(); + + let mid = nums[nums.len() / 2] as i64; + + let i = unsafe { + match PS.binary_search(&mid) { + Ok(i) => i, + Err(i) => i, + } + }; + + let f = |x: i64| -> i64 { + nums.iter().map(|&v| (v as i64 - x).abs()).sum() + }; + + let mut ans = i64::MAX; + + for j in i.saturating_sub(1)..=(i + 1).min(2 * 100_000 - 1) { + let x = unsafe { PS[j] }; + ans = min(ans, f(x)); + } + + ans + } +} +``` + diff --git a/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README_EN.md b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README_EN.md index 91acd5c5a9d83..03b7b38be3526 100644 --- a/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README_EN.md +++ b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README_EN.md @@ -306,6 +306,64 @@ function minimumCost(nums: number[]): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn minimum_cost(nums: Vec) -> i64 { + use std::sync::Once; + use std::cmp::min; + + static INIT: Once = Once::new(); + static mut PS: Vec = Vec::new(); + + INIT.call_once(|| { + let mut ps_local = Vec::with_capacity(2 * 100_000); + for i in 1..=100_000 { + let s = i.to_string(); + + let mut t1 = s.clone(); + t1 = t1.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t1).parse::().unwrap()); + + let mut t2 = s[0..s.len() - 1].to_string(); + t2 = t2.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t2).parse::().unwrap()); + } + ps_local.sort(); + unsafe { + PS = ps_local; + } + }); + + let mut nums = nums; + nums.sort(); + + let mid = nums[nums.len() / 2] as i64; + + let i = unsafe { + match PS.binary_search(&mid) { + Ok(i) => i, + Err(i) => i, + } + }; + + let f = |x: i64| -> i64 { + nums.iter().map(|&v| (v as i64 - x).abs()).sum() + }; + + let mut ans = i64::MAX; + + for j in i.saturating_sub(1)..=(i + 1).min(2 * 100_000 - 1) { + let x = unsafe { PS[j] }; + ans = min(ans, f(x)); + } + + ans + } +} +``` + diff --git a/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/Solution.rs b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/Solution.rs new file mode 100644 index 0000000000000..f14b3ce57bd44 --- /dev/null +++ b/solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/Solution.rs @@ -0,0 +1,51 @@ +impl Solution { + pub fn minimum_cost(nums: Vec) -> i64 { + use std::cmp::min; + use std::sync::Once; + + static INIT: Once = Once::new(); + static mut PS: Vec = Vec::new(); + + INIT.call_once(|| { + let mut ps_local = Vec::with_capacity(2 * 100_000); + for i in 1..=100_000 { + let s = i.to_string(); + + let mut t1 = s.clone(); + t1 = t1.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t1).parse::().unwrap()); + + let mut t2 = s[0..s.len() - 1].to_string(); + t2 = t2.chars().rev().collect(); + ps_local.push(format!("{}{}", s, t2).parse::().unwrap()); + } + ps_local.sort(); + unsafe { + PS = ps_local; + } + }); + + let mut nums = nums; + nums.sort(); + + let mid = nums[nums.len() / 2] as i64; + + let i = unsafe { + match PS.binary_search(&mid) { + Ok(i) => i, + Err(i) => i, + } + }; + + let f = |x: i64| -> i64 { nums.iter().map(|&v| (v as i64 - x).abs()).sum() }; + + let mut ans = i64::MAX; + + for j in i.saturating_sub(1)..=(i + 1).min(2 * 100_000 - 1) { + let x = unsafe { PS[j] }; + ans = min(ans, f(x)); + } + + ans + } +}