Submission #2173866

---

Source Code Expand

use std::str::FromStr;
use std::io::*;

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(&mut i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}
type Pt = (isize, isize);

fn run<R: BufRead, W: Write>(i: &mut R, o: &mut W) {
    let mut i = ReadEx::from(i);
    let l = i.read_vec::<isize>();
    let xy_a = (l[0], l[1]);
    let xy_b = (l[2], l[3]);
    let t = l[4];
    let v = l[5];
    let n = i.read::<usize>();
    let mut xy = Vec::<Pt>::new();
    for _ in 0..n {
        xy.push(i.read2());
    }
    fn d(xy0: Pt, xy1: Pt) -> f64 {
        let d = ((xy0.0 - xy1.0) as f64, (xy0.1 - xy1.1) as f64);
        (d.0 * d.0 + d.1 * d.1).sqrt()
    }
    let tv = (t * v) as f64;
    let r = xy.iter().any(|&xy| d(xy, xy_a) + d(xy, xy_b) <= tv);
    writeln!(o, "{}", if r { "YES" } else { "NO" }).unwrap();
}

struct ReadEx<'a, R: BufRead + 'a> {
    r: &'a mut R,
    s: String,
}

macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.next().split(' ');
                $(
                    let $v = next(i);
                )*
                ($($v),*)
            }
        };
    }

impl<'a, R: BufRead + 'a> ReadEx<'a, R> {
    fn from(r: &'a mut R) -> Self {
        ReadEx {
            r: r,
            s: String::new(),
        }
    }
    fn next(&mut self) -> &str {
        self.s.clear();
        self.r.read_line(&mut self.s).unwrap();
        self.s.trim()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.next().parse().ok().unwrap()
    }
    fn_read! { read2(v1: T1, v2: T2) }

    fn read_vec<T: FromStr>(&mut self) -> Vec<T> {
        self.next()
            .split(' ')
            .map(|x| x.parse().ok().unwrap())
            .collect()
    }
}

fn next<'a, T: FromStr, I: std::iter::Iterator<Item = &'a str>>(i: &mut I) -> T {
    i.next().unwrap().parse().ok().unwrap()
}

Submission Info

Judge Result