module Array = ArrayLabels
module List = ListLabels

let inf = 1000000000.
let (>>=) x f = List.map f x |> List.concat

let () =
  Scanf.scanf "%d" @@ fun n ->
  let xyds = Array.init n (fun _ -> Scanf.scanf " %f %f %s" (fun x y d -> x, y, d)) in
  let find_edges axis dir =
    Array.fold_left xyds ~init:(inf, -.inf) ~f:(fun (minv, maxv) (x, y, d) ->
      let v = match axis with `X -> x | `Y -> y in
      if d = dir then (min minv v, max maxv v) else (minv, maxv))
  in
  let dirs = ["R"; "L"; "U"; "D"] in
  let exs = List.map dirs ~f:(fun d ->
    let x1, x2 = find_edges `X d in
    (x1, x2, match d with "R" -> 1. | "L" -> -1. | _ -> 0.))
  and eys = List.map dirs ~f:(fun d ->
    let y1, y2 = find_edges `Y d in
    (y1, y2, match d with "U" -> 1. | "D" -> -1. | _ -> 0.))
  in

  let area_of_time (t : float) =
    let (+), (-), ( * ) = (+.), (-.), ( *.) in
    let xm, xM = List.fold_left exs ~init:(inf, -.inf) ~f:(fun (xm, xM) (x1, x2, mul) ->
      (min xm (x1 + mul * t), max xM (x2 + mul * t)))
    in
    let ym, yM = List.fold_left eys ~init:(inf, -.inf) ~f:(fun (ym, yM) (y1, y2, mul) ->
      (min ym (y1 + mul * t), max yM (y2 + mul * t)))
    in
    (xM - xm) * (yM - ym)
  in

  let txs =
    exs >>= fun (xa1, xa2, da) ->
    exs >>= fun (xb1, xb2, db) ->
      if da = db then [] else
        [xa1; xa2] >>= fun xa ->
        [xb1; xb2] >>= fun xb -> [abs_float @@ (xa -. xb) /. (da -. db)]
  and tys =
    eys >>= fun (ya1, ya2, da) ->
    eys >>= fun (yb1, yb2, db) ->
      if da = db then [] else
        [ya1; ya2] >>= fun ya ->
        [yb1; yb2] >>= fun yb -> [abs_float @@ (ya -. yb) /. (da -. db)]
  in
  List.map area_of_time ([0.] @ txs @ tys) |> List.fold_left ~f:min ~init:inf
  |> Printf.printf "%.11f\n"
