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: Accepted)

#include<bits/stdc++.h>
//ios::sync_with_stdio(false);
//cin.tie(0);
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<pii,int> ppii;
typedef pair<int,pii> pipi;
typedef pair<ll,ll> pll;
typedef pair<pll,ll> ppll;
typedef pair<ll,pll> plpl;
typedef tuple<ll,ll,ll> tl;
ll mod=1000000007;
ll mod2=998244353;
ll inf=1000000000000000000;
double pi=2*acos(0);
#define rep(i,m,n) for(int i=m;i<n;i++)
#define rrep(i,n,m) for(int i=n;i>=m;i--)
int dh[4]={1,-1,0,0};
int dw[4]={0,0,1,-1};
int ddh[8]={-1,-1,-1,0,0,1,1,1};
int ddw[8]={-1,0,1,-1,1,-1,0,1};
ll lmax(ll a,ll b){
    if(a<b)return b;
    else return a;
}
ll lmin(ll a,ll b){
    if(a<b)return a;
    else return b;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll n;cin>>n;
    ll x[n],y[n];
    char d[n];
    rep(i,0,n)cin>>x[i]>>y[i]>>d[i];
    vector<ll> v[4];
    int num=-1;
    ll ma=-1000000000000;
    rep(i,0,n){
        if(d[i]=='R'&&x[i]>ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[0].push_back(num);
    num=-1;
    ma=-1000000000000;
    rep(i,0,n){
        if(d[i]=='L'&&x[i]>ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[0].push_back(num);
    num=-1;
    ma=-1000000000000;
    rep(i,0,n){
        if((d[i]=='U'||d[i]=='D')&&x[i]>ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[0].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if(d[i]=='R'&&x[i]<ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[1].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if(d[i]=='L'&&x[i]<ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[1].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if((d[i]=='U'||d[i]=='D')&&x[i]<ma){
            ma=x[i];
            num=i;
        }
    }
    if(num!=-1)v[1].push_back(num);
    num=-1;
    ma=-1000000000000;
    rep(i,0,n){
        if(d[i]=='U'&&y[i]>ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[2].push_back(num);
    num=-1;
    ma=-1000000000000;
    rep(i,0,n){
        if(d[i]=='D'&&y[i]>ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[2].push_back(num);
    num=-1;
    ma=-1000000000000;
    rep(i,0,n){
        if((d[i]=='L'||d[i]=='R')&&y[i]>ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[2].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if(d[i]=='U'&&y[i]<ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[3].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if(d[i]=='D'&&y[i]<ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[3].push_back(num);
    num=-1;
    ma=1000000000000;
    rep(i,0,n){
        if((d[i]=='R'||d[i]=='L')&&y[i]<ma){
            ma=y[i];
            num=i;
        }
    }
    if(num!=-1)v[3].push_back(num);
    vector<double> w;
    w.push_back(0);
    rep(i,0,4){
        rep(j,0,v[i].size()-1){
            rep(k,j+1,v[i].size()){
                if(i<=1){
                    ll f=x[v[i][j]],g=x[v[i][k]];
                    if(d[v[i][j]]=='R'){
                        if(d[v[i][k]]=='L'){
                            if(g>f)w.push_back((g-f)/2.0);
                        }
                        else{
                            if(g>f)w.push_back(g-f);
                        }
                    }
                    else{
                        if(g<f)w.push_back(f-g);
                    }
                }
                else{
                    ll f=y[v[i][j]],g=y[v[i][k]];
                    if(d[v[i][j]]=='U'){
                        if(d[v[i][k]]=='D'){
                            if(g>f)w.push_back((g-f)/2.0);
                        }
                        else{
                            if(g>f)w.push_back(g-f);
                        }
                    }
                    else{
                        if(g<f)w.push_back(f-g);
                    }
                }
            }
        }
    }
    double ans=40000000000000000;
    rep(i,0,w.size()){
        double xma=-1000000000,xmi=1000000000,yma=-1000000000,ymi=1000000000;
        rep(j,0,v[0].size()){
            double h=x[v[0][j]];
            if(d[v[0][j]]=='R')h+=w[i];
            if(d[v[0][j]]=='L')h-=w[i];
            xma=max(xma,h);
        }
        rep(j,0,v[1].size()){
            double h=x[v[1][j]];
            if(d[v[1][j]]=='R')h+=w[i];
            if(d[v[1][j]]=='L')h-=w[i];
            xmi=min(xmi,h);
        }
        rep(j,0,v[2].size()){
            double h=y[v[2][j]];
            if(d[v[2][j]]=='U')h+=w[i];
            if(d[v[2][j]]=='D')h-=w[i];
            yma=max(yma,h);
        }
        rep(j,0,v[3].size()){
            double h=y[v[3][j]];
            if(d[v[3][j]]=='U')h+=w[i];
            if(d[v[3][j]]=='D')h-=w[i];
            ymi=min(ymi,h);
        }
        ans=min(ans,(xma-xmi)*(yma-ymi));
    }
    cout<<fixed<<setprecision(12)<<ans<<endl;
}