POJ 3135 Polygons on the Grid（枚举+凸包）

题目大意是让你用这n条边放在网格上构成凸包，并且边的两端点必须在网格上。

那么比较容易想到的就是枚举可能情况，因为这样的勾股数组成情况不多，因此可以直接枚举所有连出去的边反映在坐标轴上的所有情况，最后判断是否回到起点并且绕城一个凸包。

但是样例三每条边有最多36个方向，那么36⁶*6！显然会超时，我们就需要一些剪枝。

1.第一条边固定住，那么我们的枚举边的顺序的复杂度变成了5！.

2.枚举到最后一个点的时候，不需要再将次边连出去判断是否回到起点，直接判断起点到该点的距离是否为这条边的长度即可，复杂度降成36⁵.

3.每次往下搜索的时候都要去判断是否把这个点定住，当前的所有点仍然是一个凸包，因为满足的条件的凸包不多，所以这部分剪枝剪得比较多.

附赠数据：

6

60 203 113 164 169 131 

6

185 198 159 109 69 120

6

246 261 281 217 240 225

6

290 124 130 16 112 120

0

41636

37323

125526

32088

 //      ——By DD_BOND
 
 //#include<bits/stdc++.h>
 //#include<unordered_map>
 //#include<unordered_set>
 #include<functional>
 #include<algorithm>
 #include<iostream>
 //#include<ext/rope>
 #include<iomanip>
 #include<climits>
 #include<cstring>
 #include<cstdlib>
 #include<cstddef>
 #include<cstdio>
 #include<memory>
 #include<vector>
 #include<cctype>
 #include<string>
 #include<cmath>
 #include<queue>
 #include<deque>
 #include<ctime>
 #include<stack>
 #include<map>
 #include<set>
 
 #define fi first
 #define se second
 #define MP make_pair
 #define pb push_back
 #define INF 0x3f3f3f3f
 #define pi 3.1415926535898
 #define lowbit(a)  (a&(-a))
 #define lson l,(l+r)/2,rt<<1
 #define rson (l+r)/2+1,r,rt<<1|1
 #define Min(a,b,c)  min(a,min(b,c))
 #define Max(a,b,c)  max(a,max(b,c))
 #define debug(x)  cerr<<#x<<"="<<x<<"\n";
 
 //#pragma GCC optimize(3)
 //#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
 
 using namespace std;
 
 typedef long long ll;
 typedef pair<int,int> P;
 typedef pair<ll,ll> Pll;
 typedef unsigned long long ull;
 
 const int seed=;
 const ll LLMAX=2e18;
 const int MOD=1e9+;
 const double eps=1e-;
 const int MAXN=1e6+;
 const int hmod1=0x48E2DCE7;
 const int hmod2=0x60000005;
 
 inline ll sqr(ll x){ return x*x; }
 inline int sqr(int x){ return x*x; }
 inline double sqr(double x){ return x*x; }
 ll __gcd(ll a,ll b){ return b==? a: __gcd(b,a%b); }
 ll qpow(ll a,ll n){ll sum=;while(n){if(n&)sum=sum*a%MOD;a=a*a%MOD;n>>=;}return sum;}
 inline int dcmp(double x){  if(fabs(x)<eps) return ;   return (x>? : -); }
 
 struct Point{
     int x,y;
     Point(){ x=y=; }
     Point(int _x,int _y):x(_x),y(_y){}
     inline Point operator -(const Point &n)const{
         return Point(x-n.x,y-n.y);
     }
     inline int operator *(const Point &n)const{
         return x*n.x+y*n.y;
     }
     inline int operator ^(const Point &n)const{
         return x*n.y-y*n.x;
     }
 };
 
 Point loc[];
 int n,sum,ans,l[];
 vector<Point>vec[];
 
 inline void dfs(int p,int x,int y,int res,int area){
     if(p==n-){
         if(sqr(l[p])!=x*x+y*y)    return ;
         ans=max(ans,area/);
     }
     else{
         for(int i=;i<(int)vec[l[p]].size();i++){
             if(p==&&(vec[l[p]][i].x<||vec[l[p]][i].y<||vec[l[p]][i].x<vec[l[p]][i].y))  continue;
             Point tmp(x+vec[l[p]][i].x,y+vec[l[p]][i].y);
             if(p==||(p>=&&
                 ( ((loc[p]-loc[p-])^(tmp-loc[p]))>||( ((loc[p]-loc[p-])^(tmp-loc[p]))==&&((loc[p]-loc[p-])*(tmp-loc[p]))> ) )&&
                 ( ((tmp-loc[p])^(Point(,)-tmp))>||( ((tmp-loc[p])^(Point(,)-tmp))==&&((tmp-loc[p])*(Point(,)-tmp))> ) )&&
                 ( ((Point(,)-tmp)^loc[])>||( ((Point(,)-tmp)^loc[])==&&((Point(,)-tmp)*loc[])> ) )&&
                 tmp.x*tmp.x+tmp.y*tmp.y<=sqr(sum-res-l[p]) ) ){
                 int now=area;
                 loc[p+]=tmp;
                 if(p>=)    now+=loc[p]^loc[p+];
                 dfs(p+,tmp.x,tmp.y,res+l[p],now);
             }
         }
     }
 }
 
 int main(void)
 {
     loc[]=Point(,);
     for(int i=-;i<=;i++)
         for(int j=-;j<=;j++){
             int p=i*i+j*j;
             int sq=round(sqrt(p));
             if(sq>||sq*sq!=p)  continue;
             vec[sq].pb(Point(i,j));
         }
     while(scanf("%d",&n)&&n){
         sum=;  ans=-;
         for(int i=;i<n;i++)    scanf("%d",&l[i]),sum+=l[i];
         sort(l,l+n);
         do{ dfs(,,,,); }while(next_permutation(l+,l+n));
         if(ans==)  ans=-;
         printf("%d\n",ans);
     }
     return ;
 }