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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.ABC_130
{
    class F
    {
        static void Main(string[] args)
        {
            Method(args);
        }

        static void Method(string[] args)
        {
            int n = ReadInt();
            long[][] xys = new long[n][];
            char[] dirs = new char[n];
            for(int i = 0; i < n; i++)
            {
                string[] ss = Read().Split();
                xys[i] = new long[2] { int.Parse(ss[0]), int.Parse(ss[1]) };
                dirs[i] = ss[2][0];
            }

            List<long>[] poses = new List<long>[6];
            for (int i = 0; i < 6; i++) poses[i] = new List<long>();
            for(int i = 0; i < n; i++)
            {
                switch (dirs[i])
                {
                    case 'L':
                        poses[0].Add(xys[i][0]);
                        poses[5].Add(xys[i][1]);
                        break;
                    case 'R':
                        poses[1].Add(xys[i][0]);
                        poses[5].Add(xys[i][1]);
                        break;
                    case 'U':
                        poses[4].Add(xys[i][1]);
                        poses[2].Add(xys[i][0]);
                        break;
                    case 'D':
                        poses[3].Add(xys[i][1]);
                        poses[2].Add(xys[i][0]);
                        break;
                }
            }
            for(int i = 0; i < 6; i++)
            {
                poses[i].Sort();
            }
            List<double> times = new List<double>();
            times.Add(0);
            for (int i = 0; i < 6; i += 3) {
                if (poses[i].Count > 0 && poses[i + 1].Count > 0)
                {
                    if (poses[i][poses[i].Count - 1] 
                        > poses[i + 1][poses[i+1].Count-1])
                    {
                        times.Add((poses[i][poses[i].Count - 1]
                            - poses[i + 1][poses[i + 1].Count - 1]) * 0.5);
                    }
                    if (poses[i][0] > poses[i+1][0])
                    {
                        times.Add((poses[i][0]
                            - poses[i + 1][0]) * 0.5);
                    }
                }
                if (poses[i].Count > 0 && poses[i + 2].Count > 0)
                {
                    if (poses[i][poses[i].Count - 1]
                        > poses[i + 2][poses[i + 2].Count - 1])
                    {
                        times.Add(poses[i][poses[i].Count - 1]
                            - poses[i + 2][poses[i + 2].Count - 1]);
                    }
                    if (poses[i][0] > poses[i + 2][0])
                    {
                        times.Add(poses[i][0] - poses[i + 2][0]);
                    }
                }
                if (poses[i + 1].Count > 0 && poses[i + 2].Count > 0)
                {
                    if(poses[i+1][poses[i+1].Count-1]
                        < poses[i + 2][poses[i + 2].Count - 1])
                    {
                        times.Add(poses[i + 2][poses[i + 2].Count - 1]
                            - poses[i + 1][poses[i + 1].Count - 1]);
                    }
                    if (poses[i + 1][0] < poses[i + 2][0])
                    {
                        times.Add(poses[i + 2][0] - poses[i + 1][0]);
                    }
                }
            }
            double res = long.MaxValue;
            for(int i = 0; i < times.Count; i++)
            {
                double tmp = 1;
                for(int j = 0; j < 6; j += 3)
                {
                    double min = long.MaxValue;
                    double max = long.MinValue;
                    if (poses[j].Count > 0)
                    {
                        min = Min(min,poses[j][0] - times[i]);
                        max = Max(max,
                            poses[j][poses[j].Count - 1] - times[i]);
                    }
                    if (poses[j+1].Count > 0)
                    {
                        min = Min(min, poses[j+1][0] + times[i]);
                        max = Max(max,
                            poses[j+1][poses[j+1].Count - 1] + times[i]);
                    }
                    if (poses[j+2].Count > 0)
                    {
                        min = Min(min, poses[j+2][0]);
                        max = Max(max, poses[j+2][poses[j+2].Count - 1]);
                    }
                    tmp *= (max - min);
                }
                res = Min(res, tmp);
            }

            var sw = new System.IO.StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);

            // Write output here
            WriteLine(res);

            Out.Flush();
        }

        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}