解题思路

要找到由给定点构成的最大面积三角形，最直观的方法是枚举所有可能的三点组合，计算其面积，然后找出最大值。然而，这种方法的时间复杂度是O($n$^$3$)，当$n$=$50000$时，这显然是不可行的。

因此，我们需要一个更高效的算法。观察到最大面积的三角形的顶点一定位于这些点的凸包上。因为如果有一个点不在凸包上，那么可以用凸包上的点替换它，从而得到一个更大的面积。因此，我们可以先计算这些点的凸包，然后在凸包的顶点上寻找最大面积的三角形。

计算凸包的时间复杂度是O($n$ log $n$)，而凸包上的点数通常远小于$n$。假设凸包上有$h$个点，那么枚举所有三点组合的时间复杂度是O($h$^$3$)。如果$h$很小，这是可行的。但对于较大的$h$（例如$h$=$50000$），这仍然不可行。

进一步优化，可以使用旋转卡壳法（Rotating Calipers）来找到凸包上构成最大面积三角形的三个点。这种方法可以将时间复杂度降低到O($h$^$2$)或更好。

解题方法

计算凸包：使用Andrew算法或Graham扫描算法计算给定点的凸包。Andrew算法通常更容易实现且效率较高。

寻找最大面积三角形：在凸包的顶点上，使用旋转卡壳法或三重循环（如果$h$较小）来找到最大面积的三角形。

C++代码实现：

#include <cmath>
#include <algorithm>
#include <cstdio>
#include <vector>
#define LL long long
using namespace std;

const LL Maxn = 50010;
struct point {
    LL x, y;
    point() {}
    point(LL _x, LL _y) : x(_x), y(_y) {}
    point operator-(const point &Other) const {
        return point(x - Other.x, y - Other.y);
    }
    LL operator*(const point &Other) const {
        return x * Other.y - y * Other.x;
    }
    LL Dis() const { return x * x + y * y; }
};

LL N;
vector<point> A, B;

bool Cmp(const point &X, const point &Y) {
    point ref = A[0];
    LL cross = (X - ref) * (Y - ref);
    if (cross != 0) return cross > 0;
    return (X - ref).Dis() < (Y - ref).Dis();
}

void compute_convex_hull() {
    if (A.size() < 3) {
        B = A;
        return;
    }
    B.clear();
    for (LL i = 0; i < A.size(); ++i) {
        while (B.size() >= 2 && 
               (A[i] - B[B.size()-2]) * (B.back() - B[B.size()-2]) >= 0) {
            B.pop_back();
        }
        B.push_back(A[i]);
    }
}

LL rotating_calipers() {
    if (B.size() < 3) return 0;
    LL max_area = 0;
    for (LL i = 0; i < B.size(); ++i) {
        LL k = (i + 2) % B.size();
        for (LL j = (i + 1) % B.size(); j != i; j = (j + 1) % B.size()) {
            while (true) {
                LL next_k = (k + 1) % B.size();
                LL curr_area = abs((B[j] - B[i]) * (B[k] - B[i]));
                LL next_area = abs((B[j] - B[i]) * (B[next_k] - B[i]));
                if (next_area <= curr_area) break;
                k = next_k;
            }
            LL area = abs((B[j] - B[i]) * (B[k] - B[i]));
            if (area > max_area) max_area = area;
        }
    }
    return max_area;
}

int main() {
    while (scanf("%lld", &N) == 1 && N != -1) {
        A.resize(N);
        for (LL i = 0; i < N; ++i) {
            scanf("%lld%lld", &A[i].x, &A[i].y);
        }
        if (N < 3) {
            printf("0.00\n");
            continue;
        }
        // Find the lowest leftmost point
        LL min_idx = 0;
        for (LL i = 1; i < N; ++i) {
            if (A[i].y < A[min_idx].y || 
                (A[i].y == A[min_idx].y && A[i].x < A[min_idx].x)) {
                min_idx = i;
            }
        }
        swap(A[0], A[min_idx]);
        sort(A.begin() + 1, A.end(), Cmp);
        compute_convex_hull();
        LL max_area = rotating_calipers();
        printf("%.2lf\n", max_area / 2.0);
    }
    return 0;
}