L3-021 神坛

题目链接：

L3-021 神坛

 

题目：

在古老的迈瑞城，巍然屹立着 n 块神石。长老们商议，选取 3 块神石围成一个神坛。因为神坛的能量强度与它的面积成反比，因此神坛的面积越小越好。特殊地，如果有两块神石坐标相同，或者三块神石共线，神坛的面积为 0.000。

长老们发现这个问题没有那么简单，于是委托你编程解决这个难题。

输入格式：

输入在第一行给出一个正整数 n（3 ≤ n ≤ 5000）。随后 n 行，每行有两个整数，分别表示神石的横坐标、纵坐标（−10​9​​≤ 横坐标、纵坐标 <10​9​​）。

输出格式：

在一行中输出神坛的最小面积，四舍五入保留 3 位小数。

输入样例：

8
3 4
2 4
1 1
4 1
0 3
3 0
1 3
4 2

输出样例：

0.500

 

题目简单分析：

邓公出的题目，果然非计算几何莫属。

 最普遍应用的便是  对每个点的其他点进行极角排序，然后仅计算相邻向量组成的三角形面积

如下图：

1. 简单来说：本题就是求一系列点中可以组成的面积最小的三角形
2. 最简单的做法自然是暴力枚举，复杂度O(n^3)，自然是要超时的，不过可以骗点分
3. 寻找优化策略：

计算A点，此时对与A与其他点组成的向量进行极角排序，本质就是使其他点绕着A点按照顺时针或者逆时针排序，这样就可以得到相邻的两点与A点组成的相邻向量

故计算A点时，仅需计算三角形ABC、ACD、ADE、AEF

整体复杂度变为 nlogn（需要以每一个点为极点进行计算 为n  &  极角排序nlogn）

 

可惜的是该种处理方式仅能通过所有的测试样例，然而并不是一个正确的解决方式，所以从算法上来说是错误的

相对来说，计算相邻向量组成的三角形只能说得到的是相对较优的结果，并不是一定最优

反例如下图：最小面积三角形应为DEF

       4. 目前我并未找到其他正确的低复杂度的算法，希望有相关想法或解法的伙伴能够告知，拯救一下我。

 

极角排序：

实质见上

相关算法较多：

应用叉积进行比较排序、应用atan2计算极角排序、分象限处理等

可参考博客：极角排序

下列代码采取的是应用叉积进行排序

如上上图：向量 AB(x1, y1)、AC(x2, y2)、AE(x3, y3）……

顺时针：C在B后  即 x1*y2 - x2*y1 < 0

 

AC_Code:

此处采坑：

全程采用double处理所有数据，有两个测试点无法通过

参考了博客PTA L3-021 神坛，全程采取long long数据类型进行处理，AC。感谢！

个人感觉是输入数据以及前期计算均为整型，用longlong更为精确，double本身便是不太精确的。

有哪位伙伴知其中具体原由，还望告知，笔芯。

//L3-021 神坛
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#define MINI 10e-6
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;


//向量或点的坐标表示
struct vect
{
    ll x, y;
    bool operator <(vect& a){   //仅须按照顺序即可，无所谓顺时针逆时针
        return a.x*y < x*a.y;
    }
};

ll tri_area(vect a, vect b){
    return abs(a.x*b.y - a.y*b.x);   //可将/2运算放置最后处理ans
}

int main(){
    int i, n;
    ll ans=10e17;
    double res;
    scanf("%d", &n);
    vect d[n], v[n];
    for(i=0; i<n; i++)
        scanf("%lld %lld", &d[i].x, &d[i].y);
    for(i=0; i<n; i++){
        int k=0;
        for(int j=0; j<n; j++){
            if (j==i) continue;
            v[k].x = d[j].x - d[i].x;
            v[k].y = d[j].y - d[i].y;
            k++;
        }
        sort(v, v+k);
        for(int j=0; j<n-2; j++){
            ans = min(ans, tri_area(v[j], v[j+1]));
        }
        if(ans < MINI) break;
    }
    res = ans*1.0/2;
    printf("%.3lf\n", res);
    return 0;
}

前期版本代码：

未AC，权当纪念。。。。。

//版本二
//因为全程使用double，可能因为计算的问题，两个测试点未通过
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#define MINI 10e-6
#define INF 0x3f3f3f3f
#define ll long long
using namespace std;


//向量或点的坐标表示
struct vect
{
    double x, y;
    bool operator <(vect& a){   //仅须按照顺序即可，无所谓顺时针逆时针
        return a.x*y < x*a.y;
    }
};

double tri_area(vect a, vect b){
    return abs(a.x*b.y - a.y*b.x)/2;   //可将/2运算放置最后处理ans
}

int main(){
    int i, n;
    double ans=10e18, tmp;
    scanf("%d", &n);
    vect d[n], v[n];
    for(i=0; i<n; i++)
        scanf("%lf %lf", &d[i].x, &d[i].y);
    for(i=0; i<n; i++){
        int k=0;
        for(int j=0; j<n; j++){
            if (j==i) continue;
            v[k].x = d[j].x - d[i].x;
            v[k].y = d[j].y - d[i].y;
            k++;
        }
        sort(v, v+k);
        for(int j=0; j<n-2; j++){
            ans = min(ans, tri_area(v[j], v[j+1]));
        }
        if(ans < MINI) break;
    }
    printf("%.3lf\n", ans);
    return 0;
}

//版本一
//暴力 超时是必然，但还是皮了皮试一下
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#define MINI 10e-6
#define INF 0x3f3f3f3f
using namespace std;

struct dot
{
    double x, y;
};

double tri_area(dot a, dot b, dot c){
    return abs((c.x-a.x)*(b.y-a.y) - (b.x-a.x)*(c.y-a.y))/2;
}

int main(){
    int i, n;
    double ans=INF, tmp;
    scanf("%d", &n);
    dot d[n];
    for(i=0; i<n; i++)
        scanf("%lf %lf", &d[i].x, &d[i].y);
    for(i=0; i<n; i++){
        for(int j=i+1; j<n; j++){
            for(int k=j+1; k<n; k++){
                tmp = tri_area(d[i], d[j], d[k]);
                if(ans > tmp) ans = tmp;
            }
        }
    }
    printf("%.3lf\n", ans);
    return 0;
}