output_description: Print the minimum possible value of (x_{max} - x_{min}) \times (y_{max} -
  y_{min}).
  
  The output will be considered correct when its absolute or relative error from
  the judge's output is at most 10^{-9}.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      x_1 y_1 d_1
      x_2 y_2 d_2
      .
      .
      .
      x_N y_N d_N
attempt: import sys
  from itertools import combinations
  
  input = sys.stdin.readline
  n = int(input())
  
  xl = []
  xr = []
  xc = []
  yt = []
  yb = []
  yc = []
  for i in range(n):
      x, y, d = input().split()
      x, y = int(x), int(y)
      if d == "R":
          xr.append(x)
          yc.append(y)
      elif d == "L":
          xl.append(x)
          yc.append(y)
      elif d == "U":
          xc.append(x)
          yt.append(y)
      else:
          xc.append(x)
          yb.append(y)
  xr.sort()
  xl.sort()
  xc.sort()
  yt.sort()
  yb.sort()
  yc.sort()
  
  # xの最小値
  xr_min = xr[0] if xr else None
  xl_min = xl[0] if xl else None
  xc_min = xc[0] if xc else None
  xmin = [xr_min, xl_min, xc_min]
  
  # xの最大値 最小化
  xr_max = xr[-1] if xr else None
  xl_max = xl[-1] if xl else None
  xc_max = xc[-1] if xc else None
  xmax = [xr_max, xl_max, xc_max]
  
  # 上に行く　最小化
  yt_max = yt[-1] if yt else None
  yb_max = yb[-1] if yb else None
  yc_max = yc[-1] if yc else None
  ymax = [yt_max, yb_max, yc_max]
  
  # 下に行く
  yt_min = yt[0] if yt else None
  yb_min = yb[0] if yb else None
  yc_min = yc[0] if yc else None
  ymin = [yt_min, yb_min, yc_min]
  
  
  def cross(p1, p2):
      ret = []
      if p1 is None or p2 is None:
          return ret
      sub = abs(p1 - p2)
      ret.append(sub)
      ret.append(sub / 2)
      ret.append(sub / 2 + 1)
      return ret
  
  
  def check(t, xmax, xmin, ymax, ymin):
      op = [+1, -1, 0]
      xmax_ = -float("inf")
      xmin_ = float("inf")
      ymax_ = -float("inf")
      ymin_ = float("inf")
      # xmax
      for i, x in enumerate(xmax):
          if x is not None:
              xmax_ = max(xmax_, x + t * op[i])
      # xmin
      for i, x in enumerate(xmin):
          if x is not None:
              xmin_ = min(xmin_, x + t * op[i])
      # ymax
      for i, y in enumerate(ymax):
          if y is not None:
              ymax_ = max(ymax_, y + t * op[i])
      # ymin
      for i, y in enumerate(ymin):
          if y is not None:
              ymin_ = min(ymin_, y + t * op[i])
      return (xmax_ - xmin_) * (ymax_ - ymin_)
  
  
  time_candidate = [0]
  
  for lis in [xmin, xmax, ymin, ymax]:
      for p1, p2 in combinations(lis, 2):
          time_candidate.extend(cross(p1, p2))
  
  ans = float("inf")
  for i in set(time_candidate):
      ans_tmp = check(i, xmax, xmin, ymax, ymin)
      ans = min(ans, check(i, xmax, xmin, ymax, ymin))
  print(ans)
  
problem_description: Statement
  
  There are N points in a two-dimensional plane. The initial coordinates of the
  i-th point are (x_i, y_i). Now, each point starts moving at a speed of 1 per
  second, in a direction parallel to the x\- or y\- axis. You are given a
  character d_i that represents the specific direction in which the i-th point
  moves, as follows:
  
    * If d_i = `R`, the i-th point moves in the positive x direction;
    * If d_i = `L`, the i-th point moves in the negative x direction;
    * If d_i = `U`, the i-th point moves in the positive y direction;
    * If d_i = `D`, the i-th point moves in the negative y direction.
  
  You can stop all the points at some moment of your choice after they start
  moving (including the moment they start moving). Then, let x_{max} and x_{min}
  be the maximum and minimum among the x-coordinates of the N points,
  respectively. Similarly, let y_{max} and y_{min} be the maximum and minimum
  among the y-coordinates of the N points, respectively.
  
  Find the minimum possible value of (x_{max} - x_{min}) \times (y_{max} -
  y_{min}) and print it.
samples: [{"input": "2\n    0 3 D\n    3 0 L", "output": "0\n    \n\nAfter three seconds, the two points will meet at the origin. The value in\nquestion will be 0 at that moment.\n\n* * *"}, {"input": "5\n    -7 -10 U\n    7 -6 U\n    -8 7 D\n    -3 3 D\n    0 -6 R", "output": "97.5\n    \n\nThe answer may not be an integer.\n\n* * *"}, {"input": "20\n    6 -10 R\n    -4 -9 U\n    9 6 D\n    -3 -2 R\n    0 7 D\n    4 5 D\n    10 -10 U\n    -1 -8 U\n    10 -6 D\n    8 -5 U\n    6 4 D\n    0 3 D\n    7 9 R\n    9 -4 R\n    3 10 D\n    1 9 U\n    1 -6 U\n    9 -8 R\n    6 7 D\n    7 -3 D", "output": "273"}]