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 Ruby (2.3.3) (judge verdict: Accepted)

class P2
  attr_reader :a, :b, :c

  def initialize(a,b,c)
    @a = a || 0; @b = b || 0; @c = c || 0
  end

  def f(t)
    @a*t*t + @b*t + @c
  end

  def df(t)
    2*@a*t + @b
  end

  def stationary
    @a == 0 ? nil : -@b.to_f/@a/2
  end

  def min(t1,t2)
    vs = [f(t1),f(t2)]
    ts = stationary
    if ts && t1 <= ts && ts <= t2
      vs << f(ts)
    end
    vs.min
  end
end

class P1
  attr_reader :a, :b
  def initialize(a,b)
    @a = a || 0; @b = b || 0
  end

  def f(t)
    @a*t+@b
  end

  def df(t)
    @a
  end

  def self.add(p1,p2)
    self.new(p1.a + p2.a, p1.b + p2.b)
  end

  def self.sub(p1,p2)
    self.new(p1.a - p2.a, p1.b - p2.b)
  end

  def self.prod(p1,p2)
    P2.new(p1.a*p2.a, p1.a*p2.b + p2.a*p1.b, p1.b*p2.b)
  end

  def zero_cross
    @a == 0 ? nil : -@b.to_f/@a
  end
end


N = gets.to_i
XYD = (0...N).map{ gets.split }.transpose
XS = XYD[0].map &:to_i
YS = XYD[1].map &:to_i
DS = XYD[2]

Xmax = {}
Ymax = {} 
Xmin = {}
Ymin = {} 

["L","R","U","D"].each{ |d|
  is = (0...N).select{ |i| DS[i] == d }
  xs = is.map{ |i| XS[i] }
  ys = is.map{ |i| YS[i] }
  Xmax[d] = xs.max; Xmin[d] = xs.min
  Ymax[d] = ys.max; Ymin[d] = ys.min
}

#p Xmin, Xmax, Ymin, Ymax

XUDmin = [Xmin["U"], Xmin["D"]].compact.min
XUDmax = [Xmax["U"], Xmax["D"]].compact.max
YLRmin = [Ymin["L"], Ymin["R"]].compact.min
YLRmax = [Ymax["L"], Ymax["R"]].compact.max

PXmin = []
PXmin << P1.new(0, -XUDmin) if XUDmin
PXmin << P1.new(-1, -Xmin["R"]) if Xmin["R"]
PXmin << P1.new(+1, -Xmin["L"]) if Xmin["L"]
PXmax = []
PXmax << P1.new(0, XUDmax) if XUDmax
PXmax << P1.new(+1, +Xmax["R"]) if Xmax["R"]
PXmax << P1.new(-1, +Xmax["L"]) if Xmax["L"]
PYmin = []
PYmin << P1.new(0, -YLRmin) if YLRmin
PYmin << P1.new(-1, -Ymin["U"]) if Ymin["U"]
PYmin << P1.new(+1, -Ymin["D"]) if Ymin["D"]
PYmax = []
PYmax << P1.new(0, YLRmax) if YLRmax
PYmax << P1.new(+1, +Ymax["U"]) if Ymax["U"]
PYmax << P1.new(-1, +Ymax["D"]) if Ymax["D"]

InterestTimes = {}
InterestTimes[0.0] = InterestTimes[1e10] = 1
[PXmin, PXmax, PYmin, PYmax].each{ |ps|
  (0...ps.size).each{ |i|
    (i+1...ps.size).each{ |j|
      t = P1.sub(ps[i], ps[j]).zero_cross
      if t && t > 0
        #p [ps[i],ps[j],t]
        InterestTimes[t] = 1
      end
    }
  }
}

ITS = InterestTimes.keys.sort
#p ITS
p (0...ITS.size-1).map{ |i|
  t1 = ITS[i]; t2 = ITS[i+1]
  ps = [PXmin, PXmax, PYmin, PYmax].map{ |ps|
    ps.sort_by{ |p| p.f((t1+t2)/2) }.last
  }
  px = P1.add(ps[1], ps[0])
  py = P1.add(ps[3], ps[2])
  p2 = P1.prod(px,py)
  #p ps, px, py, p2, p2.zero, p2.min(t1,t2)
  p2.min(t1,t2)
}.min