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: # coding: utf-8
  # Your code here!
  
  import copy
  
  N = int(input())
  
  U = []
  D = []
  R = []
  L = []
  
  for _ in range(N):
      x, y, ori = input().rstrip().split(" ")
      x = int(x)
      y = int(y)
      if ori == "U":
          U.append([x, y])
      elif ori == "D":
          D.append([x, y])
      elif ori == "R":
          R.append([x, y])
      else:
          L.append([x, y])
  
  
  def calc(inc_points, dec_points, other_points, index):
      inc = []
      dec = []
      other = []
      if len(inc_points) > 0:
          inc_min = min([x[index] for x in inc_points])
          inc_max = max([x[index] for x in inc_points])
          inc = [inc_min, inc_max]
      if len(dec_points) > 0:
          dec_min = min([x[index] for x in dec_points])
          dec_max = max([x[index] for x in dec_points])
          dec = [dec_min, dec_max]
      if len(other_points) > 0:
          other_min = min([x[index] for x in other_points])
          other_max = max([x[index] for x in other_points])
          other = [other_min, other_max]
  
      cross_time = [0]
      if len(inc_points) > 0 and len(dec_points) > 0:
          for u in [inc_min, inc_max]:
              for d in [dec_min, dec_max]:
                  if u < d:  # collision
                      cross_time.append((d - u) / 2)
  
      if len(dec_points) > 0 and len(other_points) > 0:
          for rl in [other_min, other_max]:
              for d in [dec_min, dec_max]:
                  if rl < d:  # collision
                      cross_time.append(d - rl)
  
      if len(inc_points) > 0 and len(other_points) > 0:
          for rl in [other_min, other_max]:
              for u in [inc_min, inc_max]:
                  if u < rl:  # collision
                      cross_time.append(rl - u)
  
      return inc, dec, other, cross_time
  
  
  def calc_size(inc, dec, other, times):
      sizes = []
      for time in times:
          values = copy.copy(other)
          if len(inc) > 0:
              values.extend([x + time for x in inc])
          if len(dec) > 0:
              values.extend([x - time for x in dec])
          sizes.append(max(values) - min(values))
      return sizes
  
  
  inc_x, dec_x, other_x, cross_time_x = calc(R, L, U + D, 0)
  inc_y, dec_y, other_y, cross_time_y = calc(U, D, R + L, 1)
  
  times = list(set(cross_time_x + cross_time_y))
  sizes_x = calc_size(inc_x, dec_x, other_x, times)
  sizes_y = calc_size(inc_y, dec_y, other_y, times)
  
  print(min([x * y for x, y in zip(sizes_x, sizes_y)]))
  
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"}]