[数据结构] 最小覆盖圆

这个数据结构是根据 最小覆盖圆 算法进行改造得到，主要是描述一个圆的半径、圆心坐标、圆覆盖的点的圆，以及维护一个加入点的操作(push_point方法)。

成员变量如下：

• Center 圆心坐标，是一个struct point类型
• Radius 圆的半径，是一个double类型
• allPoint 点的数组，是一个vector< struct point >类型，表示这个圆覆盖的所有点

成员方法如下：

• bool inside_circle (const point&)：判断输入的point是否在圆内，在圆内则返回ture，否则返回false
• void push_point (const point&)：加入一个点，具体操作如下：
1. 将该点加入allPoint数组
2. 判断这个点的是否在圆内部，如果在圆内部直接返回
3. 如果这个点在圆外部，则进行最小圆覆盖算法处理：从allPoint数组中进行枚举出一个或者两个点与push_point输入的点来形成新的圆（最小覆盖圆算法）
   1. 　　枚举一个点的原因是会存在钝角三角形的外接圆情况，此时这个钝角三角的外接圆一定可以缩小为其中两个点为直径的圆。

cpp代码：

struct point {
    double x,y;

    point():x(0.0),y(0.0) {}
    point(double x, double y): x(x),y(y) {}

    point operator + (const point &p) const { // (x1+x2), (y1+y2)
        return {this->x + p.x, this->y + p.y};
    }
    point operator - (const point &p) const { // (x1-x2), (y1-y2)
        return {this->x - p.x, this->y - p.y};
    }
    point operator / (const double &number) const { // (x / n), (y / n)
        return {this->x / number, this->y / number};
    }
    double distance (const point &p) const { // sq_distance = ((x1 - x2)^2 + (y1 - y2)^2) = distance^2
        return (this->x - p.x) * (this->x - p.x) + (this->y - p.y) * (this->y - p.y);
    }
    point circumcenter (const point &p1, const point &p2) const { // The center of the circumscribed circle of three points
        double x1 = this->x, x2 = p1.x, x3 = p2.x;
        double y1 = this->y, y2 = p1.y, y3 = p2.y;
        if ( (y2 - y1) * (x3 - x1) == (x2 - x1) * (y3 - y1)) {
            double d1 = this->distance(p1); // this and p1
            double d2 = this->distance(p2); // this and p2
            double d3 = p1.distance(p2); // p1 and p3
            if (d1 > d2 && d1 > d3) {
                return (*this + p1) / 2.0;
            } else if (d2 > d3) {
                return (*this + p2) / 2.0;
            } else {
                return (p1 + p2) / 2.0;
            }
        }
        double new_x = ((y2-y1)*(y3*y3-y1*y1+x3*x3-x1*x1)-(y3-y1)*(y2*y2-y1*y1+x2*x2-x1*x1)) / (2.0*((x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)));
        double new_y = ((x2-x1)*(x3*x3-x1*x1+y3*y3-y1*y1)-(x3-x1)*(x2*x2-x1*x1+y2*y2-y1*y1)) / (2.0*((y3-y1)*(x2-x1)-(y2-y1)*(x3-x1)));
        return {new_x, new_y};
    }
};
struct circle {
    point center;
    double radius;
    std::vector< point > all_points;

    circle (): center(point()), radius(0.0) {}

    bool inside_point (const point &p) const { // if distance <= radius, return true;
        return p.distance(this->center) <= this->radius;
    }

    void push_point (const point &p) {
        this->all_points.push_back(p);

        if(this->inside_point(p)) return;

        this->center = p;
        this->radius = 0.0;

        for (auto i = 0; i < this->all_points.size() - 1; i++) {
            if( this->inside_point(this->all_points[i]) ) continue;

            this->center = (p + this->all_points[i]) / 2.0;
            this->radius = p.distance(this->center);

            for (int j = 0; j < i; j++) {
                if(this->inside_point(this->all_points[j])) continue;

                this->center = p.circumcenter(this->all_points[i], this->all_points[j]);
                this->radius = p.distance(this->center);
            }
        }
    }
};