UVa 137 Polygons：计算几何中的多边形相交与面积计算

1. UVa 137 Polygons 题目解析与算法设计

UVa 137 Polygons是算法竞赛中的一道经典计算几何题目，主要考察多边形相交判断与面积计算能力。题目要求判断两个简单多边形是否相交，并计算它们的对称差面积（即两个多边形不相交部分的面积总和）。

1.1 题目核心需求

这道题目的核心在于解决两个关键问题：

1. 判断两个简单多边形是否相交
2. 计算两个多边形的对称差面积

多边形相交判断需要考虑以下几种情况：

• 边与边相交
• 一个多边形完全包含另一个多边形
• 多边形顶点重合的特殊情况

对称差面积的计算公式为：Area(P1 ∪ P2) - Area(P1 ∩ P2)，也可以表示为Area(P1) + Area(P2) - 2*Area(P1 ∩ P2)

1.2 计算几何基础

解决这个问题需要掌握以下计算几何基础知识：

1. 点与线段的相对位置判断
2. 线段相交检测（包括共线情况处理）
3. 多边形面积计算（鞋带公式）
4. 点在多边形内判断（射线法或转角法）
5. 多边形求交算法（Weiler-Atherton算法）

注意：在实际编码中，浮点数精度问题需要特别处理，通常设置一个epsilon值（如1e-8）来判断两个浮点数是否相等。

2. 多边形相交检测的实现

2.1 线段相交检测

判断两个多边形是否相交的基础是线段相交检测。我们需要实现一个可靠的线段相交判断函数：

cpp复制struct Point {
    double x, y;
    Point(double x=0, double y=0):x(x),y(y){}
};

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

// 判断线段ab与cd是否相交
bool segmentIntersect(Point a, Point b, Point c, Point d) {
    double c1 = cross(b-a, c-a);
    double c2 = cross(b-a, d-a);
    double c3 = cross(d-c, a-c);
    double c4 = cross(d-c, b-c);
    
    // 跨立实验
    if(((c1 > 0 && c2 < 0) || (c1 < 0 && c2 > 0)) && 
       ((c3 > 0 && c4 < 0) || (c3 < 0 && c4 > 0)))
        return true;
    
    // 处理共线情况
    if(c1 == 0 && onSegment(a, b, c)) return true;
    if(c2 == 0 && onSegment(a, b, d)) return true;
    if(c3 == 0 && onSegment(c, d, a)) return true;
    if(c4 == 0 && onSegment(c, d, b)) return true;
    
    return false;
}

bool onSegment(Point a, Point b, Point c) {
    return min(a.x, b.x) <= c.x && c.x <= max(a.x, b.x) &&
           min(a.y, b.y) <= c.y && c.y <= max(a.y, b.y);
}

2.2 多边形相交判断

基于线段相交检测，我们可以实现多边形相交判断：

cpp复制bool polygonsIntersect(const vector<Point>& poly1, const vector<Point>& poly2) {
    int n = poly1.size(), m = poly2.size();
    
    // 检查边相交
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            Point a = poly1[i], b = poly1[(i+1)%n];
            Point c = poly2[j], d = poly2[(j+1)%m];
            if(segmentIntersect(a, b, c, d))
                return true;
        }
    }
    
    // 检查包含关系
    if(pointInPolygon(poly1[0], poly2)) return true;
    if(pointInPolygon(poly2[0], poly1)) return true;
    
    return false;
}

3. 多边形面积计算与对称差

3.1 多边形面积计算

使用鞋带公式计算多边形面积：

cpp复制double polygonArea(const vector<Point>& poly) {
    double area = 0;
    int n = poly.size();
    for(int i = 0; i < n; i++) {
        int j = (i + 1) % n;
        area += poly[i].x * poly[j].y;
        area -= poly[i].y * poly[j].x;
    }
    return fabs(area) / 2.0;
}

3.2 对称差面积计算

对称差面积可以通过以下步骤计算：

1. 计算两个多边形的并集面积
2. 计算两个多边形的交集面积
3. 对称差面积 = 并集面积 - 交集面积

cpp复制double symmetricDifference(const vector<Point>& poly1, const vector<Point>& poly2) {
    double area1 = polygonArea(poly1);
    double area2 = polygonArea(poly2);
    
    if(!polygonsIntersect(poly1, poly2)) {
        return area1 + area2;
    }
    
    // 实际实现中需要使用多边形裁剪算法计算交集面积
    double intersectionArea = computeIntersectionArea(poly1, poly2);
    return area1 + area2 - 2 * intersectionArea;
}

4. 多边形裁剪算法实现

4.1 Weiler-Atherton算法概述

Weiler-Atherton算法是计算多边形交集的经典算法，主要步骤如下：

1. 找到所有交点并插入到两个多边形中
2. 建立交点之间的双向链接
3. 从入口交点开始追踪交集多边形

4.2 算法实现关键步骤

cpp复制vector<Point> computeIntersection(const vector<Point>& subject, const vector<Point>& clip) {
    vector<Point> output;
    vector<IntersectionNode> subjectNodes, clipNodes;
    
    // 1. 计算所有交点并插入多边形顶点列表
    findIntersections(subject, clip, subjectNodes, clipNodes);
    
    // 2. 建立交点之间的链接
    linkIntersectionNodes(subjectNodes, clipNodes);
    
    // 3. 追踪交集多边形
    while(unprocessedIntersectionExists(subjectNodes)) {
        vector<Point> intersectionPolygon;
        traceIntersectionPolygon(subjectNodes, clipNodes, intersectionPolygon);
        if(!intersectionPolygon.empty()) {
            // 合并到结果中
            output.insert(output.end(), intersectionPolygon.begin(), intersectionPolygon.end());
        }
    }
    
    return output;
}

5. 完整解题框架与优化技巧

5.1 UVa 137解题框架

cpp复制#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

struct Point { /* 点定义 */ };
/* 前面实现的各种几何函数 */

int main() {
    int n, m;
    while(cin >> n && n) {
        vector<Point> poly1(n);
        for(auto& p : poly1) cin >> p.x >> p.y;
        
        cin >> m;
        vector<Point> poly2(m);
        for(auto& p : poly2) cin >> p.x >> p.y;
        
        double area1 = polygonArea(poly1);
        double area2 = polygonArea(poly2);
        
        if(!polygonsIntersect(poly1, poly2)) {
            printf("%8.2f", area1 + area2);
        } else {
            double intersectionArea = computeIntersectionArea(poly1, poly2);
            printf("%8.2f", area1 + area2 - 2 * intersectionArea);
        }
    }
    return 0;
}

5.2 性能优化技巧

1. 快速排斥实验：在检查线段相交前，先检查两个线段的外接矩形是否相交
2. 扫描线算法：可以使用扫描线算法优化多边形相交检测
3. 空间分割：对多边形边进行空间分割（如网格或四叉树）减少不必要的相交检测
4. 浮点精度处理：使用相对误差而非绝对误差判断浮点数相等

提示：在UVa OJ上提交时，输出格式必须严格符合要求，每个结果占8个字符宽度，保留2位小数。

6. 常见问题与调试技巧

6.1 浮点精度问题

计算几何题目中最常见的问题是浮点精度误差。解决方法包括：

1. 使用足够小的epsilon值（如1e-8）
2. 避免直接比较浮点数相等，使用fabs(a-b) < epsilon
3. 尽量保持计算过程的数值稳定性

6.2 特殊测试用例

需要特别注意以下测试用例：

1. 多边形退化为线段或点
2. 多边形自相交（虽然题目保证简单多边形）
3. 多边形顶点重合
4. 边重合或部分重合

6.3 调试建议

1. 可视化工具：使用Python matplotlib等工具绘制多边形辅助调试
2. 单元测试：为每个几何函数编写测试用例
3. 边界检查：特别注意多边形最后一个顶点与第一个顶点连接的边

我在实际解决这个问题时发现，多边形求交算法的实现最容易出错。建议先实现一个可靠的线段相交检测函数，然后逐步构建更复杂的功能。对于对称差面积的计算，如果实现完整的多边形求交算法太复杂，可以考虑使用蒙特卡洛方法近似计算交集面积，虽然精度稍低但实现简单。