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: def main():
      R_edge, L_edge, U_edge, D_edge = [None] * 3, [None] * 3, [None] * 3, [None] * 3
      n = int(input())
      xyd = [input().split() for _ in [0] * n]
      xyd = [(int(x), int(y), d) for x, y, d in xyd]
      for x, y, d in xyd:
          if d in ["R", "L"]:
              if U_edge[1] is None:
                  U_edge[1] = y
              else:
                  U_edge[1] = max(U_edge[1], y)
              if D_edge[1] is None:
                  D_edge[1] = y
              else:
                  D_edge[1] = min(D_edge[1], y)
          else:
              if R_edge[1] is None:
                  R_edge[1] = x
              else:
                  R_edge[1] = max(R_edge[1], x)
              if L_edge[1] is None:
                  L_edge[1] = x
              else:
                  L_edge[1] = min(L_edge[1], x)
          for p, q, r in [
              [R_edge, "R", x],
              [L_edge, "L", x],
              [U_edge, "U", y],
              [D_edge, "D", y],
          ]:
              if d == q:
                  if p[0] is None:
                      p[0] = r
                      p[2] = r
                  else:
                      p[0] = min(p[0], r)
                      p[2] = max(p[2], r)
  
      def area(t):
          RL, UD = [], []
          if R_edge[0] is not None:
              RL += [t + R_edge[0], t + R_edge[2]]
          if R_edge[1] is not None:
              RL += [R_edge[1]]
          if L_edge[0] is not None:
              RL += [-t + L_edge[0], -t + L_edge[2]]
          if L_edge[1] is not None:
              RL += [L_edge[1]]
          if U_edge[0] is not None:
              UD += [t + U_edge[0], t + U_edge[2]]
          if U_edge[1] is not None:
              UD += [U_edge[1]]
          if D_edge[0] is not None:
              UD += [-t + D_edge[0], -t + D_edge[2]]
          if D_edge[1] is not None:
              UD += [D_edge[1]]
          if len(RL) * len(UD) == 0:
              return 0
          else:
              return (max(RL) - min(RL)) * (max(UD) - min(UD))
  
      t = [0]
      for edge in [R_edge, L_edge, U_edge, D_edge]:
          if None not in edge:
              t.append(abs(edge[1] - edge[0]))
              t.append(abs(edge[1] - edge[2]))
      for edge1, edge2 in [[R_edge, L_edge], [U_edge, D_edge]]:
          if None not in [edge1[1], edge2[0]]:
              t.append(abs(edge1[1] - edge2[0]))
              t.append(abs(edge1[1] - edge2[2]))
          if None not in [edge2[1], edge1[0]]:
              t.append(abs(edge2[1] - edge1[0]))
              t.append(abs(edge2[1] - edge1[2]))
          if None not in [edge1[0], edge2[0]]:
              for i in [0, 2]:
                  for j in [0, 2]:
                      t.append(abs(edge2[i] - edge1[j]) / 2)
  
      print(min([area(i) for i in t]))
  
  
  main()
  
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"}]