sec1

Author: matonix

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,17 @@
+[package]
+name = "antbook"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+proconio = { version = "=0.4.3", features = ["derive"] }
+itertools = "=0.9.0"
+
+[[bin]]
+name = "main"
+# path = "src/1_1.rs"
+# path = "src/1_6_triangle.rs"
+# path = "src/1_6_ant.rs"
+path = "src/binary_search.rs"

Cargo.toml

@@ -0,0 +1,74 @@
+use itertools::*;
+use proconio::{fastout, input};
+
+#[fastout]
+fn main() {
+    input! {
+        n: usize,
+        m: i32,
+        k: [i32; n]
+    }
+    let ans = if solve(n, m, &k) { "Yes" } else { "no" };
+    println!("{}", ans);
+}
+
+// O(n^2 log n^2)
+fn solve(_n: usize, m: i32, k: &[i32]) -> bool {
+    let prod: &Vec<i32> = &k
+        .iter()
+        .combinations(2)
+        .map(|v| v.into_iter().sum())
+        .sorted()
+        .collect::<Vec<_>>();
+    for i in prod {
+        if let Ok(_) = prod.binary_search(&(m - i)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// O(n^3 log n)
+fn _solve(_n: usize, m: i32, k: &[i32]) -> bool {
+    for a in k {
+        for b in k {
+            for c in k {
+                let d = m - a - b - c;
+                if let Ok(_) = k.binary_search(&d) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+// O(n^4)
+fn __solve(_n: usize, m: i32, k: &[i32]) -> bool {
+    for a in k {
+        for b in k {
+            for c in k {
+                for d in k {
+                    if a + b + c + d == m {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::solve;
+
+    #[test]
+    fn example1() {
+        assert_eq!(solve(3, 10, &[1, 3, 5]), true);
+    }
+    #[test]
+    fn example2() {
+        assert_eq!(solve(3, 9, &[1, 3, 5]), false);
+    }
+}

src/1_1.rs

@@ -0,0 +1,37 @@
+use std::cmp::*;
+
+use proconio::{fastout, input};
+
+#[fastout]
+fn main() {
+    input! {
+        l: i32,
+        n: usize,
+        x: [i32; n]
+    }
+    let (min, max) = solve(l, n, &x);
+    println!("min = {}", min);
+    println!("max = {}", max);
+}
+
+fn solve(l: i32, _n: usize, x: &[i32]) -> (i32, i32) {
+    let min = x.iter().map(|&x| min(x, l - x)).max().unwrap();
+    let max = x.iter().map(|&x| max(x, l - x)).max().unwrap();
+    return (min, max);
+}
+
+fn _solve(l: i32, _n: usize, x: &[i32]) -> (i32, i32) {
+    let min = (l/2) - x.iter().map(|x| (x - (l/2)).abs()).min().unwrap();
+    let max = (l/2) + x.iter().map(|x| (x - (l/2)).abs()).max().unwrap();
+    return (min, max);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::solve;
+
+    #[test]
+    fn example1() {
+        assert_eq!(solve(10, 3, &[2, 6, 7]), (4, 8));
+    }
+}

src/1_6_ant.rs

@@ -0,0 +1,51 @@
+use std::cmp::Reverse;
+
+use proconio::{input, fastout};
+
+#[fastout]
+fn main() {
+    input!{
+        n: usize,
+        mut a: [i32; n]
+    }
+    println!("{}", solve(n, &mut a));
+}
+
+
+fn solve(n: usize, a: &mut [i32]) -> i32 {
+    a.sort_by_key(|w| Reverse(*w));
+    for i in 0..n-2 {
+        if a[i] < a[i+1] + a[i+2] {
+            return a[i] + a[i+1] + a[i+2];
+        }
+    }
+    return 0;
+}
+
+fn _solve(n: usize, a: &mut [i32]) -> i32 {
+    a.sort_by_key(|w| Reverse(*w));
+    for i in 0..n {
+        for j in i+1..n {
+            for k in j+1..n {
+                if a[i] < a[j] + a[k] {
+                    return a[i] + a[j] + a[k];
+                }
+            } 
+        }
+    }
+    return 0;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::solve;
+
+    #[test]
+    fn example1() {
+        assert_eq!(solve(5, &mut [2, 3, 4, 5, 10]), 12);
+    }
+    #[test]
+    fn example2() {
+        assert_eq!(solve(4, &mut [4, 5, 10, 20]), 0);
+    }
+}

src/1_6_triangle.rs

@@ -0,0 +1,87 @@
+use proconio::{fastout, input};
+
+#[fastout]
+fn main() {
+    input! {
+        n: usize,
+        x: usize,
+        xs: [usize; n]
+    }
+    println!("{:?}", xs.lower_bound(&x));
+}
+pub trait BinarySearch<T> {
+    fn lower_bound(&self, x: &T) -> usize;
+    fn upper_bound(&self, x: &T) -> usize;
+}
+
+impl<T: Ord> BinarySearch<T> for [T] {
+    // x 以上の要素のうち最初の要素の添字を返す。
+    // xs には昇順ソート済みを想定する。
+    fn lower_bound(&self, x: &T) -> usize {
+        let mut left = 0;
+        let mut right = self.len();
+        while left != right {
+            let mid = (left + right) / 2;
+            if &self[mid] < x {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        left
+    }
+
+    // x より大きい要素のうち最初の要素の添字を返す。
+    // xs には昇順ソート済みを想定する。
+    fn upper_bound(&self, x: &T) -> usize {
+        let mut left = 0;
+        let mut right = self.len();
+        while left != right {
+            let mid = (left + right) / 2;
+            if &self[mid] <= x {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        left
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lower1_found_exact() {
+        assert_eq!([1, 2, 3, 4, 5].lower_bound(&3), 2);
+    }
+    #[test]
+    fn lower2_found_exact_dup() {
+        assert_eq!([1, 2, 3, 3, 3, 4, 5].lower_bound(&3), 2);
+    }
+    #[test]
+    fn lower3_found_not_exact() {
+        assert_eq!([1, 2, 4, 5].lower_bound(&3), 2);
+    }
+    #[test]
+    fn lower4_not_found() {
+        assert_eq!([1, 2, 2].lower_bound(&3), 3);
+    }
+    #[test]
+    fn upper1_found_exact() {
+        assert_eq!([1, 2, 3, 4, 5].upper_bound(&3), 3);
+    }
+    #[test]
+    fn upper2_found_exact_dup() {
+        assert_eq!([1, 2, 3, 3, 3, 4, 5].upper_bound(&3), 5);
+    }
+    #[test]
+    fn upper3_found_not_exact() {
+        assert_eq!([1, 2, 4, 5].upper_bound(&3), 2);
+    }
+    #[test]
+    fn upper4_not_found() {
+        assert_eq!([1, 2, 2].upper_bound(&3), 3);
+    }
+}