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++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define VV vector
#define pb push_back
#define bitc  __builtin_popcountl
#define m_p make_pair
#define inf 1000000000000000000ll
#define MAXN 1000001
#define eps 0.0000000001
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);
string char_to_str(char c){string tem(1,c);return tem;}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template<class T>//usage rand<long long>()
T rand() {
    return uniform_int_distribution<T>()(rng);
}

// string to integer stuuu()
// string to long long stoll()
// string.substr(position,length);
// integer to string to_string();

//////////////

#define S second
#define F first
#define int long long  

vector<pair<long double,long double>> L;
vector<pair<long double,long double>> R;
vector<pair<long double,long double>> U;
vector<pair<long double,long double>> D;
long double cal(long double ti)
{
	long double xmi=10000000,xma=-10000000,ymi=100000000,yma=-100000000;
	for(int i=0;i<L.size();++i){
		pair<long double,long double> p;
		p={L[i].F-ti,L[i].S};
		
		{
			xmi=min(xmi,p.F);
			xma=max(xma,p.F);
			ymi=min(ymi,p.S);
			yma=max(yma,p.S);
		}
	}
	for(int i=0;i<R.size();++i){
		pair<long double,long double> p;
		p={R[i].F+ti,R[i].S};
		
		{
			xmi=min(xmi,p.F);
			xma=max(xma,p.F);
			ymi=min(ymi,p.S);
			yma=max(yma,p.S);
		}
	}for(int i=0;i<U.size();++i){
		pair<long double,long double> p;
		p={U[i].F,U[i].S+ti};
		
		{
			xmi=min(xmi,p.F);
			xma=max(xma,p.F);
			ymi=min(ymi,p.S);
			yma=max(yma,p.S);
		}
	}for(int i=0;i<D.size();++i){
		pair<long double,long double> p;
		p={D[i].F,D[i].S-ti};
		
		{
			xmi=min(xmi,p.F);
			xma=max(xma,p.F);
			ymi=min(ymi,p.S);
			yma=max(yma,p.S);
		}
	}
	// cout<<xma<<" "<<xmi<<" "<<yma<<" "<<ymi<<"\n";
	return (xma-xmi)*(yma-ymi);
}
signed main()
{
	fastio;
	#ifdef ANIKET_GOYAL
		freopen("inputf.in","r",stdin);
		freopen("outputf.in","w",stdout);
	#endif
	int n;
	cin>>n;
	int v=0;
	long double xmi,xma,ymi,yma;
	for(int i=0;i<n;++i)
	{
		pair<long double,long double> p;
		char c;
		cin>>p.F>>p.S;
		cin>>c;
		if(i==0)
		{
			xmi=p.F;
			xma=xmi;
			ymi=p.S;
			yma=p.S;
		}
		else
		{
			xmi=min(xmi,p.F);
			xma=max(xma,p.F);
			ymi=min(ymi,p.S);
			yma=max(yma,p.S);
		}
		if(c=='L')
		{
			L.push_back(p);
		}
		if(c=='U')
			U.push_back(p);
		if(c=='D')
			D.push_back(p);
		if(c=='R')
			R.push_back(p);
	}
	long double l=0.000000000001;
	long double r=10000000000000;
	while(r-l>0.0000000001)
	{
		long double m=(l+r)/2;
		if(cal(m+0.000000000001)>=cal(m))
		{
			r=m;
		}
		else{
			l=m;
		}
	}
	// cout<<l<<"\n";
	cout<<fixed<<setprecision(10)<<cal(l);
}