{
    Решение избранных задач
    © 2024 Слинкин Д.А., GNU LGPLv3

 **********************************************************************}

{$mode objfpc}
// поиск по фразе - построение выпуклого многоугольника
// +Алгоритм Джарвиса
// -Алгоритм Грэхема
type
    TPoint=record
        x,y:integer;
        inBound:integer; // номер в массиве границ
    end;

var a:array of TPoint; // массив точек
    bounds:array of integer; // массив границ (ссылки на точки)
    bstore:array of integer; // вспомогательный массив границ
    pull:string; // строка изымаемых гвоздей
    count, // кол-во точек
    bcount, // кол-во граничных точек
    i,minY,minX,maxY,maxX:integer;
    minCos,CurCos,sq:real;

// косинус угла между векторами main->first и main->second
function cospolar(main,first,second:tpoint):real;
 begin
    result:=((first.x-main.x)*(second.x-main.x)+(first.y-main.y)*(second.y-main.y))/
            (sqrt(sqr(first.x-main.x)+sqr(first.y-main.y))*sqrt(sqr(second.x-main.x)+sqr(second.y-main.y)));
 end;

// площадь треугольника по трем точкам
function square(pt1,pt2,pt3:TPoint):real;
 begin
    result:=abs((pt2.x-pt1.x)*(pt3.y-pt1.y)-(pt3.x-pt1.x)*(pt2.y-pt1.y))/2;
 end;

// генератор точки
function point(x,y:integer; inbound:integer=0):tpoint;
begin
    result.x:=x; result.y:=y; result.inbound:=inbound;
end;

var predPT:tpoint; // предпоследняя точка

    del:integer;

    first:boolean; // факт первого прохода по алгоритму Джарвиса
begin

 readln(count);
 setlength(a,count);
 setlength(bounds,count);

 minY:=0;
 for i:=0 to count-1 do begin
    readln(a[i].x,a[i].y);
    a[i].inBound:=-1;
 end;
 readln(pull);
{
Суть:
По алгоритму Джарвиса строим выпуклую оболочку, начиная снизу.
Алгоритм модифицирован, введено понятие фиктивной начальной точки, для оптимизации.
1) Находим самую нижнюю точку A1. Такая по условию будет только одна.
Заносим A1 в массив границ. НЕ ПОМЕЧАЕМ как граничную.
2) Создаем фиктивную точку слева от найденной A0. Теперь есть вектор A0->A1
3) Среди остальных точек ищем такую A2, что косинус между A0->A1 и A1->A2
максимальный, это будет следующая точка оболочки.
Заносим A2 в массив границ, помечаем как граничную.
В дальнейшем A0 - предпоследняя найденная точка, A1 - последняя найденная точка
4) Если очередная A2 равна начальной точке (п.1), оболочка построена, завершаем алгоритм
5) goto 3
}

// ++ 1
 minY:=0;
 for i:=0 to count-1 do begin
    if a[i].inBound>=0 then continue;
    if a[i].y<a[minY].y then minY:=i;
 end;
 bcount:=1;
 bounds[0]:=minY;
 a[minY].inBound:=0;
// -- 1

// ++ 2
 predpt:=a[bounds[0]];
 predpt.x-=1;
 first:=true;
// --2

while true do begin

 while true do begin
// ++ 3
    minCos:=2;
    for i:=0 to count-1 do begin
        if a[i].inBound>0 then continue;
        if (i=bounds[0]) and first then continue; // на первом проходе не проверять начальную точку, вектор нулевой
        curCos:=cospolar(a[bounds[bcount-1]],predPT,a[i]);
        if curCos<minCos then begin
            minCos:=curCos;
            bounds[bcount]:=i;
        end;
    end;
    first:=false;
// ++ 4
    if bounds[bcount]=bounds[0] then break;
// -- 4
    a[bounds[bcount]].inBound:=bcount;
    inc(bcount);
    predPT:=a[bounds[bcount-2]];
// -- 3
 end;

// теперь bounds содержит граничные точки

 if bcount<3 then break; // завершаем алгоритм, точек в фигуре меньше 3

// ищем и выводим площадь полученного многоугольника
 sq:=0;
 for i:=1 to bcount-2 do sq+=square(a[bounds[0]],a[bounds[i]],a[bounds[i+1]]);
 writeln(sq:0:1);

// ищем в bounds четыре граничные точки
 minY:=0; minX:=0; maxY:=0; maxX:=0;
 for i:=1 to bcount-1 do begin
    if a[bounds[i]].x<a[bounds[minX]].x then minX:=i;
    if a[bounds[i]].y<a[bounds[minY]].y then minY:=i;
    if a[bounds[i]].x>a[bounds[maxX]].x then maxX:=i;
    if a[bounds[i]].y>a[bounds[maxY]].y then maxY:=i;
 end;

// выбираем, какую из них будем удалять
 case pull[1] of
    'U':del:=maxY;
    'D':del:=minY;
    'L':del:=minX;
    'R':del:=maxX;
 end;
 delete(pull,1,1);

// переносим все граничные точки в массиве bcount так
// удаляемая оказалась последней и удаляем ее
 setlength(bstore,del);
 move(bounds[0],bstore[0],del*sizeof(integer));
 move(bounds[del+1],bounds[0],(bcount-del-1)*sizeof(integer));
 move(bstore[0],bounds[bcount-del-1],del*sizeof(integer));
 dec(bcount);
// перенумеровываем точки в соответствии с их новыми местами в bounds
 for i:=0 to bcount-1 do a[bounds[i]].inBound:=i;
// предпоследняя и последняя точка в bounds - начальный вектор
 predPT:=a[bounds[bcount-2]];
// возвращаемся к началу построения для формирования недостающего участка границы
end;

end.