hdu 6219 Empty Convex Polygons (凸包)

给你n个点，求面积最大的凸多边形，使得这个凸多边形没有内点。

考虑求凸包的graham算法，需要找到左下角的点，再进行极角排序后按顺序扫点，所以先枚举左下角的点。

这个过程中，如果遇到内点，就需要把这个内点排除掉，而现在需要把在外的点排除掉。

因为不确定凸包的边界，需要dp处理，一开始是一个三角线的两条边作为边界，然后不断枚举可能的边界进行扩展，同时保证不能包含内点。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include <set>
#include <queue>
#define ll long long
#define ld long double
#define lson l,m,rt<<1
#define pi acos(-1)
#define rson m+1,r,rt<<1|1
#define fo(i,l,r) for(int i = l;i <= r;i++)
#define fd(i,l,r) for(int i = r;i >= l;i--)
#define mem(x) memset(x,0,sizeof(x))
#define eps 3e-11
using namespace std;
const int maxn = ;
const ll inf = 1e9;
const ll mod = ;
ll read() {
    ll x=,f=;
    char ch=getchar();
    while(!(ch>=''&&ch<='')) {
        if(ch=='-')f=-;
        ch=getchar();
    };
    while(ch>=''&&ch<='') {
        x=x*+(ch-'');
        ch=getchar();
    };
    return x*f;
}
int sgn(double x){
    if(fabs(x)<eps)return ;
    if(x<)return -;
    return ;
}
struct Point{
    int id;
    double x,y;
    Point(){
    }
    Point(double _x,double _y){
        x=_x;
        y=_y;
    }
    friend bool operator < (Point a,Point b) {
        return sgn(a.x-b.x)==?sgn(a.y-b.y)<:a.x<b.x;
    }
    double operator ^ (const Point &b) const{
        return x*b.y - y*b.x;
    }
    bool operator == (const Point &b) const{
        return sgn(x-b.x)==&&sgn(y-b.y)==;
    }
    Point operator - (const Point &b) const{
        return Point(x-b.x,y-b.y);
    }
    double distance(Point b){
        return sqrt((x-b.x)*(x-b.x) + (y-b.y)*(y-b.y));
    }
};
struct polygon{
    int n;
    Point p[maxn];
    struct cmp{
        Point p;
        cmp(const Point &p0) {p=p0;}
        bool operator()(const Point &aa,const Point &bb){
            Point a=aa,b=bb;
            int d=sgn((a-p)^(b-p));
            if(d==){
                return sgn(a.distance(p) - b.distance(p)) < ;
            }
            return d>;
        }
    };
    void norm(Point t){
        sort(p+,p++n,cmp(t));
    }
    int relationpoint(Point q){
        int cnt = ;
        fo(i,,n-){
            int j = (i+)%n;
            int k = sgn((q-p[j])^(p[i]-p[j]));
            int u = sgn(p[i].y-q.y);
            int v = sgn(p[j].y-q.y);
            if(k>&&u<&&v>=)cnt++;
            if(k<&&v<&&u>=)cnt--;
            if(k==)return ;
        }
        return cnt != ;
    }
}ps,pts,rec;
int n;
bool ok[maxn][maxn][maxn];
double dp[maxn][maxn],ans;
void gao(int st){
    memset(dp,,sizeof(dp));
    int m = n-st+;
    pts.n=m;
    fo(i,,m){
        pts.p[i] = ps.p[st+i-];
    }
    pts.norm(pts.p[]);
    fo(i,,m){
        fo(j,i+,m){
            if(!ok[pts.p[].id][pts.p[i].id][pts.p[j].id]){
                dp[i][j] = ;
            }else{
                bool flag = true;
                fo(k,,i-){
                    if(sgn((pts.p[k]-pts.p[])^(pts.p[i]-pts.p[]))==){
                        flag=false;
                        break;
                    }
                }
                if(flag)fo(k,,i-){
                    if(sgn((pts.p[i]-pts.p[k])^(pts.p[j]-pts.p[i]))>=){

                        dp[i][j] = max(dp[i][j],dp[k][i]);
                    }
                }
                dp[i][j] += ((pts.p[i]-pts.p[]) ^ (pts.p[j]-pts.p[]))/2.0;
            }
            ans=max(ans,dp[i][j]);
        }
    }
}
int main() {
    int T=read();
    while(T--){
        ans=;
        n=ps.n=read();
        fo(i,,n){
            ps.p[i] = Point(read(),read());
        }
        sort(ps.p+,ps.p++n);
        fo(i,,n) ps.p[i].id=i;
        fo(i,,n){
            fo(j,i+,n){
                fo(k,j+,n){
                    rec.n=;
                    rec.p[]=ps.p[i];rec.p[]=ps.p[j];rec.p[]=ps.p[k];
                    ok[k][i][j]=ok[k][j][i]=ok[j][i][k]=ok[j][k][i]=ok[i][k][j]=ok[i][j][k]=true;
                    if(sgn((rec.p[]-rec.p[])^(rec.p[]-rec.p[]))==)continue;
                    fo(t,,n){
                        if(t==i||t==j||t==k)continue;
                        if(rec.relationpoint(ps.p[t])==){
                            ok[k][i][j]=ok[k][j][i]=ok[j][i][k]=ok[j][k][i]=ok[i][k][j]=ok[i][j][k]=false;
                            break;
                        }
                    }
                }
            }
        }
        fo(i,,n){
            gao(i);
        }
        printf("%.1f\n",ans);
    }
    return ;
}