C语言实现最小面积旋转矩形算法

1. 问题理解与建模

这道题目要求我们在给定平面上的一组点中，找出能够构成矩形的最小面积。与基础版本不同，这里允许矩形旋转，因此我们需要考虑斜向矩形的情况。题目给出的点都是整数坐标，但最终面积可能是浮点数。

理解题目时需要注意几个关键点：

1. 矩形定义：必须满足四个角都是直角，对边平行且相等，对角线长度相等
2. 面积计算：需要找到所有可能矩形中的最小正值面积
3. 输入规模：点的数量最多为50，因此O(n^4)的暴力解法在理论上是可行的

2. 几何原理与算法选择

2.1 矩形判定条件

判断四个点能否构成矩形，有以下几种数学方法：

1. 对角线中点重合且长度相等
2. 三条边满足勾股定理（即存在直角）
3. 向量点积为零（垂直）且长度匹配

在实际编码中，第一种方法实现起来最为简便。具体来说：

• 对于点对(p1,p2)和(p3,p4)，如果它们的中点相同且距离相等，则这四个点可以构成矩形
• 面积就是这两条对角线长度的乘积除以2（实际上应该是边长的乘积）

2.2 算法优化思路

暴力枚举所有四点组合的O(n^4)方法虽然可行，但对于n=50来说计算量较大（约230万次循环）。我们可以采用更聪明的O(n^2)方法：

1. 预处理所有点对，计算它们的中点坐标和距离
2. 使用哈希表存储相同中点和距离的点对
3. 对于每组具有相同中点和距离的点对集合，计算可能形成的矩形面积

这种方法利用了矩形的几何特性，将复杂度从O(n^4)降低到O(n^2)。

3. C语言实现详解

3.1 数据结构设计

c复制typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    int dx;
    int dy;
} Vector;

typedef struct {
    Point p1;
    Point p2;
    long distance_sq;
    Point center;
} Segment;

我们定义了三种主要数据结构：

• Point：存储点的x,y坐标
• Vector：表示向量，用于计算几何关系
• Segment：存储点对信息，包括两点坐标、距离平方和中点

3.2 关键函数实现

3.2.1 距离和中点计算

c复制long distance_sq(Point p1, Point p2) {
    long dx = p1.x - p2.x;
    long dy = p1.y - p2.y;
    return dx*dx + dy*dy;
}

Point center(Point p1, Point p2) {
    Point c = {
        .x = p1.x + p2.x,
        .y = p1.y + p2.y
    };
    return c;
}

这里使用距离平方而非实际距离，避免了浮点数运算和开方操作，同时不影响比较结果。

3.2.2 哈希表实现

由于C标准库没有内置哈希表，我们需要实现一个简易版本：

c复制#define HASH_SIZE 20000

typedef struct HashNode {
    Segment seg;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

unsigned int hash_func(Point center, long dist_sq) {
    return ((center.x * 31 + center.y) * 31 + dist_sq) % HASH_SIZE;
}

void insert_segment(Segment seg) {
    unsigned int idx = hash_func(seg.center, seg.distance_sq);
    HashNode* node = malloc(sizeof(HashNode));
    node->seg = seg;
    node->next = hashTable[idx];
    hashTable[idx] = node;
}

3.2.3 面积计算与比较

c复制double calculate_area(Point p1, Point p2, Point p3) {
    Vector v1 = {p1.x - p3.x, p1.y - p3.y};
    Vector v2 = {p2.x - p3.x, p2.y - p3.y};
    long dot = v1.dx * v2.dx + v1.dy * v2.dy;
    if (dot != 0) return DBL_MAX;
    
    long len1_sq = v1.dx * v1.dx + v1.dy * v1.dy;
    long len2_sq = v2.dx * v2.dx + v2.dy * v2.dy;
    return sqrt(len1_sq * len2_sq);
}

这里通过向量点积判断是否垂直，然后计算两边长度的乘积得到面积。

4. 完整算法流程

4.1 主函数结构

c复制double minAreaFreeRect(int** points, int pointsSize, int* pointsColSize) {
    // 初始化哈希表
    memset(hashTable, 0, sizeof(hashTable));
    
    // 预处理所有点对
    Point* pts = malloc(pointsSize * sizeof(Point));
    for (int i = 0; i < pointsSize; i++) {
        pts[i].x = points[i][0];
        pts[i].y = points[i][1];
    }
    
    // 填充哈希表
    for (int i = 0; i < pointsSize; i++) {
        for (int j = i + 1; j < pointsSize; j++) {
            Segment seg = {
                .p1 = pts[i],
                .p2 = pts[j],
                .distance_sq = distance_sq(pts[i], pts[j]),
                .center = center(pts[i], pts[j])
            };
            insert_segment(seg);
        }
    }
    
    // 查找最小面积矩形
    double min_area = DBL_MAX;
    
    // ... (后续处理)
    
    free(pts);
    return min_area == DBL_MAX ? 0 : min_area;
}

4.2 矩形查找逻辑

c复制for (int i = 0; i < HASH_SIZE; i++) {
    for (HashNode* node1 = hashTable[i]; node1 != NULL; node1 = node1->next) {
        for (HashNode* node2 = node1->next; node2 != NULL; node2 = node2->next) {
            Segment seg1 = node1->seg;
            Segment seg2 = node2->seg;
            
            if (seg1.center.x == seg2.center.x && 
                seg1.center.y == seg2.center.y &&
                seg1.distance_sq == seg2.distance_sq) {
                
                double area = calculate_area(seg1.p1, seg1.p2, seg2.p1);
                if (area < min_area) {
                    min_area = area;
                }
            }
        }
    }
}

5. 优化与边界情况处理

5.1 性能优化技巧

1. 提前终止：当找到面积为1的矩形时可以直接返回，因为这是可能的最小值
2. 哈希冲突处理：使用链表法处理冲突，确保不会丢失任何潜在矩形
3. 内存管理：在程序结束时释放所有分配的哈希节点

5.2 特殊测试用例

需要考虑的特殊情况包括：

1. 所有点共线（应返回0）
2. 点数少于4（应返回0）
3. 存在多个相同点（需要正确处理）
4. 存在多个面积相同的矩形

6. 复杂度分析

• 时间复杂度：O(n^2)用于预处理所有点对，O(n^2)用于查找矩形，总体为O(n^2)
• 空间复杂度：O(n^2)存储所有点对信息

7. 实际编码注意事项

1. 浮点数比较：由于使用浮点数表示面积，比较时应考虑精度误差
2. 整数溢出：在计算距离平方时使用long类型防止溢出
3. 内存释放：C语言需要手动释放所有malloc的内存
4. 哈希函数设计：需要确保不同几何特性的点对不会冲突过多

提示：在实际面试中，可以先实现暴力解法，再逐步优化。解释清楚每种优化背后的几何原理非常重要。

8. 完整代码实现

以下是整合所有优化后的完整实现：

c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <float.h>

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    int dx;
    int dy;
} Vector;

typedef struct {
    Point p1;
    Point p2;
    long distance_sq;
    Point center;
} Segment;

typedef struct HashNode {
    Segment seg;
    struct HashNode* next;
} HashNode;

#define HASH_SIZE 20000
HashNode* hashTable[HASH_SIZE];

unsigned int hash_func(Point center, long dist_sq) {
    return ((center.x * 31 + center.y) * 31 + dist_sq) % HASH_SIZE;
}

void insert_segment(Segment seg) {
    unsigned int idx = hash_func(seg.center, seg.distance_sq);
    HashNode* node = malloc(sizeof(HashNode));
    node->seg = seg;
    node->next = hashTable[idx];
    hashTable[idx] = node;
}

long distance_sq(Point p1, Point p2) {
    long dx = p1.x - p2.x;
    long dy = p1.y - p2.y;
    return dx*dx + dy*dy;
}

Point center(Point p1, Point p2) {
    Point c = {
        .x = p1.x + p2.x,
        .y = p1.y + p2.y
    };
    return c;
}

double calculate_area(Point p1, Point p2, Point p3) {
    Vector v1 = {p1.x - p3.x, p1.y - p3.y};
    Vector v2 = {p2.x - p3.x, p2.y - p3.y};
    long dot = v1.dx * v2.dx + v1.dy * v2.dy;
    if (dot != 0) return DBL_MAX;
    
    long len1_sq = v1.dx * v1.dx + v1.dy * v1.dy;
    long len2_sq = v2.dx * v2.dx + v2.dy * v2.dy;
    return sqrt(len1_sq * len2_sq);
}

double minAreaFreeRect(int** points, int pointsSize, int* pointsColSize) {
    memset(hashTable, 0, sizeof(hashTable));
    
    Point* pts = malloc(pointsSize * sizeof(Point));
    for (int i = 0; i < pointsSize; i++) {
        pts[i].x = points[i][0];
        pts[i].y = points[i][1];
    }
    
    for (int i = 0; i < pointsSize; i++) {
        for (int j = i + 1; j < pointsSize; j++) {
            Segment seg = {
                .p1 = pts[i],
                .p2 = pts[j],
                .distance_sq = distance_sq(pts[i], pts[j]),
                .center = center(pts[i], pts[j])
            };
            insert_segment(seg);
        }
    }
    
    double min_area = DBL_MAX;
    
    for (int i = 0; i < HASH_SIZE; i++) {
        for (HashNode* node1 = hashTable[i]; node1 != NULL; node1 = node1->next) {
            for (HashNode* node2 = node1->next; node2 != NULL; node2 = node2->next) {
                Segment seg1 = node1->seg;
                Segment seg2 = node2->seg;
                
                if (seg1.center.x == seg2.center.x && 
                    seg1.center.y == seg2.center.y &&
                    seg1.distance_sq == seg2.distance_sq) {
                    
                    double area = calculate_area(seg1.p1, seg1.p2, seg2.p1);
                    if (area < min_area) {
                        min_area = area;
                        if (min_area == 1) goto cleanup; // 提前终止
                    }
                }
            }
        }
    }
    
cleanup:
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = hashTable[i];
        while (node != NULL) {
            HashNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    free(pts);
    
    return min_area == DBL_MAX ? 0 : min_area;
}

9. 测试用例验证

建议使用以下测试用例验证代码正确性：

1. 常规测试：

   c复制int points1[4][2] = {{1,2},{2,1},{1,0},{0,1}};
   // 应返回 2.0
   

2. 无矩形情况：

   c复制int points2[4][2] = {{0,1},{2,1},{1,1},{1,0}};
   // 应返回 0
   

3. 最小面积：

   c复制int points3[4][2] = {{0,1},{1,0},{2,1},{1,2}};
   // 应返回 1.0
   

4. 多点共线：

   c复制int points4[5][2] = {{0,0},{0,1},{0,2},{1,0},{1,1}};
   // 应返回 0
   

10. 扩展思考

这个问题可以进一步扩展为：

1. 找出所有可能的矩形而不仅仅是面积最小的
2. 处理三维空间中的最小体积盒子
3. 当点数非常大时的近似算法

在实际工程应用中，类似的几何算法常用于：

• 计算机视觉中的形状检测
• 图形学中的碰撞检测
• GIS系统中的区域划分