Problem:
Problem C: Dragon Fantasy

永遠に続くと思われていた平和は突然終わりを告げた。 はるか昔に封印されていた魔王がついに復活を遂げたのである。 だが、今まさに世界が闇に覆われようとしているとき、1 人の勇者が現れた。 そしてその勇者は、世界各地に散らばっている伝説のクリスタルを集める旅に出た。 伝説によると、全てのクリスタルを集めることができたならば、どのような願いでもかなえられるという伝説の龍神を呼び出すことができると伝えられている。 その龍神の力を借りれば魔王を倒すことも可能なはずだ。

クリスタルは世界各地に散らばっている。 勇者はそれらを 1 つずつ、自らの手で集めていく必要がある。 なぜなら、勇者以外の者がクリスタルを手に入れたならば、魔王の手先によって奪われてしまうかもしれないからである。 勇者は、1 日あたりユークリッド距離で 1 だけ移動することができる。

しかし、ここで 1 つの重大な問題がある。 魔王は、常に闇の瘴気をまき散らしており、その瘴気に汚染された場所は人が立ち入ることのできない死の大地と化してしまう。 たとえ勇者であってもその場所に立ち入ることはできない。 さらに、その瘴気は時間とともに同心円状に広まっていくため、 時間の経過とともに勇者の移動できる領域は減少していってしまう。 瘴気は 1 日あたりユークリッド距離 1 だけ広がることが確認されている。 そして、その境界線上にあるクリスタルを勇者は取ることはできない。また、復活したばかりの魔王は力を蓄えるために動かないことも分かっている。

勇者は一刻も早くクリスタルを手に入れなければならない。 しかし、もし全てのクリスタルを手に入れることが不可能であるならば、別の手段を考えなければならないだろう。 そこで、あなたには勇者の初期位置と魔王の復活した場所、そしてクリスタルの存在する位置から、全てのクリスタルを手に入れることができるかどうかを調べるプログラムを作っていただきたい。

ちなみに、勇者は疲れない。 そして眠らない。 全てのクリスタルを集めて世界を救うまでは絶えず動き続け、クリスタルを集めるのだ！！

Input

入力は複数のテストケースから構成される。 各テストケースの先頭の行では 5 つの整数 n (0 < n <= 20)、hx 、hy 、dx 、dy が与えられる。
n はクリスタルの個数、(hx , hy ) は魔王が復活した瞬間での勇者の位置、(dx , dy ) は魔王が復活した位置である。
後に続く n 行には、各クリスタルの位置を表す 2 つの整数 cx 、cy が与えられる。 入力は n = hx = hy = dx = dy = 0 のときに終了し、これはテストケースには含まない。

入力で与えられる全ての座標は絶対値が 1000 以下の整数であることが保証されている。

Output

各テストケースについて、全てのクリスタルを集めることができるならば「YES」と、そうでないならば「NO」と出力せよ。

Sample Input

2 0 0 10 10
1 1
4 4
2 0 0 10 10
1 1
6 6
2 0 0 10 10
1 1
5 5
0 0 0 0 0

Output for the Sample Input

YES
NO
NO

Solution in Rust (judge verdict: Memory Limit Exceeded)

use std::io::{Read, StdinLock};
use std::ops::{Add, Mul, Sub};
use std::str::{from_utf8, FromStr};
use std::vec::Vec;

struct StdinReader<'a> {
    reader: StdinLock<'a>,
}

impl<'a> StdinReader<'a> {
    pub fn new(reader: StdinLock<'a>) -> StdinReader {
        StdinReader { reader: reader }
    }

    pub fn read<T: FromStr>(&mut self) -> T {
        fn is_whitespace(ch: u8) -> bool {
            ch == 0x20 || ch == 0x0a || ch == 0x0d
        }

        let token: Vec<u8> = self.reader
            .by_ref()
            .bytes()
            .map(|ch| ch.expect("failed to read a byte"))
            .skip_while(|ch| is_whitespace(*ch))
            .take_while(|ch| !is_whitespace(*ch))
            .collect();
        let token_str = from_utf8(&token)
            .unwrap_or_else(|_| panic!(format!("invalid utf8 sequence: {:?}", token)));
        token_str
            .parse()
            .unwrap_or_else(|_| panic!(format!("failed to parse input: {}", token_str)))
    }
}

const EPS: f64 = 1e-10;

#[derive(Debug, Copy, Clone)]
struct Complex {
    pub re: f64,
    pub im: f64,
}

impl Complex {
    fn new(re: f64, im: f64) -> Complex { Complex { re: re, im: im } }
}

impl Add<Complex> for Complex {
    type Output = Complex;
    fn add(self, other: Complex) -> Complex { Complex::new(self.re + other.re, self.im + other.im) }
}

impl Sub<Complex> for Complex {
    type Output = Complex;
    fn sub(self, other: Complex) -> Complex { Complex::new(self.re - other.re, self.im - other.im) }
}

impl Mul<f64> for Complex {
    type Output = Complex;
    fn mul(self, other: f64) -> Complex { Complex::new(self.re * other, self.im * other) }
}

impl Mul<Complex> for Complex {
    type Output = Complex;
    fn mul(self, other: Complex) -> Complex {
        Complex::new(self.re * other.re - self.im * other.im,
                     self.re * other.im + self.im * other.re)
    }
}

impl Complex {
    fn conj(&self) -> Complex { Complex::new(self.re, -self.im) }
    fn norm_sqr(&self) -> f64 { self.re * self.re + self.im * self.im }
    fn norm(&self) -> f64 { self.norm_sqr().sqrt() }
    /*
    fn inv(&self) -> Complex {
        let d = self.norm_sqr();
        Complex::new(self.re / d, -self.im / d)
    }
    */
    fn dot(&self, other: Complex) -> f64 {
        (self.conj() * other).re
    }
    /*
    fn cross(&self, other: Complex) -> f64 {
        (self.conj() * other).im
    }
    */
}

/*
fn ccw(a: Complex, b: Complex, c: Complex) -> i32 {
    let p = b - a;
    let q = c - a;
    if p.cross(q) > 0.0 { return 1; }
    if p.cross(q) < 0.0 { return -1; }
    if p.dot(q) < 0.0 { return 2; }
    if p.norm_sqr() < q.norm_sqr() { return -2; }
    return 0;
}
*/

fn projection(a: Complex, b: Complex, p: Complex) -> Complex {
    let t = (p - a).dot(a - b) / (a - b).norm();
    a + (a - b) * t
}

fn intersect_sp(a: Complex, b: Complex, p: Complex) -> bool {
    (a - p).norm() + (b - p).norm() - (b - a).norm() < EPS
}

/*
fn distance_sp(a: Complex, b: Complex, p: Complex) -> f64 {
    let r = projection(a, b, p);
    if intersect_sp(a, b, p) {
        (r - p).norm()
    } else {
        (a - p).norm().min((b - p).norm())
    }
}
*/

fn main() {
    let zero = Complex::new(0.0, 0.0);

    let stdin = std::io::stdin();
    let mut reader = StdinReader::new(stdin.lock());

    loop {
        // 入力
        let n: usize = reader.read();
        let hx: f64 = reader.read();
        let hy: f64 = reader.read();
        let dx: f64 = reader.read();
        let dy: f64 = reader.read();
        let start = Complex::new(hx - dx, hy - dy);
        if n == 0 { break; }

        let mut crystals: Vec<Complex> = Vec::new();
        for _ in 0..n {
            let cx = reader.read::<f64>() - dx;
            let cy = reader.read::<f64>() - dy;
            crystals.push(Complex::new(cx, cy));
        }

        let mut distance = vec![vec![0.0; n]; n];
        let mut time_limit = vec![vec![0.0; n]; n];

        for i in 0..n {
            for j in 0..n {
                if i != j {
                    let p1 = crystals[i];
                    let p2 = crystals[j];
                    let t1 = p1.norm();
                    let t2 = p2.norm() - (p2 - p1).norm();
                    let r = projection(p1, p2, zero);
                    let t3 = if intersect_sp(p1, p2, zero) {
                        r.norm() - (r - p1).norm()
                    } else {
                        1e10
                    };
                    time_limit[i][j] = t1.min(t2.min(t3));
                    distance[i][j] = (p1 - p2).norm();
                }
            }
        }

        // dp[S][v] = Sのすべての頂点を訪れた後にvを訪れるときの最小の時刻
        let mut dp = vec![vec![0.0; n]; 1 << n];
        for v in 0..n {
            dp[0][v] = (crystals[v] - start).norm();
        }
        for set in 1..(1 << n) {
            for v in 0..n {
                if set & (1 << v) != 0 { continue; }
                let mut min_time: f64 = 1e10;
                for u in 0..n {
                    if set & (1 << u) == 0 { continue; }
                    let t = dp[set ^ (1 << u)][u];
                    if t < time_limit[u][v] {
                        min_time = min_time.min(t + distance[u][v]);
                    }
                }
                dp[set][v] = min_time;
            }
        }

        let mut ok = false;
        for v in 0..n {
            let set = (1 << n) - 1;
            if dp[set ^ (1 << v)][v] < 1e10 {
                ok = true;
            }
        }
        println!("{}", if ok { "YES" } else { "NO" })
    }
}