UVa 109 - SCUD Busters（凸包计算）

题目来源：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=3&page=show_problem&problem=45

SCUD Busters

Background

Some problems are difficult to solve but have a simplification that is easy to solve. Rather than deal with the difficulties of constructing a model of the Earth (a somewhat oblate spheroid), consider a pre-Columbian flat world that is a 500 kilometer 500 kilometer square.

In the model used in this problem, the flat world consists of several warring kingdoms. Though warlike, the people of the world are strict isolationists; each kingdom is surrounded by a high (but thin) wall designed to both protect the kingdom and to isolate it. To avoid fights for power, each kingdom has its own electric power plant.

When the urge to fight becomes too great, the people of a kingdom often launch missiles at other kingdoms. Each SCUD missile (Sanitary Cleansing Universal Destroyer) that lands within the walls of a kingdom destroys that kingdom's power plant (without loss of life).

The Problem

Given coordinate locations of several kingdoms (by specifying the locations of houses and the location of the power plant in a kingdom) and missile landings you are to write a program that determines the total area of all kingdoms that are without power after an exchange of missile fire.

In the simple world of this problem kingdoms do not overlap. Furthermore, the walls surrounding each kingdom are considered to be of zero thickness. The wall surrounding a kingdom is the minimal-perimeter wall that completely surrounds all the houses and the power station that comprise a kingdom; the area of a kingdom is the area enclosed by the minimal-perimeter thin wall.

There is exactly one power station per kingdom.

There may be empty space between kingdoms.

The Input

The input is a sequence of kingdom specifications followed by a sequence of missile landing locations.

A kingdom is specified by a number N ( ) on a single line which indicates the number of sites in this kingdom. The next line contains the x and y coordinates of the power station, followed by N-1 lines of x, y pairs indicating the locations of homes served by this power station. A value of -1 for N indicates that there are no more kingdoms. There will be at least one kingdom in the data set.

Following the last kingdom specification will be the coordinates of one or more missile attacks, indicating the location of a missile landing. Each missile location is on a line by itself. You are to process missile attacks until you reach the end of the file.

Locations are specified in kilometers using coordinates on a 500 km by 500 km grid. All coordinates will be integers between 0 and 500 inclusive. Coordinates are specified as a pair of integers separated by white-space on a single line. The input file will consist of up to 20 kingdoms, followed by any number of missile attacks.

The Output

The output consists of a single number representing the total area of all kingdoms without electricity after all missile attacks have been processed. The number should be printed with (and correct to) two decimal places.

Sample Input

Sample Output

70.50

A Hint

You may or may not find the following formula useful.

Given a polygon described by the vertices such that , the signed area of the polygon is given by

where the x, y coordinates of ; the edges of the polygon are from to for .

If the points describing the polygon are given in a counterclockwise direction, the value of a will be positive, and if the points of the polygon are listed in a clockwise direction, the value of a will be negative.

解题思路：

计算几何类型的题目。需要用到三个基本算法，一是求凸包，二是判断点在多边形内，三是求多边形面积（题目中已给出）。关于凸包算法请详见Graham's Scan法。判断点在多边形内的算法有很多种，这里用到的是外积法：设待判断的点为p，逆时针或顺时针遍例多边形的每个点v_n，将两个向量<p, v_n>和<v_n, v_{n + 1}>做外积。如果对于多边形上所有的点，外积的符号都相同（顺时针为负，逆时针为正），则可断定p在多边形内。外积出现0，则表示p在边上，否则在多边形外。

算法的思路很直接，实现也很简单，关键是这道题的测试数据太扯蛋了，让我郁闷了很久。题目中并未说明导弹打在墙上怎么办，只是说“... whithin the wall ...”。根据测试结果来看，打在墙上和打在据点上都要算打中。题目中还提到国家不会互相重叠“... kingdoms do not overlap.”，但测试表明数据里确有重叠的情况，因此在导弹击中后一定要跳出循环，否则会出现一弹多击的情况。

给你N个王国，求下凸包，再求面积。给你一些炮弹，问炮弹炸掉的面积。（一个炮弹炸的话，整个王国都被炸了）。

直接求凸包后，求出各个王国的面积，然后判断炮弹在哪个王国里，这个直接用判断点是否在多边形内。

参考代码：

 #include<bits/stdc++.h>
 
 using namespace std;
 
 const int MAX = ;
 struct point{ double x,y;};        //点
 struct polygon{ point c[MAX],a; double area; int n;};
 struct segment{ point a,b;};        // 线段
 const double eps = 1e-;
 bool dy(double x,double y)    {    return x > y + eps;}    // x > y
 bool xy(double x,double y)    {    return x < y - eps;}    // x < y
 bool dyd(double x,double y)    {     return x > y - eps;}    // x >= y
 bool xyd(double x,double y)    {    return x < y + eps;}     // x <= y
 bool dd(double x,double y)     {    return fabs( x - y ) < eps;}  // x == y
 polygon king[MAX];
 point c[MAX];
 double crossProduct(point a,point b,point c)//向量 ac 在 ab 的方向
 {
     return (c.x - a.x)*(b.y - a.y) - (b.x - a.x)*(c.y - a.y);
 }
 double disp2p(point a,point b)
 {
     return sqrt( ( a.x - b.x ) * ( a.x - b.x ) + ( a.y - b.y ) * ( a.y - b.y ) );
 }
 double area_polygon(point p[],int n)
 {
     double s = 0.0;
     for(int i=; i<n; i++)
         s += p[(i+)%n].y * p[i].x - p[(i+)%n].x * p[i].y;
     return fabs(s)/2.0;
 }
 bool cmp(point a,point b)  // 排序
 {
     double len = crossProduct(c[],a,b);
     if( dd(len,0.0) )
         return xy(disp2p(c[],a),disp2p(c[],b));
     return xy(len,0.0);
 }
 bool onSegment(point a, point b, point c)
 {
     double maxx = max(a.x,b.x);
     double maxy = max(a.y,b.y);
     double minx = min(a.x,b.x);
     double miny = min(a.y,b.y);
     if( dd(crossProduct(a,b,c),0.0) && dyd(c.x,minx) && xyd(c.x,maxx) && dyd(c.y,miny) && xyd(c.y,maxy) )
         return true;
     return false;
 }
 bool segIntersect(point p1,point p2, point p3, point p4)
 {
     double d1 = crossProduct(p3,p4,p1);
     double d2 = crossProduct(p3,p4,p2);
     double d3 = crossProduct(p1,p2,p3);
     double d4 = crossProduct(p1,p2,p4);
     if( xy(d1 * d2,0.0) && xy(d3 * d4,0.0) )    return true;
     if( dd(d1,0.0) && onSegment(p3,p4,p1) )        return true;//如果不判端点相交，则下面这四句话不需要
     if( dd(d2,0.0) && onSegment(p3,p4,p2) )        return true;
     if( dd(d3,0.0) && onSegment(p1,p2,p3) )        return true;
     if( dd(d4,0.0) && onSegment(p1,p2,p4) )        return true;
     return false;
 }
 bool point_inPolygon(point pot,point p[],int n)
 {
     int count = ;
     segment l;
     l.a = pot;
     l.b.x = 1e10*1.0;
     l.b.y = pot.y;
     p[n] = p[];
     for(int i=; i<n; i++)
     {
         if( onSegment(p[i],p[i+],pot) )
             return true;
         if( !dd(p[i].y,p[i+].y) )
         {
             int tmp = -;
             if( onSegment(l.a,l.b,p[i]) )
                 tmp = i;
             else
                 if( onSegment(l.a,l.b,p[i+]) )
                     tmp = i+;
             if( tmp != - && dd(p[tmp].y,max(p[i].y,p[i+].y)) )
                 count++;
             else
                 if( tmp == - && segIntersect(p[i],p[i+],l.a,l.b) )
                     count++;
         }
     }
     if( count %  ==  )
         return true;
     return false;
 }
 point stk[MAX];
 int top;
 double Graham(int n)
 {
     int tmp = ;
     for(int i=; i<n; i++)
         if( xy(c[i].x,c[tmp].x) || dd(c[i].x,c[tmp].x) && xy(c[i].y,c[tmp].y) )
             tmp = i;
     swap(c[],c[tmp]);
     sort(c+,c+n,cmp);
     stk[] = c[]; stk[] = c[];
     top = ;
     for(int i=; i<n; i++)
     {
         while( xyd( crossProduct(stk[top],stk[top-],c[i]), 0.0 ) && top >=  )
             top--;
         stk[++top] = c[i];
     }
     return area_polygon(stk,top+);
 }
 int main()
 {
     int n;
     int i = ;
     double x,y;
     while( ~scanf("%d",&n) && n != - )
     {
         king[i].n = n;
         for(int k=; k<n; k++)
             scanf("%lf %lf",&king[i].c[k].x,&king[i].c[k].y);
         king[i].a = king[i].c[];
         i++;
     }
 
     double sum = 0.0;
     for(int k=; k<i; k++)
     {
         memcpy(c,king[k].c,sizeof(king[k].c));
         king[k].area = Graham(king[k].n);
         memcpy(king[k].c,stk,sizeof(stk));
         king[k].n = top+;
     }
     point pot;
     bool die[MAX];
     memset(die,false,sizeof(die));
     while( ~scanf("%lf %lf",&pot.x,&pot.y) )
     {
         for(int k=; k<i; k++)
             if( point_inPolygon(pot,king[k].c,king[k].n) && !die[k] )
             {
                 die[k] = true;
                 sum += king[k].area;
             }
     }
 
     printf("%.2lf\n",sum);
 return ;
 }

参考代码2：

 #include <algorithm>
 #include <functional>
 #include <iomanip>
 #include <iostream>
 #include <vector>
 #include <math.h>
 
 using namespace std;
 
 struct POINT {
     int x; int y;
     bool operator==(const POINT &other) {
         return (x == other.x && y == other.y);
     }
 } ptBase;
 
 typedef vector<POINT> PTARRAY;
 
 bool CompareAngle(POINT pt1, POINT pt2) {
     pt1.x -= ptBase.x, pt1.y -= ptBase.y;
     pt2.x -= ptBase.x, pt2.y -= ptBase.y;
     return (pt1.x / sqrt((float)(pt1.x * pt1.x + pt1.y * pt1.y)) <
         pt2.x / sqrt((float)(pt2.x * pt2.x + pt2.y * pt2.y)));
 }
 
 void CalcConvexHull(PTARRAY &vecSrc, PTARRAY &vecCH) {
     ptBase = vecSrc.back();
     sort(vecSrc.begin(), vecSrc.end() - , &CompareAngle);
     vecCH.push_back(ptBase);
     vecCH.push_back(vecSrc.front());
     POINT ptLastVec = { vecCH.back().x - ptBase.x,
         vecCH.back().y - ptBase.y };
     PTARRAY::iterator i = vecSrc.begin();
     for (++i; i != vecSrc.end() - ; ++i) {
         POINT ptCurVec = { i->x - vecCH.back().x, i->y - vecCH.back().y };
         while (ptCurVec.x * ptLastVec.y - ptCurVec.y * ptLastVec.x < ) {
             vecCH.pop_back();
             ptCurVec.x = i->x - vecCH.back().x;
             ptCurVec.y = i->y - vecCH.back().y;
             ptLastVec.x = vecCH.back().x - (vecCH.end() - )->x;
             ptLastVec.y = vecCH.back().y - (vecCH.end() - )->y;
         }
         vecCH.push_back(*i);
         ptLastVec = ptCurVec;
     }
     vecCH.push_back(vecCH.front());
 }
 
 int CalcArea(PTARRAY &vecCH) {
     int nArea = ;
     for (PTARRAY::iterator i = vecCH.begin(); i != vecCH.end() - ; ++i) {
         nArea += (i + )->x * i->y - i->x * (i + )->y;
     }
     return nArea;
 }
 
 bool PointInConvexHull(POINT pt, PTARRAY &vecCH) {
     for (PTARRAY::iterator i = vecCH.begin(); i != vecCH.end() - ; ++i) {
         int nX1 = pt.x - i->x, nY1 = pt.y - i->y;
         int nX2 = (i + )->x - i->x, nY2 = (i + )->y - i->y;
         if (nX1 * nY2 - nY1 * nX2 < ) {
             return false;
         }
     }
     return true;
 }
 
 int main(void) {
     vector<PTARRAY> vecKingdom;
     POINT ptIn;
     int aFlag[] = {}, nAreaSum = ;
     for (int nPtCnt; cin >> nPtCnt && nPtCnt >= ;) {
         PTARRAY vecSrc, vecCH;
         cin >> ptIn.x >> ptIn.y;
         vecSrc.push_back(ptIn);
         for (; --nPtCnt != ;) {
             cin >> ptIn.x >> ptIn.y;
             POINT &ptMin = vecSrc.back();
             vecSrc.insert(vecSrc.end() - (ptIn.y > ptMin.y ||
                 (ptIn.y == ptMin.y && ptIn.x > ptMin.x)), ptIn);
         }
         CalcConvexHull(vecSrc, vecCH);
         vecKingdom.push_back(vecCH);
     }
     while (cin >> ptIn.x >> ptIn.y) {
         vector<PTARRAY>::iterator i = vecKingdom.begin();
         for (int k = ; i != vecKingdom.end(); ++i, ++k) {
             if (PointInConvexHull(ptIn, *i) && aFlag[k] != ) {
                 nAreaSum += CalcArea(*i);
                 aFlag[k] = ;
                 break;
             }
         }
     }
     cout << setiosflags(ios::fixed) << setprecision();
     cout << (float)nAreaSum / 2.0f << endl;
     return ;
 }