use std::io::*;
use utils::*;

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

pub fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = CpReader::new(i);
    let n = i.read::<usize>();
    let xyd = i.read_vec::<(i64, i64, char)>(n);

    writeln!(o, "{}", solve(&xyd)).unwrap();
}
#[derive(Copy, Clone)]
struct ValRange {
    min: f64,
    max: f64,
}
impl ValRange {
    fn new() -> Self {
        ValRange {
            min: std::f64::INFINITY,
            max: std::f64::NEG_INFINITY,
        }
    }
    fn set(&mut self, value: i64) {
        self.min = self.min.min(value as f64);
        self.max = self.max.max(value as f64);
    }
    #[inline]
    fn at(&self, t: f64) -> Self {
        ValRange {
            min: self.min + t,
            max: self.max + t,
        }
    }
    #[inline]
    fn union(&self, other: Self) -> Self {
        ValRange {
            min: self.min.min(other.min),
            max: self.max.max(other.max),
        }
    }
    #[inline]
    fn d(&self) -> f64 {
        self.max - self.min
    }
}

fn solve(xyd: &[(i64, i64, char)]) -> f64 {
    let mut static_x = ValRange::new();
    let mut static_y = ValRange::new();

    let mut y_u = ValRange::new();
    let mut y_d = ValRange::new();

    let mut x_l = ValRange::new();
    let mut x_r = ValRange::new();

    for &(x, y, d) in xyd {
        match d {
            'R' => {
                static_y.set(y);
                x_r.set(x);
            }
            'L' => {
                static_y.set(y);
                x_l.set(x);
            }
            'U' => {
                static_x.set(x);
                y_u.set(y);
            }
            'D' => {
                static_x.set(x);
                y_d.set(y);
            }
            _ => unreachable!(),
        }
    }
    let xd = |t: f64| d(t, &static_x, &x_r, &x_l);
    let yd = |t: f64| d(t, &static_y, &y_u, &y_d);

    let mut ts = vec![0.0];
    cross_t3(&static_y, &y_u, &y_d, &mut ts);
    cross_t3(&static_x, &x_r, &x_l, &mut ts);

    ts.iter().map(|&t| OrdF64(xd(t) * yd(t))).min().unwrap().0
}

fn d(t: f64, val_static: &ValRange, val_up: &ValRange, val_down: &ValRange) -> f64 {
    val_static.union(val_down.at(-t)).union(val_up.at(t)).d()
}
fn cross_t3(val_static: &ValRange, val_up: &ValRange, val_down: &ValRange, ts: &mut Vec<f64>) {
    cross_t2(val_up, val_down, 2.0, ts);
    cross_t2(val_up, val_static, 1.0, ts);
    cross_t2(val_static, val_down, 1.0, ts);
}
fn cross_t2(val_up: &ValRange, val_down: &ValRange, step: f64, ts: &mut Vec<f64>) {
    cross_t(val_up.max, val_down.max, step, ts);
    cross_t(val_up.max, val_down.min, step, ts);
    cross_t(val_up.min, val_down.max, step, ts);
    cross_t(val_up.min, val_down.min, step, ts);
}
fn cross_t(val_up: f64, val_down: f64, step: f64, ts: &mut Vec<f64>) {
    if val_up.is_finite() && val_down.is_finite() && val_up < val_down {
        ts.push((val_down - val_up) / step);
    }
}

pub mod utils {
    use super::*;
    use std::cmp::Ordering;

    pub struct CpReader<R: BufRead> {
        r: R,
        b: Vec<u8>,
    }
    impl<R: BufRead> CpReader<R> {
        pub fn new(r: R) -> Self {
            CpReader {
                r: r,
                b: Vec::new(),
            }
        }
        pub fn read_word(&mut self) -> &[u8] {
            self.b.clear();
            let mut consume = 0;
            loop {
                self.r.consume(consume);
                let b = self.r.fill_buf().unwrap();
                assert!(b.len() != 0);
                if let Some(p) = b.iter().position(|&x| x == b' ' || x == b'\n') {
                    self.b.extend_from_slice(&b[..p]);
                    consume = p + 1;
                    break;
                }
                self.b.extend_from_slice(b);
                consume = b.len();
            }
            self.r.consume(consume);
            &self.b
        }
        pub fn read_word_str(&mut self) -> &str {
            unsafe { std::str::from_utf8_unchecked(self.read_word()) }
        }

        pub fn read_line(&mut self) -> &[u8] {
            self.b.clear();
            self.r.read_until(b'\n', &mut self.b).unwrap();
            if self.b.last() == Some(&b'\n') {
                &self.b[..self.b.len() - 1]
            } else {
                &self.b
            }
        }
        pub fn read_line_str(&mut self) -> &str {
            unsafe { std::str::from_utf8_unchecked(self.read_line()) }
        }

        pub fn read<T: CpIn>(&mut self) -> T {
            T::read_from(self)
        }

        pub fn read_vec<T: CpIn>(&mut self, n: usize) -> Vec<T> {
            (0..n).map(|_| self.read()).collect()
        }
        pub fn read_iter<'a, T: CpIn>(&'a mut self, n: usize) -> CpIter<'a, R, T> {
            CpIter {
                r: self,
                n: n,
                _pd: Default::default(),
            }
        }
    }
    pub struct CpIter<'a, R: BufRead + 'a, T> {
        r: &'a mut CpReader<R>,
        n: usize,
        _pd: std::marker::PhantomData<fn() -> T>,
    }
    impl<'a, R: BufRead, T: CpIn> Iterator for CpIter<'a, R, T> {
        type Item = T;
        fn next(&mut self) -> Option<T> {
            if self.n == 0 {
                None
            } else {
                self.n -= 1;
                Some(self.r.read())
            }
        }
    }

    pub trait CpIn {
        fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self;
    }

    impl CpIn for u64 {
        fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
            read_u64_fast(&mut r.r)
        }
    }
    impl CpIn for i64 {
        fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
            read_i64_fast(&mut r.r)
        }
    }
    impl CpIn for char {
        fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
            let b = r.r.fill_buf().unwrap()[0] as char;
            r.r.consume(1);
            let s = r.r.fill_buf().unwrap()[0];
            assert!(s == b' ' || s == b'\n');
            r.r.consume(1);
            b
        }
    }

    macro_rules! cpin_tuple {
        ($($t:ident),*) => {
            impl<$($t: CpIn),*> CpIn for ($($t),*) {
                fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
                    ($($t::read_from(r)),*)
                }
            }
        };
    }

    macro_rules! cpin_cast {
        ($t_self:ty, $t_read:ty) => {
            impl CpIn for $t_self {
                fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
                    <$t_read>::read_from(r) as $t_self
                }
            }
        };
    }
    macro_rules! cpin_parse {
        ($t:ty) => {
            impl CpIn for $t {
                fn read_from<R: BufRead>(r: &mut CpReader<R>) -> Self {
                    r.read_word_str().parse().unwrap()
                }
            }
        };
    }
    cpin_cast!(usize, u64);
    cpin_cast!(u32, u64);
    cpin_cast!(u16, u64);
    cpin_cast!(i32, i64);
    cpin_cast!(i16, i64);
    cpin_cast!(i8, i64);

    cpin_parse!(f64);

    cpin_tuple!(T1, T2);
    cpin_tuple!(T1, T2, T3);
    cpin_tuple!(T1, T2, T3, T4);
    cpin_tuple!(T1, T2, T3, T4, T5);

    fn read_u64_fast<R: BufRead>(r: &mut R) -> u64 {
        let mut value = 0;
        loop {
            let mut idx = 0;
            let buf_len;
            {
                let buf = r.fill_buf().unwrap();
                buf_len = buf.len();
                assert!(buf_len != 0);
                while idx < buf_len && b'0' <= buf[idx] && buf[idx] <= b'9' {
                    value = value * 10 + (buf[idx] - b'0') as u64;
                    idx += 1;
                }
            }
            if idx < buf_len {
                r.consume(idx + 1);
                return value;
            }
            r.consume(idx);
        }
    }
    fn read_i64_fast<R: BufRead>(r: &mut R) -> i64 {
        let (consume, sign) = match r.fill_buf().unwrap()[0] {
            b'+' => (true, 1),
            b'-' => (true, -1),
            _ => (false, 1),
        };
        if consume {
            r.consume(1);
        }
        read_u64_fast(r) as i64 * sign
    }

    pub fn binary_search<F: Fn(usize) -> bool>(len: usize, f: F) -> usize {
        let mut low = 0;
        let mut high = len;
        while low < high {
            let mid = (low + high) / 2;
            if f(mid) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }
        low
    }

    pub fn binary_search_f<F: Fn(f64) -> bool>(len: f64, d: f64, f: F) -> f64 {
        let mut low = 0.0;
        let mut high = len;
        while low + d < high {
            let mid = (low + high) / 2.0;
            if f(mid) {
                high = mid;
            } else {
                low = mid;
            }
        }
        (low + high) / 2.0
    }

    #[derive(PartialEq, PartialOrd)]
    pub struct OrdF64(pub f64);

    impl OrdF64 {
        pub fn new(value: f64) -> Self {
            assert!(!value.is_nan());
            OrdF64(value)
        }
    }

    impl Eq for OrdF64 {}
    impl Ord for OrdF64 {
        fn cmp(&self, other: &Self) -> Ordering {
            self.partial_cmp(&other).unwrap()
        }
    }

}


Measured memory_bytes: 8444