HDU 5839 Special Tetrahedron(计算几何)

/**
题意：给出n个三维空间的点的坐标，问有多少个特殊的四面体，四面体的定义:至少四条边相等，如果恰好四条边相等，那么不相等的两条边应该不相邻

思路：枚举每条边， 然后枚举每个点， 要是一个点和该边的中点的连线和该边垂直的话，那么关于这条边记录下这个点，并记录该点到该边中点的距离，
这个距离可以用距离的平方放大四倍表示，就一定是整数了，记录下所有点之后，再枚举每条边中相关的每个点， 寻找一样和该边垂直且到该边中点距离
相等的点，这样一定组成了一个至少四条边相等的四面体，注意四个点不能共面，这样计算下来一个正四面体计算了12次，其他特殊四面体计算了4次，用
除法原理后相加即为答案
**/
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<map>
#include<algorithm>
const int maxn = 200 + 10;
const int mod = 1e9 + 7;
const int INF = 1e9;
using namespace std;

struct point {
    int x, y, z;
    int dis;
    point() {}
    point(int x, int y, int z, int d) :
        x(x), y(y), z(z), dis(d) {}
    bool operator < (point p) const {
        if(dis != p.dis) return dis < p.dis;
        if(x != p.x) return x < p.x;
        if(y != p.y) return y < p.y;
        return z < p.z;
    }
    void input() { scanf("%d %d %d", &x, &y, &z); }
} p[maxn];
pair<point, point> res[maxn * maxn];
vector<point> G[maxn * maxn];
int T, n, d[maxn * maxn], kase = 1;

int dist(point p1, point p2) { ///距离的平方
    int dx = p1.x - p2.x;
    int dy = p1.y - p2.y;
    int dz = p1.z - p2.z;
    return dx*dx + dy*dy + dz*dz;
}

point dc_point(point p1, point p2, point pt) {  ///pt点 关于p1 - p2的对称点
    int dx = p1.x + p2.x - pt.x;
    int dy = p1.y + p2.y - pt.y;
    int dz = p1.z + p2.z - pt.z;
    return point(dx, dy, dz, 0);
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for(int i = 0; i < maxn * maxn; i++) G[i].clear();
        for(int i = 0; i < n; i++) {
            int x, y, z;
            scanf("%d %d %d", &x, &y, &z);
            p[i] = point(x, y, z, 0);
        }
        int num = 0;
        for(int i = 0; i < n; i++) {
            for(int j = i + 1; j < n; j++) {
                point p1 = p[i], p2 = p[j];
                for(int k = 0; k < n; k++) {
                    if(k == i || k == j) continue;
                    point pt = p[k];
                    int dx = p1.x + p2.x - pt.x;
                    int dy = p1.y + p2.y - pt.y;
                    int dz = p1.z + p2.z - pt.z;
                    int dt = (p1.x - p2.x) * (dx - pt.x);
                    dt += (p1.y - p2.y) * (dy - pt.y);
                    dt += (p1.z - p2.z) * (dz - pt.z);
                    if(dt) continue;
                    int dis = dist(pt, point(dx, dy, dz, 0));
                    G[num].push_back(point(pt.x, pt.y, pt.z, dis));
                }
                sort(G[num].begin(), G[num].end());
                d[num] = dist(p1, p2);
                res[num].first = p1; res[num].second = p2;
                num++;
            }
        }
        int ans1 = 0, ans2 = 0;
        for(int i = 0; i < num; i++) {
            for(int j = 0; j < G[i].size(); j++) {
                point t = G[i][j], ks = point(-INF, -INF, -INF, t.dis);
                int x = lower_bound(G[i].begin(), G[i].end(), ks) - G[i].begin();
                int k = x;
                point dc = dc_point(res[i].first, res[i].second, t);
                while(k < G[i].size() && G[i][k].dis == t.dis) {
                    if(k == j) { k++; continue; }
                    point nt = G[i][k];
                    if(dc.x == nt.x && dc.y == nt.y && dc.z == nt.z) { k++; continue; }
                    int d1 = d[i], d2 = dist(res[i].first, t);
                    int d3 = dist(t, nt);
                    if(d1 == d2 && d2 == d3) ans2++;
                    else ans1++;
                    k++;
                }
            }
        }
        printf("Case #%d: %d\n", kase++, ans1 / 4 + ans2 / 12);
    }
    return 0;
}