Add problem 3376: Minimum Time to Break Locks I

Author: EFanZh

src/lib.rs

@@ -2208,6 +2208,7 @@ pub mod problem_3365_rearrange_k_substrings_to_form_target_string;
 pub mod problem_3370_smallest_number_with_all_set_bits;
 pub mod problem_3371_identify_the_largest_outlier_in_an_array;
 pub mod problem_3375_minimum_operations_to_make_array_values_equal_to_k;
+pub mod problem_3376_minimum_time_to_break_locks_i;
 
 #[cfg(test)]
 mod test_utilities;

src/problem_3376_minimum_time_to_break_locks_i/dynamic_programming.rs

@@ -0,0 +1,51 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl Solution {
+    fn iter_bits(mut x: u8, mut f: impl FnMut(u8)) {
+        while x != 0 {
+            let bit = x & x.wrapping_neg();
+
+            f(bit);
+
+            x ^= bit;
+        }
+    }
+
+    pub fn find_minimum_time(strength: Vec<i32>, k: i32) -> i32 {
+        let strength = strength.into_iter().map(i32::cast_unsigned).collect::<Vec<_>>();
+        let k = k.cast_unsigned();
+        let cache = &mut [0_u32; 256][..1 << strength.len()];
+
+        for i in 1..cache.len() {
+            let factor = 1 + k * (i.count_ones() - 1);
+            let mut cost = u32::MAX;
+
+            Self::iter_bits(i as _, |bit| {
+                cost = cost
+                    .min(cache[usize::from(i as u8 ^ bit)] + strength[bit.trailing_zeros() as usize].div_ceil(factor));
+            });
+
+            cache[i] = cost;
+        }
+
+        cache.last().unwrap().cast_signed()
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn find_minimum_time(strength: Vec<i32>, k: i32) -> i32 {
+        Self::find_minimum_time(strength, k)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}

src/problem_3376_minimum_time_to_break_locks_i/mod.rs

@@ -0,0 +1,22 @@
+pub mod dynamic_programming;
+
+pub trait Solution {
+    fn find_minimum_time(strength: Vec<i32>, k: i32) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[3, 4, 1] as &[_], 1), 4),
+            ((&[2, 5, 4], 2), 5),
+            ((&[25, 12, 21, 40, 20, 41, 14, 42], 4), 28),
+        ];
+
+        for ((strength, k), expected) in test_cases {
+            assert_eq!(S::find_minimum_time(strength.to_vec(), k), expected);
+        }
+    }
+}