POJ1259：The Picnic（DP）

传送门

题意：
给$n$ 个点，求最大凸多边形，要求内部没有点$(n\le 100)$。

题解：DP

预处理两两到原点的三角形中包含的点的个数以便$O(1)$查询任意三角形中包含的点（我写的代码边界十分繁琐，不知道哪位dalao看了能教教我怎么写得简便一些）。

现在固定左端点，考虑包含它及它右端点的最大凸多边形。

设$f[i][j]$表示从选取点开始，到j点，j点从i点转移的多边形的最大面积。
那么直接$n^3$DP就好了，总时间复杂度$O(n^4)$。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath> 
using namespace std;
inline int read(){
    char ch=getchar();int i=0,f=1;
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=getchar();}
    return i*f;
}
const int Maxn=1e2+5;
int T,n,now;
struct  point{
    int x,y;
    int id;
    double slope;
    point(){}
    point(int x,int y):x(x),y(y){}
    friend inline bool operator <(const point &a,const point &b){return a.x<b.x||(a.x==b.x&&a.y<b.y);} 
    friend inline point operator -(const point &a,const point &b){return point(a.x-b.x,a.y-b.y);}
    friend inline int operator *(const point &a,const point &b){return a.x*b.y-a.y*b.x;}
    inline int norm(){return x*x+y*y;}
}p[Maxn],tp[Maxn];
inline bool cmp_slope(const point &a,const point &b){
    int t=(a-p[now])*(b-p[now]);
    if(t)return (a-p[now])*(b-p[now])>0;
    else return (a-p[now]).norm()>(b-p[now]).norm();
}
int sum[Maxn][Maxn],l_p[Maxn][Maxn],l_p2[Maxn]; 
const double eps=1e-9;
int tmp[5];
inline bool cmp(const int &a,const int &b){
    if(fabs(p[a].slope-p[b].slope)<eps)return p[a].norm()<p[b].norm();
    else return p[a].slope<p[b].slope;
}
inline int area(int i,int j,int k){
    tmp[1]=i,tmp[2]=j,tmp[3]=k;
    sort(tmp+1,tmp+3+1,cmp);
    i=tmp[1],j=tmp[2],k=tmp[3]; 
    if(fabs(p[j].slope-p[k].slope)<eps)swap(j,k);
    int t=(p[i]-p[j])*(p[k]-p[j]);
    int S=abs(sum[i][j])-l_p2[j]+abs(sum[j][k])-abs(sum[k][i]);
    if(t<0) return S+l_p[i][k];
    else return abs(S)+l_p[i][j]+l_p[j][k]-1;
}
int main(){
    T=read();
    while(T--){
        n=read();
        for(int i=1;i<=n;i++)p[i].x=read(),p[i].y=read();
        sort(p+1,p+n+1);
        for(int i=1;i<=n;i++)p[i].id=i,p[i].slope=atan2((double)p[i].y,(double)p[i].x);
        for(int i=1;i<=n;i++){
            for(int j=i+1;j<=n;j++){
                int t1=i,t2=j;
                if(p[i]*p[j]<0)swap(t1,t2);
                int cnt=0;
                for(int k=1;k<=n;k++){
                    if((p[k]-p[t1])*(p[k]-p[t2])<0)continue;
                    if(p[k]*p[t2]<0)continue;
                    if(p[t1]*p[k]<0)continue;
                    ++cnt; 
                } 
                sum[t1][t2]=cnt;
                sum[t2][t1]=-cnt;
                cnt=0;
                for(int k=1;k<=n;k++){
                    if((p[i]-p[k])*(p[j]-p[k]))continue;
                    if((p[k].x<min(p[i].x,p[j].x))||(p[k].x>max(p[i].x,p[j].x)))continue;
                    if((p[k].y<min(p[i].y,p[j].y))||(p[k].y>max(p[i].y,p[j].y)))continue;
                    ++cnt;
                }
                l_p[i][j]=(l_p[j][i]=cnt);
            }
        }
        for(int i=1;i<=n;i++){
            int cnt=0;
            for(int j=1;j<=n;j++){
                if(p[i]*p[j])continue;
                if(p[j].x>=p[i].x&&p[i].x<0&&p[j].x<=0)++cnt;
                else if(p[j].x<=p[i].x&&p[i].x>=0&&p[j].x>=0)++cnt;
            }
            l_p2[i]=cnt;
        }
        static int f[Maxn][Maxn],ans;
        ans=0;
        for(now=1;now<n-1;++now){
            memset(f,0,sizeof(f));
            memcpy(tp+now,p+now,sizeof(point)*(n-now+1));
            sort(tp+now+1,tp+n+1,cmp_slope);
            for(int j=now+2;j<=n;j++){
                for(int k=now+1;k<j;k++){
                    int t=area(now,tp[j].id,tp[k].id),s=abs((tp[j]-p[now])*(tp[k]-p[now]));
                    if(!(t-l_p[now][tp[k].id]-l_p[tp[k].id][tp[j].id]+1)){
                        for(int pre=now;pre<k;++pre){
                            if((tp[j]-tp[pre])*(tp[k]-tp[pre])>0)continue;
                            f[j][k]=max(f[j][k],f[k][pre]+s);
                            ans=max(ans,f[j][k]);
                        }
                    }
                    if(!(t-l_p[now][tp[j].id]-l_p[now][tp[k].id]-l_p[tp[j].id][tp[k].id]+3)){
                        for(int pre=now;pre<k;++pre){
                            if((tp[j]-tp[pre])*(tp[k]-tp[pre])>0)continue;
                            ans=max(ans,f[k][pre]+s);
                        }
                    }
                }
            }
        }
        printf("%.1f\n",(double)ans/2.0);
    }
}