POJ 3410 Split convex polygon（凸包）

题意是逆时针方向给你两个多边形，问你这两个多边形通过旋转和平移能否拼成一个凸包。

首先可以想到的便是枚举边，肯定是有一对长度相同的边贴合，那么我们就可以n²枚举所有边对，接下来就是旋转点对，那么假设多边型在这条向量的左侧，那么我们可以根据叉积正负判断旋转的方向。

然后就是如何判断了，显然有一种情况是凸包里扣除整个多边形，那么这种情况我们需要对重合的边进行删除，可以发现，如果有重合的边，他一定是成对出现，有一条进去的边也有一条出来的边，那么我们可以直接通过vector不断插入的过程和之前那条边比较，是否是同一对点产生的边，如果是我们就直接抵消，进行下一次判断。

最后就是对这些绕着一圈的点进行判断是否是凸包，那么我们直接绕一圈判断两个向量叉积是否是小于0或者叉积等于0但是方向相反，那么这种情况也是非法。

还是有很多细节地方，此题好像eps要开大一点，不然会wa。

 

12
0 0
10 0
10 4
6 4
8 2
4 2
4 8
8 8
6 6
10 6
10 10
0 10
12
12 4
12 6
10 10
10 6
6 6
8 8
4 8
4 2
8 2
6 4
10 4
10 0

ans=1

12
0 0
10 0
10 4
6 4
8 2
4 2
4 8
8 8
6 6
10 6
10 10
0 10
8
12 4
12 6
6 6
8 8
4 8
4 2
8 2
6 4

ans=0

//      ——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 pb push_back
#define MP make_pair

using namespace std;

typedef double db;
typedef long ll;
typedef pair<db,db> Pd;
typedef pair<int,int> P;
typedef pair<ll,ll> Pll;

const db eps=1e-6;
const int MAXN=1e3+10;
const db pi=acos(-1.0);
const ll INF=0x3f3f3f3f3f3f3f3f;

inline int dcmp(db x){
    if(fabs(x)<eps) return 0;
    return (x>0? 1: -1);
}

inline db Sqrt(db x){
    return x>0? sqrt(x): 0;
}

inline db sqr(db x){ return x*x; }

struct Point{
    db x,y;
    Point(){ x=0,y=0; }
    Point(db _x,db _y):x(_x),y(_y){}
    void input(){
        double _x,_y;
        scanf("%lf%lf",&_x,&_y);
        x=_x,y=_y;
    }
    bool operator ==(const Point &b)const{
        return (dcmp(x-b.x)==0&&dcmp(y-b.y)==0);
    }
    bool operator <(const Point &b)const{
        return (dcmp(x-b.x)==0? dcmp(y-b.y)<0 : x<b.x);
    }
    Point operator +(const Point &b)const{
        return Point(x+b.x,y+b.y);
    }
    Point operator -(const Point &b)const{
        return Point(x-b.x,y-b.y);
    }
    Point operator *(db a){
        return Point(x*a,y*a);
    }
    Point operator /(db a){
        return Point(x/a,y/a);
    }
    db len2(){  //长度平方
        return sqr(x)+sqr(y);
    }
    db len(){   //长度
        return Sqrt(len2());
    }
    db polar(){ //向量的极角
        return atan2(y,x);   //返回与x轴正向夹角(-pi~pi]
    }
    Point change_len(db r){ //转化为长度为r的向量
        db l=len();
        if(dcmp(l)==0)  return *this;  //零向量
        return Point(x*r/l,y*r/l);
    }
    Point rotate(Point p,db ang){   //绕点p逆时针旋转ang度
        Point v=(*this)-p;
        db c=cos(ang),s=sin(ang);
        return Point(p.x+v.x*c-v.y*s,p.y+v.x*s+v.y*c);
    }
};

inline db cross(Point a,Point b){   //叉积
    return a.x*b.y-a.y*b.x;
}

inline db dot(Point a,Point b){ //点积
    return a.x*b.x+a.y*b.y;
}

inline db dis(Point a,Point b){ //两点的距离
    Point p=b-a;    return p.len();
}

db rad(Point a,Point b){    //两个向量的夹角
    return fabs(atan2(fabs(cross(a,b)),dot(a,b)));
}

struct Node{
    Point vec,s,t;
    Node(){}
    Node(Point a,Point b,Point c){
        vec=a,s=b,t=c;
    }
};

Point a[210],b[210],tmp[410];

int main(void){
    int n;  
    while(~scanf("%d",&n)){
        int ans=0;
        for(int i=0;i<n;i++)    a[i].input(),a[i+n]=a[i];
        int m;  scanf("%d",&m);
        for(int i=0;i<m;i++)    b[i].input(),b[i+m]=b[i];

        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(dcmp(dis(a[i],a[i+1])-dis(b[j],b[j+1]))==0){
                    int p=0,f=0; 
                    vector<Node>st;
                    db ang=rad(b[j+1]-b[j],a[i+1]-a[i]);
                    if(dcmp(cross(b[j+1]-b[j],a[i+1]-a[i]))>=0)  ang-=pi;
                    else    ang=pi-ang;

                    for(int k=0;k<i;k++)        tmp[p++]=a[k];
                    for(int k=j+1;k<j+m+1;k++)  tmp[p++]=a[i+1]+(b[k]-b[j]).rotate(Point(0,0),ang);
                    for(int k=i+2;k<n;k++)      tmp[p++]=a[k];

                    tmp[p]=tmp[0];

                    for(int i=0;i<p;i++){
                        Point res=tmp[i+1]-tmp[i];
                        if(st.size()&&st.back().t==tmp[i]&&st.back().s==tmp[i+1])   st.pop_back();
                        else    st.pb(Node(res,tmp[i],tmp[i+1]));
                    }

                    st.pb(st[0]);
                    for(int i=1;i<(int)st.size();i++)
                        if(dcmp(cross(st[i-1].vec,st[i].vec))<0||
                          (dcmp(cross(st[i-1].vec,st[i].vec))==0&&dcmp(dot(st[i-1].vec,st[i].vec))<=0))
                            f=1;
                    if(!f)  ans=1;
                }
        printf("%d
",ans);
    }
    return 0;
}