【hdu4785】【闵可夫斯基和】 Exhausted Robot

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4785

题意：一个房间（矩形），里面有一些家具（凸多边形），你有一个扫地机器（凸多边形），扫地机器可以扫地是它的第一个点，能扫地条件是机器完全在房间里面并且和家具没有交（机器可以穿过家具，但穿过的时候不能扫地），问扫地机器扫到的最大面积。

题解：在房间内的限制等同于机器移动的限制是在一个矩形内，然后不交多边形的限制就变成了 家具 和 机器求一个闵可夫斯基和 ， 机器移动不能移动到这个闵可夫斯基和里面，所以问题转换成一个矩形里面有若干个凸多边形，问矩形内多边形没有覆盖到的面积。

这里由于n只有20 ， 我们可以考虑直接暴力扫描线。我们把多边形的顶点以及交点求出来，然后平行于y轴的扫面线一直扫过去，相邻的扫描线是一个区间片，多边形要么是不在区间片里面，要么是横穿了这个区间片，交的结果是一个梯形，注意到，多个多边形的交的梯形不会相交，因为假如相交了，那么交点肯定在区间片中间，那么区间片就应该缩小（因为是扫关键点），

由于刚刚的结论，所以我们直接用梯形面积公式求出区间片的面积，累加即可。

注意：对于一个多边形，我一个区间片统计其贡献的时候，当且仅当该多边形贯穿区间片，不然会出现问题，自己脑部一下就知道了。

#include<bits/stdc++.h>
using namespace std;
#define eps 1e-8
const int N = 1e3+9;
const double inf = 1e6;
int sgn(double x){
    if( fabs(x) < eps) return 0;
    if( x < 0 ) return -1;
    return 1;
}
struct Point{
    double x,y;
    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};
    }
    bool operator < (const Point& b)const{
        if( sgn(x - b.x) == 0 ) return y < b.y;
        return x < b.x;
    }
}va[N],vb[N],rec[10];
double cross(Point a,Point b){
    return a.x * b.y - b.x * a.y;
}
vector<Point> a[N],b[N];
int n;
double xl,yl,xr,yr;
double X[N];
double mi[N],mx[N];
int cnt;
bool insert(Point a,Point b,Point c,Point d){
    return 
        max(a.x,b.x) >= min(c.x,d.x) &&
        max(c.x,d.x) >= min(a.x,b.x) &&
        max(a.y,b.y) >= min(c.y,d.y) &&
        max(c.y,d.y) >= min(a.y,b.y) &&
        sgn(cross(c-a,b-a))*sgn(cross(d-a,b-a))<=0 &&
        sgn(cross(a-c,d-c))*sgn(cross(b-c,d-c))<=0;
}
Point segcross(Point a,Point b,Point c,Point d){
    double u = cross(b-a,c-a) , v = cross(a-b,d-b);
    return (Point){ (c.x*v+d.x*u)/(u+v) , (c.y*v+d.y*u)/(u+v)};
}
vector<Point> Minke(vector<Point> pa,vector<Point> pb){
    int na = pa.size(),nb = pb.size();
    //
    int ida = 0, idb = 0;
    for(int i = 0;i<na;++i) if(pa[i] < pa[ida]) ida = i;
    for(int i = 0;i<nb;++i) if(pb[i] < pb[idb]) idb = i;
    vector<Point> ta , tb;
    for(int i = 0;i<na;++i){
        ta.push_back(pa[ida]);
        ida = (ida+1)%na;
    }
    for(int i = 0;i<nb;++i){
        tb.push_back(pb[idb]);
        idb = (idb+1)%nb;
    }
    pa = ta; pb = tb;

    for(int i = 0 ; i < na-1;++i) va[i] = pa[i+1] - pa[i];
    va[na-1] = pa[0] - pa[na-1];
    for(int i = 0 ; i < nb-1;++i) vb[i] = pb[i+1] - pb[i];
    vb[nb-1] = pb[0] - pb[nb-1];
    vector<Point> pc;
    Point tem;
    tem = pa[0] + pb[0];
    pc.push_back(tem);
    int p1 = 0, p2 = 0;
    while(p1 < na && p2 < nb){
        tem = tem + ( (cross(va[p1],vb[p2]) >= 0 ) ? va[p1++] : vb[p2++]);
        pc.push_back(tem);
    }
    while(p1 < na){
        tem = tem + va[p1++];
        pc.push_back(tem);
    }
    while(p2 < nb){
        tem = tem + vb[p2++];
        pc.push_back(tem);
    }
    //
    return pc;
}
void init(){
    double xmi = a[n+1][0].x,ymi = a[n+1][0].y,xmx = xmi , ymx = ymi;
    for(auto it : a[n+1]){
        xmi = min(xmi,it.x) , xmx = max(xmx,it.x);
        ymi = min(ymi,it.y) , ymx = max(ymx,it.y);
    }
    xl -= xmi; xr -= xmx;
    yl -= ymi; yr -= ymx;

    for(int i = 0;i<a[n+1].size();++i){
        a[n+1][i].x = -a[n+1][i].x;
        a[n+1][i].y = -a[n+1][i].y;
    }
    for(int i = 1;i<=n;++i){
        b[i] = Minke(a[n+1],a[i]);
    }
    for(int i = 1;i<=n;++i){
        mi[i] = b[i][0].x , mx[i] = mi[i];
        for(auto it : b[i]){
            mi[i] = min(mi[i],it.x);
            mx[i] = max(mx[i],it.x);
        }
    }
    X[++cnt] = xl;
    X[++cnt] = xr;
    for(int i = 1;i<=n;++i){
        for(auto it : b[i]){
            if(it.x < xl + eps || it.x > xr - eps ) continue;
            X[++cnt] = it.x;
        }
    }
    for(int i = 1;i<=n;++i){
        for(int j = i+1;j<=n;++j){
            for(int ii = 0;ii<b[i].size()-1;++ii){
                for(int jj = 0;jj<b[j].size()-1;++jj){
                    Point s1 = b[i][ii] , e1 = b[i][ii+1];
                    Point s2 = b[j][jj] , e2 = b[j][jj+1];
                    if( sgn(cross(e1 - s1,s2 - s1) ) == 0 && sgn(cross(e1 - s1,e2 - s1) == 0 ) ) continue;
                    if( insert(s1,e1,s2,e2) ){
                        Point tem = segcross(s1,e1,s2,e2);
                        if(tem.x < xl + eps || tem.x > xr - eps ) continue;
                        X[++cnt] = tem.x;
                    }
                }
            }
        }
    }
    rec[0] = (Point){xl,yl}; rec[1] = (Point){xr,yl};
    rec[2] = (Point){xr,yr}; rec[3] = (Point){xl,yr}; rec[4] = rec[0];
    for(int i = 1;i<=n;++i){
        for(int j = 0;j<b[i].size()-1;++j){
            for(int k = 0;k<4;++k){
                if(insert(b[i][j],b[i][j+1],rec[k],rec[k+1])){
                    Point res = segcross(b[i][j],b[i][j+1],rec[k],rec[k+1]);
                    X[++cnt] = res.x;
                }
            }
        }
    }
    sort(X+1,X+1+cnt);
}
void crosspol(vector<Point> p, double xx , vector< pair<double,int> >& Y){
    Point le = (Point){xx,-inf} , ri = (Point){xx,inf};
    vector<double> vec;
    for(int j = 0;j<p.size()-1;++j){
        if( sgn( p[j].x - le.x) == 0 && sgn(p[j+1].x - le.x) == 0){
            vec.push_back(p[j].y);
            vec.push_back(p[j+1].y);
        }
        else{
            if(insert(le,ri,p[j],p[j+1]) ){
                Point tem = segcross(le,ri,p[j],p[j+1]);
                vec.push_back(tem.y);
            }
        }
    }
    sort(vec.begin(),vec.end());
    if(vec.size() < 2) return;
    double ya = vec[0] , yb = vec[vec.size()-1];
    Y.push_back({max(ya,yl),1}); Y.push_back({min(yb,yr),-1});
}
double solve_len(vector< pair<double,int> > Y){
    sort(Y.begin(),Y.end());
    int num = 0;
    double res = 0;
    double las;
    for(auto it : Y){
        if(num==0 && it.second == 1){
            las = it.first;
            ++num;
            continue;
        }
        num += it.second;
        if(num == 0 && it.second == -1) res += (it.first - las);
    }
    return res;
}
void solve(){
    double ans = 0;
    for(int i = 1;i<cnt;++i){
        vector< pair<double,int> > Yl,Yr;
        for(int j = 1;j<=n;++j){
            if(mx[j] < X[i] + eps || mi[j] > X[i+1] - eps ) continue;
            crosspol(b[j],X[i],Yl);
            crosspol(b[j],X[i+1],Yr);
        }
        double le = solve_len(Yl) , ri = solve_len(Yr);
        ans += (ri + le) * (X[i+1] - X[i]) * 0.5;
    }
    printf("%.3f\n",(xr-xl)*(yr-yl) - ans);
    return;
}
int main(){
    int T; scanf("%d",&T);
    for(int cas = 1;cas <= T;++cas){
        cnt = 0;
        printf("Case #%d: ",cas);
        scanf("%d",&n);
        for(int i = 1;i<=n+1;++i){
            a[i].clear();
            int m; scanf("%d",&m);
            for(int j = 1;j<=m;++j){
                Point tem;
                scanf("%lf %lf",&tem.x,&tem.y);
                a[i].push_back(tem);
            }
        }
        scanf("%lf %lf %lf %lf",&xl,&yl,&xr,&yr);
        init();
        solve();
    }
    return 0;
}
/*
6
1
3
0 0
10 0
10 10
4
0 0
1 0
1 1
0 1
0 0 10 10
*/