给定点可能的四边形数量

在平面几何中，四边形是由四个顶点和四条直线段组成的形状。给定点集中可能的四边形数量是计算机计算几何学中重要的问题之一。本文将介绍这个问题及其解决方法。

问题描述

给定平面上的n个点，求可以由这些点组成的四边形的数量。这个问题可以转化为在所有可能的点对之间找到四条边构成四边形的方案数。

暴力解法

暴力解法是枚举所有可能的点对，判断是否存在两个点对能组成一个四边形，时间复杂度为$O(n^4)$。代码如下：

int numOfQuadrilaterals(Point[] points) {
    int count = 0;
    for (int i = 0; i < points.length; i++) {
        for (int j = i + 1; j < points.length; j++) {
            for (int k = j + 1; k < points.length; k++) {
                for (int l = k + 1; l < points.length; l++) {
                    if (isQuadrilateral(points[i], points[j], points[k], points[l])) {
                        count++;
                    }
                }
            }
        }
    }
    return count;
}

这个算法可以计算出正确的答案，但是当点的数量很大时，时间复杂度会非常高，不适用于实际情况。

优化算法

为了优化暴力解法的时间复杂度，需要利用一些性质来缩小搜索空间。

性质1

四边形的对边平行。

由于对边平行，因此可以只枚举所有可能的点对，然后判断这两个点是否有对边平行的四边形。对于每个点对，需要找到与之对称的点对，这个过程可以用哈希表来实现，时间复杂度为$O(n^2)$。代码如下：

int numOfQuadrilaterals(Point[] points) {
    Map<Integer, List<Integer>> pointPairs = new HashMap<>();
    for (int i = 0; i < points.length; i++) {
        for (int j = i + 1; j < points.length; j++) {
            int key = getKey(points[i], points[j]);
            List<Integer> pair = pointPairs.getOrDefault(key, new ArrayList<>());
            pair.add(i);
            pair.add(j);
            pointPairs.put(key, pair);
        }
    }
    int count = 0;
    for (List<Integer> pair : pointPairs.values()) {
        int i = pair.get(0);
        int j = pair.get(1);
        for (int k = 0; k < points.length; k++) {
            if (k != i && k != j) {
                int l = getSymmetricPoint(i, j, k, points);
                if (l > k && isQuadrilateral(points[i], points[j], points[k], points[l])) {
                    count++;
                }
            }
        }
    }
    return count;
}

private int getKey(Point p1, Point p2) {
    if (p1.x > p2.x || (p1.x == p2.x && p1.y > p2.y)) {
        return getKey(p2, p1);
    }
    return Objects.hash(p1.x, p1.y, p2.x - p1.x, p2.y - p1.y);
}

private int getSymmetricPoint(int i, int j, int k, Point[] points) {
    int x = points[i].x + points[j].x - points[k].x;
    int y = points[i].y + points[j].y - points[k].y;
    for (int l = 0; l < points.length; l++) {
        if (l != i && l != j && points[l].x == x && points[l].y == y) {
            return l;
        }
    }
    return -1;
}

性质2

两条对边长度相等且对角线垂直。

根据勾股定理，两条长度相等的斜边所对应的直角分别在对角线的中点处。因此可以枚举所有长度相等的点对，然后选出它们的中点，再枚举中点的所有点对，判断是否在一条相垂直的对角线上。时间复杂度为$O(n^3)$。代码如下：

int numOfQuadrilaterals(Point[] points) {
    Map<Double, List<Integer>> lenPairs = new HashMap<>();
    for (int i = 0; i < points.length; i++) {
        for (int j = i + 1; j < points.length; j++) {
            double len = getLength(points[i], points[j]);
            List<Integer> pair = lenPairs.getOrDefault(len, new ArrayList<>());
            pair.add(i);
            pair.add(j);
            lenPairs.put(len, pair);
        }
    }
    int count = 0;
    for (List<Integer> pair : lenPairs.values()) {
        for (int i = 0; i < pair.size(); i += 2) {
            for (int j = i + 2; j < pair.size(); j += 2) {
                int mid1 = getMidpoint(pair.get(i), pair.get(i + 1), pair.get(j), pair.get(j + 1), points);
                for (int k = 0; k < points.length; k++) {
                    if (k != pair.get(i) && k != pair.get(i + 1) && k != pair.get(j) && k != pair.get(j + 1)) {
                        int mid2 = getMidpoint(pair.get(i), pair.get(i + 1), k, getSymmetricPoint(k, mid1, points), points);
                        if (isPerpendicular(points[pair.get(i)], points[pair.get(i + 1)], points[k], points[mid1])
                                && isPerpendicular(points[pair.get(j)], points[j + 1], points[k], points[getSymmetricPoint(k, mid1, points)])) {
                            count++;
                        }
                    }
                }
            }
        }
    }
    return count;
}

private double getLength(Point p1, Point p2) {
    return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
}

private int getMidpoint(int i, int j, int k, int l, Point[] points) {
    int x = (points[i].x + points[j].x + points[k].x + points[l].x) / 4;
    int y = (points[i].y + points[j].y + points[k].y + points[l].y) / 4;
    int mid = -1;
    int dist = Integer.MAX_VALUE;
    for (int m = 0; m < points.length; m++) {
        if (m != i && m != j && m != k && m != l) {
            int d = getDistance(x, y, points[m].x, points[m].y);
            if (d < dist) {
                mid = m;
                dist = d;
            }
        }
    }
    return mid;
}

private int getSymmetricPoint(int i, int j, Point[] points) {
    int x = points[i].x + points[j].x;
    int y = points[i].y + points[j].y;
    for (int k = 0; k < points.length; k++) {
        if (k != i && k != j && points[k].x == x && points[k].y == y) {
            return k;
        }
    }
    return -1;
}

private int getDistance(int x1, int y1, int x2, int y2) {
    return (int) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}

private boolean isPerpendicular(Point p1, Point p2, Point p3, Point p4) {
    int dx1 = p2.x - p1.x;
    int dy1 = p2.y - p1.y;
    int dx2 = p4.x - p3.x;
    int dy2 = p4.y - p3.y;
    return dx1 * dx2 + dy1 * dy2 == 0;
}

结论

给定点可能的四边形数量的时间复杂度可以优化为$O(n^3)$或者$O(n^2)$，具体算法取决于点集的性质。

参考文献

[1] de Berg, M., van Kreveld, M., Overmars, M., & Schwarzkopf, O. (2008). Computational Geometry: Algorithms and Applications. Springer.