Quickhull 快包算法解决凸包问题

凸包问题是一个与平面上的点集合相关的问题，它的目标是找到一个凸多边形，这个多边形包含了给定的 n 个点，使得这个多边形是包含这些点的最小凸集合。

现在让我们来解释一些相关的定义：

1. 凸集合：对于平面上的一个点集合，如果集合中的任意两点之间的线段都在这个集合内部，那么这个集合被称为凸集合。

2. 凸包：凸包是包含给定点集合的最小凸集合。这意味着凸包是所有包含这些点的凸集合中最小的一个。

3. 凸包的极点：凸包形成的凸多边形的顶点被称为凸包的极点。换句话说，这些极点是不能由集合中其他点构成的线段的中点。

当计算平面上一组点的凸包时，有一种常用的方法叫做分治法或分裂方法。这个方法将问题分成更小的部分，分别处理它们，然后将结果组合起来以获得整个凸包。

让我用更简单的语言和示例来解释：

步骤1： 首先，我们要找到点集合中最左边和最右边的两个点。这两个点肯定是凸包的一部分，因为它们位于最外侧。

示例： 假设我们有一组点，它们按照 x 坐标从小到大排列，如下：

(1, 2), (2, 4), (3, 1), (5, 3), (7, 5)

在这个示例中，最左边的点是 (1, 2)，最右边的点是 (7, 5)。

步骤2： 接下来，我们将这些点分成两部分，上集合和下集合。上集合包括那些位于凸包上方的点，下集合包括那些位于凸包下方的点。

示例： 在我们的示例中，将这些点分成上集合和下集合：

• 上集合包括 (3, 1) 和 (5, 3)，因为它们位于最左边点 (1, 2) 和最右边点 (7, 5) 构成的直线的上方。
• 下集合包括 (2, 4)，因为它在这条直线的下方。

步骤3： 接下来，我们需要找出上集合的凸包。这就意味着我们要找到上集合中距离直线最远的点作为凸包的顶点。

示例： 在上集合中，点 (3, 1) 是距离直线最远的点，因此它是上包的一个顶点。

步骤4： 接下来，我们重复步骤1到步骤3，但这次是对下集合进行操作。找到下集合的凸包。

步骤5： 最后，将上包和下包的结果合并，以获得整个凸包。

示例： 在我们的示例中，上包的顶点是 (3, 1)，下包的顶点是 (2, 4)。将它们合并，得到整个凸包。

如何使用行列式判断点在直线的位置：

考虑一条直线 和一个点 。

1. 首先，我们构建一个矩阵，其中第一行是直线的方程的系数，第二行是点的坐标，如下所示：| a  b  c |
          | x1 y1 1 |

2. 然后，计算这个矩阵的行列式值。行列式值的正负决定了点 在直线的左侧还是右侧。

   1. 如果行列式值为正，那么点 在直线的左侧。
   2. 如果行列式值为零，点 在直线上。
   3. 如果行列式值为负，点 在直线的右侧。

这种方法允许我们快速确定点相对于直线的位置，并且还可以计算出点到直线的距离，距离等于行列式值的绝对值。

时间复杂度：

时间复杂度表示算法所需的运行时间与输入规模的关系。在这种情况下，时间复杂度取决于点的数量，通常用 n 表示。

• 最佳情况：在最佳情况下，分治法的时间复杂度可以达到 O(n log n)。这是一种高效的算法，适用于大多数情况。

• 最坏情况：在最坏情况下，时间复杂度为 O(n^2)。这种情况通常发生在点的分布不均匀或特殊情况下。

示例：

让我们用一个简单的示例来说明如何使用行列式判断点相对于直线的位置。考虑以下直线和点：

直线方程：2x - 3y + 1 = 0 点坐标：(4, 2)

首先，构建矩阵：

|  2  -3   1 |
|  4   2   1 |
 

然后计算行列式值：
Det = (2 * 2) - (-3 * 4) = 4 + 12 = 16

因为行列式值为正（16），所以点 (4, 2) 位于直线 2x - 3y + 1 = 0 的左侧。

这种方法可以用于快速确定点相对于直线的位置。

#include <iostream>
#include <algorithm>
#include <vector>

struct Vertex {
    double x;
    double y;
};

using Points = std::vector<Vertex>;

bool CompareVertex(const Vertex& a, const Vertex& b) {
    if (a.x == b.x) {
        return a.y < b.y;
    } else {
        return a.x < b.x;
    }
}

Points FindHull(const Points& originSet, const Vertex& p1, const Vertex& p2, bool findUpper) {
    Points upperSet;

    Vertex p_max;
    double maxDistance = -1.0;
    for (auto iter = originSet.begin(); iter != originSet.end(); iter++) {
        double distance = p1.x * p2.y + (iter->x) * p1.y + p2.x * (iter->y) - (iter->x) * p2.y - p2.x * p1.y - p1.x * (iter->y);
        if ((findUpper && distance > 0.0) || (!findUpper && distance < 0.0)) {
            upperSet.push_back(*iter);
            distance = std::abs(distance);
            if (distance > maxDistance) {
                p_max = (*iter);
                maxDistance = distance;
            }
        }
    }

    if (maxDistance > 0.0) {
        Points SubHull1 = FindHull(upperSet, p1, p_max, findUpper);
        Points SubHull2 = FindHull(upperSet, p_max, p2, findUpper);
        SubHull1.insert(SubHull1.begin(), SubHull2.begin(), SubHull2.end());
        SubHull1.push_back(p_max);
        return SubHull1;
    } else {
        return Points(); // empty
    }
}

Points QuickHull(const Points& originSet) {
    Points sortedSet = originSet;
    std::sort(sortedSet.begin(), sortedSet.end(), CompareVertex);

    Points upperHull = FindHull(sortedSet, sortedSet.front(), sortedSet.back(), true);
    Points lowerHull = FindHull(sortedSet, sortedSet.front(), sortedSet.back(), false);

    upperHull.insert(upperHull.begin(), lowerHull.begin(), lowerHull.end());
    upperHull.push_back(sortedSet.front());
    upperHull.push_back(sortedSet.back());

    return upperHull;
}

void PrintPoints(const Points& points) {
    for (const auto& vertex : points) {
        std::cout << vertex.x << ' ' << vertex.y << std::endl;
    }
}

int main() {
    Points originSet = {{1.0, 1.0}, {2.0, 2.0}, {3.0, 1.0}, {3.0, 3.0}, {1.0, 3.0}};
    Points convexHull = QuickHull(originSet);

    PrintPoints(convexHull);

    return 0;
}