Add problem 3143: Maximum Points Inside the Square

Author: EFanZh

src/lib.rs

@@ -2104,6 +2104,7 @@ pub mod problem_3136_valid_word;
 pub mod problem_3137_minimum_number_of_operations_to_make_word_k_periodic;
 pub mod problem_3138_minimum_length_of_anagram_concatenation;
 pub mod problem_3142_check_if_grid_satisfies_conditions;
+pub mod problem_3143_maximum_points_inside_the_square;
 pub mod problem_3350_adjacent_increasing_subarrays_detection_ii;
 
 #[cfg(test)]

src/problem_3143_maximum_points_inside_the_square/mod.rs

@@ -0,0 +1,25 @@
+pub mod quick_select;
+
+pub trait Solution {
+    fn max_points_inside_square(points: Vec<Vec<i32>>, s: String) -> i32;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    pub fn run<S: Solution>() {
+        let test_cases = [
+            ((&[[2, 2], [-1, -2], [-4, 4], [-3, 1], [3, -3]] as &[_], "abdca"), 2),
+            ((&[[1, 1], [-2, -2], [-2, 2]], "abb"), 1),
+            ((&[[1, 1], [-1, -1], [2, -2]], "ccd"), 0),
+        ];
+
+        for ((points, s), expected) in test_cases {
+            assert_eq!(
+                S::max_points_inside_square(points.iter().map(Vec::from).collect(), s.to_string()),
+                expected,
+            );
+        }
+    }
+}

src/problem_3143_maximum_points_inside_the_square/quick_select.rs

@@ -0,0 +1,98 @@
+pub struct Solution;
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+use std::mem;
+
+impl Solution {
+    pub fn partition<T>(values: &mut [T], mut f: impl FnMut(&T) -> bool) -> usize {
+        let mut result = 0;
+        let mut iter = values.iter_mut();
+
+        'outer: while let Some(left) = iter.next() {
+            if !f(left) {
+                loop {
+                    if let Some(right) = iter.next_back() {
+                        if f(right) {
+                            mem::swap(left, right);
+
+                            break;
+                        }
+                    } else {
+                        break 'outer;
+                    }
+                }
+            }
+
+            result += 1;
+        }
+
+        result
+    }
+
+    pub fn max_points_inside_square(points: Vec<Vec<i32>>, s: String) -> i32 {
+        let mut points = points
+            .into_iter()
+            .zip(s.into_bytes())
+            .map(|(point, tag)| {
+                let [x, y] = point.try_into().unwrap();
+
+                (x.unsigned_abs().max(y.unsigned_abs()), 1 << (tag - b'a'))
+            })
+            .collect::<Vec<_>>();
+
+        let sort_key = |&(x, _): &_| x;
+
+        if points.len() < 27 {
+            points.sort_unstable_by_key(sort_key);
+        } else {
+            let key = points.select_nth_unstable_by_key(25, sort_key).1.0;
+            let n = Self::partition(&mut points[26..], |&(x, _)| x == key);
+
+            points.truncate(26 + n);
+            points[..25].sort_unstable_by_key(sort_key);
+        }
+
+        points.dedup_by(|right, left| {
+            let is_same = left.0 == right.0;
+
+            if is_same {
+                if left.1 & right.1 == 0 {
+                    left.1 |= right.1;
+                } else {
+                    left.1 = u32::MAX;
+                }
+            }
+
+            is_same
+        });
+
+        let mut bits = 0;
+
+        for point in points {
+            if point.1 != u32::MAX && point.1 & bits == 0 {
+                bits |= point.1;
+            } else {
+                break;
+            }
+        }
+
+        bits.count_ones().cast_signed()
+    }
+}
+
+// ------------------------------------------------------ snip ------------------------------------------------------ //
+
+impl super::Solution for Solution {
+    fn max_points_inside_square(points: Vec<Vec<i32>>, s: String) -> i32 {
+        Self::max_points_inside_square(points, s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_solution() {
+        super::super::tests::run::<super::Solution>();
+    }
+}