#1005505 (Rust) No.306 さいたま2008

• 問題: No.306 さいたま2008
• ユーザー: Haar
• 提出日時: 2024-08-28 17:43:24
• 言語: Rust (1.77.0 + proconio)
• 結果: WA
• 実行時間: -
• コード長: 8,288 bytes
• コンパイル時間: 18,660 ms
• コンパイル使用メモリ: 400,200 KB
• 実行使用メモリ: 6,944 KB
• 最終ジャッジ日時: 2024-08-28 17:43:44
• 合計ジャッジ時間: 20,191 ms
• ジャッジサーバーID （参考情報）: judge3 / judge1

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	1 ms; 6,816 KB
testcase_01	AC	1 ms; 6,944 KB
testcase_02	AC	1 ms; 6,940 KB
testcase_03	AC	1 ms; 6,940 KB
testcase_04	AC	1 ms; 6,940 KB
testcase_05	AC	1 ms; 6,940 KB
testcase_06	AC	1 ms; 6,944 KB
testcase_07	AC	1 ms; 6,944 KB
testcase_08	AC	1 ms; 6,940 KB
testcase_09	AC	1 ms; 6,940 KB
testcase_10	AC	1 ms; 6,940 KB
testcase_11	AC	1 ms; 6,940 KB
testcase_12	AC	1 ms; 6,940 KB
testcase_13	AC	1 ms; 6,944 KB
testcase_14	AC	1 ms; 6,944 KB
testcase_15	AC	1 ms; 6,944 KB
testcase_16	AC	1 ms; 6,940 KB
testcase_17	AC	1 ms; 6,944 KB
testcase_18	AC	1 ms; 6,944 KB
testcase_19	AC	1 ms; 6,940 KB
testcase_20	WA	-
testcase_21	WA	-
testcase_22	AC	1 ms; 6,944 KB

コンパイルメッセージ

warning: unused imports: `get`, `input`, `utils::join_str::*`
 --> src/main.rs:6:45
  |
6 |     use haar_lib::{algo::ternary_search::*, get, input, utils::fastio::*, utils::join_str::*};
  |                                             ^^^  ^^^^^                    ^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

ソースコード

// Bundled at 2024/08/28 17:41:24 +09:00
// Author: Haar

pub mod main {
    use super::*;
    use haar_lib::{algo::ternary_search::*, get, input, utils::fastio::*, utils::join_str::*};
    #[allow(unused_imports)]
    use std::cell::RefCell;
    #[allow(unused_imports)]
    use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet};
    #[allow(unused_imports)]
    use std::io::Write;
    #[allow(unused_imports)]
    use std::rc::Rc;
    #[derive(Clone, Default)]
    pub struct Problem {}
    impl Problem {
        pub fn main(&mut self) -> Result<(), Box<dyn std::error::Error>> {
            let mut io = FastIO::new();
            let xa = io.read_f64();
            let ya = io.read_f64();
            let xb = io.read_f64();
            let yb = io.read_f64();
            let ans = ternary_search(-1000.0, 10000.0, Convex::Downwards, 100, |p| {
                xa.hypot(ya - p) + xb.hypot(yb - p)
            });
            io.writeln(ans);
            Ok(())
        }
    }
}
fn main() {
    main::Problem::default().main().unwrap();
}
use crate as haar_lib;
pub mod algo {
    pub mod ternary_search {
        #[derive(Clone, Copy, Debug)]
        pub enum Convex {
            Upwards,
            Downwards,
        }
        pub fn ternary_search<F: Fn(f64) -> f64>(
            mut lb: f64,
            mut ub: f64,
            convex: Convex,
            mut loop_count: usize,
            f: F,
        ) -> f64 {
            while loop_count > 0 {
                let t1 = lb + (ub - lb) / 3.0;
                let t2 = lb + (ub - lb) / 3.0 * 2.0;
                if (matches!(convex, Convex::Upwards) && f(t1) > f(t2))
                    || (matches!(convex, Convex::Downwards) && f(t1) < f(t2))
                {
                    ub = t2;
                } else {
                    lb = t1;
                }
                loop_count -= 1;
            }
            lb
        }
    }
}
pub mod macros {
    pub mod io {
        #[macro_export]
        macro_rules! get {
    ( $in:ident, [$a:tt $(as $to:ty)*; $num:expr] ) => {
        {
            let n = $num;
            (0 .. n).map(|_| get!($in, $a $(as $to)*)).collect::<Vec<_>>()
        }
    };
    ( $in:ident, ($($type:tt $(as $to:ty)*),*) ) => {
        ($(get!($in, $type $(as $to)*)),*)
    };
    ( $in:ident, i8 ) => { $in.read_i64() as i8 };
    ( $in:ident, i16 ) => { $in.read_i64() as i16 };
    ( $in:ident, i32 ) => { $in.read_i64() as i32 };
    ( $in:ident, i64 ) => { $in.read_i64() };
    ( $in:ident, isize ) => { $in.read_i64() as isize };
    ( $in:ident, u8 ) => { $in.read_u64() as u8 };
    ( $in:ident, u16 ) => { $in.read_u64() as u16 };
    ( $in:ident, u32 ) => { $in.read_u64() as u32 };
    ( $in:ident, u64 ) => { $in.read_u64() };
    ( $in:ident, usize ) => { $in.read_u64() as usize };
    ( $in:ident, [char] ) => { $in.read_chars() };
    ( $in:ident, $from:tt as $to:ty ) => { <$to>::from(get!($in, $from)) };
}
        #[macro_export]
        macro_rules! input {
    ( @inner $in:ident, mut $name:ident : $type:tt ) => {
        let mut $name = get!($in, $type);
    };
    ( @inner $in:ident, mut $name:ident : $type:tt as $to:ty ) => {
        let mut $name = get!($in, $type as $to);
    };
    ( @inner $in:ident, $name:ident : $type:tt ) => {
        let $name = get!($in, $type);
    };
    ( @inner $in:ident, $name:ident : $type:tt as $to:ty ) => {
        let $name = get!($in, $type as $to);
    };
    ( $in:ident >> $($($names:ident)* : $type:tt $(as $to:ty)*),* ) => {
        $(input!(@inner $in, $($names)* : $type $(as $to)*);)*
    }
}
    }
}
pub mod utils {
    pub mod fastio {
        use std::fmt::Display;
        use std::io::{Read, Write};
        pub struct FastIO {
            in_bytes: Vec<u8>,
            in_cur: usize,
            out_buf: std::io::BufWriter<std::io::Stdout>,
        }
        impl FastIO {
            pub fn new() -> Self {
                let mut s = vec![];
                std::io::stdin().read_to_end(&mut s).unwrap();
                let cout = std::io::stdout();
                Self {
                    in_bytes: s,
                    in_cur: 0,
                    out_buf: std::io::BufWriter::new(cout),
                }
            }

            #[inline]
            pub fn getc(&mut self) -> Option<u8> {
                if self.in_cur < self.in_bytes.len() {
                    self.in_cur += 1;
                    Some(self.in_bytes[self.in_cur])
                } else {
                    None
                }
            }

            #[inline]
            pub fn peek(&self) -> Option<u8> {
                if self.in_cur < self.in_bytes.len() {
                    Some(self.in_bytes[self.in_cur])
                } else {
                    None
                }
            }

            #[inline]
            pub fn skip(&mut self) {
                while self.peek().map_or(false, |c| c.is_ascii_whitespace()) {
                    self.in_cur += 1;
                }
            }

            pub fn read_u64(&mut self) -> u64 {
                self.skip();
                let mut ret: u64 = 0;
                while self.peek().map_or(false, |c| c.is_ascii_digit()) {
                    ret = ret * 10 + (self.in_bytes[self.in_cur] - b'0') as u64;
                    self.in_cur += 1;
                }
                ret
            }

            pub fn read_u32(&mut self) -> u32 {
                self.read_u64() as u32
            }

            pub fn read_usize(&mut self) -> usize {
                self.read_u64() as usize
            }

            pub fn read_i64(&mut self) -> i64 {
                self.skip();
                let mut ret: i64 = 0;
                let minus = if self.peek() == Some(b'-') {
                    self.in_cur += 1;
                    true
                } else {
                    false
                };
                while self.peek().map_or(false, |c| c.is_ascii_digit()) {
                    ret = ret * 10 + (self.in_bytes[self.in_cur] - b'0') as i64;
                    self.in_cur += 1;
                }
                if minus {
                    ret = -ret;
                }
                ret
            }

            pub fn read_i32(&mut self) -> i32 {
                self.read_i64() as i32
            }

            pub fn read_isize(&mut self) -> isize {
                self.read_i64() as isize
            }

            pub fn read_f64(&mut self) -> f64 {
                self.read_chars()
                    .into_iter()
                    .collect::<String>()
                    .parse()
                    .unwrap()
            }

            pub fn read_chars(&mut self) -> Vec<char> {
                self.skip();
                let mut ret = vec![];
                while self.peek().map_or(false, |c| c.is_ascii_graphic()) {
                    ret.push(self.in_bytes[self.in_cur] as char);
                    self.in_cur += 1;
                }
                ret
            }

            pub fn write_rev<T: Display>(&mut self, s: T) {
                let mut s = format!("{}", s);
                let s = unsafe { s.as_bytes_mut() };
                s.reverse();
                self.out_buf.write_all(s).unwrap();
            }

            pub fn write<T: Display>(&mut self, s: T) {
                self.out_buf.write_all(format!("{}", s).as_bytes()).unwrap();
            }

            pub fn writeln_rev<T: Display>(&mut self, s: T) {
                self.write_rev(s);
                self.out_buf.write_all(&[b'\n']).unwrap();
            }

            pub fn writeln<T: Display>(&mut self, s: T) {
                self.write(s);
                self.out_buf.write_all(&[b'\n']).unwrap();
            }
        }
        impl Drop for FastIO {
            fn drop(&mut self) {
                self.out_buf.flush().unwrap();
            }
        }
    }
    pub mod join_str {
        pub trait JoinStr {
            fn join_str(self, _: &str) -> String;
        }
        impl<T, I> JoinStr for I
        where
            T: ToString,
            I: Iterator<Item = T>,
        {
            fn join_str(self, s: &str) -> String {
                self.map(|x| x.to_string()).collect::<Vec<_>>().join(s)
            }
        }
    }
}