Problem:
Score : 600 points

Problem 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.

Constraints

1 \leq N \leq 10^5

-10^8 \leq x_i,\ y_i \leq 10^8

x_i and y_i are integers.

d_i is R, L, U, or D.

Input

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

Output

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}.

Sample Input 1

2
0 3 D
3 0 L

Sample Output 1

0

After three seconds, the two points will meet at the origin. The value in question will be 0 at that moment.

Sample Input 2

5
-7 -10 U
7 -6 U
-8 7 D
-3 3 D
0 -6 R

Sample Output 2

97.5

The answer may not be an integer.

Sample Input 3

20
6 -10 R
-4 -9 U
9 6 D
-3 -2 R
0 7 D
4 5 D
10 -10 U
-1 -8 U
10 -6 D
8 -5 U
6 4 D
0 3 D
7 9 R
9 -4 R
3 10 D
1 9 U
1 -6 U
9 -8 R
6 7 D
7 -3 D

Sample Output 3

273

Solution in LuaJIT (2.0.4) (judge verdict: Accepted)

local mce, mfl, msq, mmi, mma = math.ceil, math.floor, math.sqrt, math.min, math.max
local n = io.read("*n", "*l")
-- local left, right, up, down = {}, {}, {}, {}
local cxmin, cxmax, cymin, cymax = nil, nil, nil, nil
local xinc_max, xinc_min, xdec_max, xdec_min = nil, nil, nil, nil
local str = ""
for i = 1, n do
  str = io.read()
  local x, y, d = str:match("(-?%d+) (-?%d+) (%w)")
  x, y = tonumber(x), tonumber(y)
  -- print(x, y, d)
  if d == "R" then
    if not cymin then
      cymin, cymax = y, y
    else
      cymin, cymax = mmi(cymin, y), mma(cymax, y)
    end
    if not xinc_min then
      xinc_min, xinc_max = x, x
    else
      xinc_min, xinc_max =mmi(xinc_min, x), mma(xinc_max, x)
    end
  elseif d == "L" then
    if not cymin then
      cymin, cymax = y, y
    else
      cymin, cymax = mmi(cymin, y), mma(cymax, y)
    end
    if not xdec_min then
      xdec_min, xdec_max = x, x
    else
      xdec_min, xdec_max =mmi(xdec_min, x), mma(xdec_max, x)
    end
  elseif d == "U" then
    if not cxmin then
      cxmin, cxmax = x, x
    else
      cxmin, cxmax = mmi(cxmin, x), mma(cxmax, x)
    end
    if not yinc_min then
      yinc_min, yinc_max = y, y
    else
      yinc_min, yinc_max =mmi(yinc_min, y), mma(yinc_max, y)
    end
  else
    if not cxmin then
      cxmin, cxmax = x, x
    else
      cxmin, cxmax = mmi(cxmin, x), mma(cxmax, x)
    end
    if not ydec_min then
      ydec_min, ydec_max = y, y
    else
      ydec_min, ydec_max =mmi(ydec_min, y), mma(ydec_max, y)
    end
  end
end
-- print(xinc_min, xinc_max, xdec_min, xdec_max)
-- print(yinc_min, yinc_max, ydec_min, ydec_max)
-- print(cxmin, cxmax, cymin, cymax)

local candidate_t = {0}
if xinc_min then
  if xdec_min then
    if xinc_min < xdec_min then
      table.insert(candidate_t, (xdec_min - xinc_min) / 2)
    end
    if xinc_min < xdec_max then
      table.insert(candidate_t, (xdec_max - xinc_min) / 2)
    end
    if xinc_max < xdec_min then
      table.insert(candidate_t, (xdec_min - xinc_max) / 2)
    end
    if xinc_max < xdec_max then
      table.insert(candidate_t, (xdec_max - xinc_max) / 2)
    end
  end
  if cxmin then
    if xinc_min < cxmin then
      table.insert(candidate_t, cxmin - xinc_min)
    end
    if xinc_min < cxmax then
      table.insert(candidate_t, cxmax - xinc_min)
    end
    if xinc_max < cxmin then
      table.insert(candidate_t, cxmin - xinc_max)
    end
    if xinc_max < cxmax then
      table.insert(candidate_t, cxmax - xinc_max)
    end
  end
end
if xdec_min then
  if cxmin then
    if xdec_min > cxmin then
      table.insert(candidate_t, -cxmin + xdec_min)
    end
    if xdec_min > cxmax then
      table.insert(candidate_t, -cxmax + xdec_min)
    end
    if xdec_max > cxmin then
      table.insert(candidate_t, -cxmin + xdec_max)
    end
    if xdec_max > cxmax then
      table.insert(candidate_t, -cxmax + xdec_max)
    end
  end
end
-- y
if yinc_min then
  if ydec_min then
    if yinc_min < ydec_min then
      table.insert(candidate_t, (ydec_min - yinc_min) / 2)
    end
    if yinc_min < ydec_max then
      table.insert(candidate_t, (ydec_max - yinc_min) / 2)
    end
    if yinc_max < ydec_min then
      table.insert(candidate_t, (ydec_min - yinc_max) / 2)
    end
    if yinc_max < ydec_max then
      table.insert(candidate_t, (ydec_max - yinc_max) / 2)
    end
  end
  if cymin then
    if yinc_min < cymin then
      table.insert(candidate_t, cymin - yinc_min)
    end
    if yinc_min < cymax then
      table.insert(candidate_t, cymax - yinc_min)
    end
    if yinc_max < cymin then
      table.insert(candidate_t, cymin - yinc_max)
    end
    if yinc_max < cymax then
      table.insert(candidate_t, cymax - yinc_max)
    end
  end
end
if ydec_min then
  if cymin then
    if ydec_min > cymin then
      table.insert(candidate_t, -cymin + ydec_min)
    end
    if ydec_min > cymax then
      table.insert(candidate_t, -cymax + ydec_min)
    end
    if ydec_max > cymin then
      table.insert(candidate_t, -cymin + ydec_max)
    end
    if ydec_max > cymax then
      table.insert(candidate_t, -cymax + ydec_max)
    end
  end
end

local ret = nil
for i = 1, #candidate_t do
  local time = candidate_t[i]
  local qxmin, qxmax = nil, nil
  local qymin, qymax = nil, nil
  if xdec_min then
    if not qxmin then qxmin, qxmax = xdec_min - time, xdec_max - time
    else qxmin, qxmax = mmi(qxmin, xdec_min - time), mma(qxmax, xdec_max - time)
    end
  end
  if xinc_min then
    if not qxmin then qxmin, qxmax = xinc_min + time, xinc_max + time
    else qxmin, qxmax = mmi(qxmin, xinc_min + time), mma(qxmax, xinc_max + time)
    end
  end
  if cxmin then
    if not qxmin then qxmin, qxmax = cxmin, cxmax
    else qxmin, qxmax = mmi(qxmin, cxmin), mma(qxmax, cxmax)
    end
  end

  if ydec_min then
    if not qymin then qymin, qymax = ydec_min - time, ydec_max - time
    else qymin, qymax = mmi(qymin, ydec_min - time), mma(qymax, ydec_max - time)
    end
  end
  if yinc_min then
    if not qymin then qymin, qymax = yinc_min + time, yinc_max + time
    else qymin, qymax = mmi(qymin, yinc_min + time), mma(qymax, yinc_max + time)
    end
  end
  if cymin then
    if not qymin then qymin, qymax = cymin, cymax
    else qymin, qymax = mmi(qymin, cymin), mma(qymax, cymax)
    end
  end
  local tmp = 0
  if qxmin and qymin then
    tmp = (qxmax - qxmin) * (qymax - qymin)
  else
    tmp = 0
  end
  -- print(time, tmp)
  if not ret then ret = tmp
  else ret = mmi(ret, tmp)
  end
end
print(ret)