Păcală a primit, aşa cum era învoiala, un petec de teren de pe moşia boierului. Terenul este împrejmuit complet cu segmente drepte de gard ce se sprijină la ambele capete de câte un par zdravăn. La o nouă prinsoare, Păcală iese iar in câştig şi primeşte dreptul să strămute nişte pari, unul câte unul, cum i-o fi voia, astfel încât să-şi extindă suprafaţa de teren. Dar învoiala prevede că fiecare par poate fi mutat în orice direcţie, dar nu pe o distanţă mai mare decât o valoare dată (scrisă pe fiecare par) şi fiecare segment de gard, fiind cam şubred, poate fi rotit şi prelungit de la un singur capăt, celălalt rămânând nemişcat.

Cerința

Cunoscând poziţiile iniţiale ale parilor şi valoarea înscrisă pe fiecare par, se cere suprafaţa maximă cu care poate să-şi extindă Păcală proprietatea. Se ştie că parii sunt daţi într-o ordine oarecare, poziţiile lor iniţiale sunt date prin numere întregi de cel mult 3 cifre, distanțele pe care fiecare par poate fi deplasat sunt numere naturale strict pozitive şi figura formată de terenul iniţial este un poligon neconcav.

Date de intrare

Fișierul de intrare mosia1.in conţine n+1 linii cu următoarele valori:

Exemplu

mosia1.in

4
-3 0 2
3 0 3
0 6 2
0 -6 6

mosia1.out

30.0000

Explicație

Prin mutarea parilor 1 si 2 cu câte 2 și respectiv 3 unități, se obține un teren având suprafaţa cu 30 de unităţi mai mare decât terenul iniţial.

#include <bits/stdc++.h>



using namespace std;

ifstream cin("mosia1.in");
ofstream cout("mosia1.out");

struct punct
{
    int x, y, d;
}v[1003];
double d1[1003] , d2[1003] , X , Y;
int n;

bool comp(punct a, punct b)
{
    return atan2(a.y - Y , a.x - X) < atan2(b.y - Y , b.x - X);
}

double dist(punct a, punct b)
{
    int dx = a.x - b.x , dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        cin >> v[i].x >> v[i].y >> v[i].d;
        X += v[i].x;
        Y += v[i].y;
    }

    X /= n;
    Y /= n;
    sort(v + 1, v + n + 1, comp);

    v[0] = v[n];
    v[n + 1] = v[1];

    for (int i = 1; i <= n; ++i)
        d1[i] = d2[i] = v[i].d * dist(v[i - 1], v[i + 1]) / 2;

    d1[n] = d2[1] = 0;

    for(int i = 2 ; i <= n ; ++i)
    {
        d1[i] = max(d1[i - 1], d1[i] + d1[i - 2]);
        d2[i] = max(d2[i - 1], d2[i] + d2[i - 2]);
    }

    cout << fixed << setprecision(4) << max(d1[n], d2[n]);

    return 0;

}