POJ 2208 Pyramids（求四面体体积）

Description

Recently in Farland, a country in Asia, a famous scientist Mr. Log Archeo has discovered ancient pyramids. But unlike those in Egypt and Central America, they have triangular (not rectangular) foundation. That is, they are tetrahedrons in mathematical sense. In order to find out some important facts about the early society of the country (it is widely believed that the pyramid sizes are in tight connection with Farland ancient calendar), Mr. Archeo needs to know the volume of the pyramids. Unluckily, he has reliable data about their edge lengths only. Please, help him!

Input

The file contains six positive integer numbers not exceeding 1000 separated by spaces, each number is one of the edge lengths of the pyramid ABCD. The order of the edges is the following: AB, AC, AD, BC, BD, CD.

Output

A real number -- the volume printed accurate to four digits after decimal point.

 

题目大意：给四面体的六条边，求这个四面体的体积。

思路：用欧拉四面体公式，注意每条边的对应关系。

 

代码（47MS）：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 using namespace std;
 #define sqr(x) ((x) * (x))

 typedef long long LL;
 typedef long double LD;

 const int MAXN = ;
 const double EPS = 1e-;
 const double PI = acos(-1.0);//3.14159265358979323846
 const double INF = ;

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 struct Point {
     double x, y, ag;
     Point() {}
     Point(double x, double y): x(x), y(y) {}
     void read() {
         scanf("%lf%lf", &x, &y);
     }
     bool operator == (const Point &rhs) const {
         return sgn(x - rhs.x) ==  && sgn(y - rhs.y) == ;
     }
     bool operator < (const Point &rhs) const {
         if(y != rhs.y) return y < rhs.y;
         return x < rhs.x;
     }
     Point operator + (const Point &rhs) const {
         return Point(x + rhs.x, y + rhs.y);
     }
     Point operator - (const Point &rhs) const {
         return Point(x - rhs.x, y - rhs.y);
     }
     Point operator * (const double &b) const {
         return Point(x * b, y * b);
     }
     Point operator / (const double &b) const {
         return Point(x / b, y / b);
     }
     double operator * (const Point &rhs) const {
         return x * rhs.x + y * rhs.y;
     }
     double length() {
         return sqrt(x * x + y * y);
     }
     double angle() {
         return atan2(y, x);
     }
     Point unit() {
         return *this / length();
     }
     void makeAg() {
         ag = atan2(y, x);
     }
     void print() {
         printf("%.10f %.10f\n", x, y);
     }
 };
 typedef Point Vector;

 double dist(const Point &a, const Point &b) {
     return (a - b).length();
 }

 double cross(const Point &a, const Point &b) {
     return a.x * b.y - a.y * b.x;
 }
 //ret >= 0 means turn right
 double cross(const Point &sp, const Point &ed, const Point &op) {
     return cross(sp - op, ed - op);
 }

 double area(const Point& a, const Point &b, const Point &c) {
     return fabs(cross(a - c, b - c)) / ;
 }
 //counter-clockwise
 Point rotate(const Point &p, double angle, const Point &o = Point(, )) {
     Point t = p - o;
     double x = t.x * cos(angle) - t.y * sin(angle);
     double y = t.y * cos(angle) + t.x * sin(angle);
     return Point(x, y) + o;
 }

 double cosIncludeAngle(const Point &a, const Point &b, const Point &o) {
     Point p1 = a - o, p2 = b - o;
     return (p1 * p2) / (p1.length() * p2.length());
 }

 double includedAngle(const Point &a, const Point &b, const Point &o) {
     return acos(cosIncludeAngle(a, b, o));
     /*
     double ret = abs((a - o).angle() - (b - o).angle());
     if(sgn(ret - PI) > 0) ret = 2 * PI - ret;
     return ret;
     */
 }

 struct Seg {
     Point st, ed;
     double ag;
     Seg() {}
     Seg(Point st, Point ed): st(st), ed(ed) {}
     void read() {
         st.read(); ed.read();
     }
     void makeAg() {
         ag = atan2(ed.y - st.y, ed.x - st.x);
     }
 };
 typedef Seg Line;

 //ax + by + c > 0
 Line buildLine(double a, double b, double c) {
     if(sgn(a) ==  && sgn(b) == ) return Line(Point(sgn(c) >  ? - : , INF), Point(, INF));
     if(sgn(a) == ) return Line(Point(sgn(b), -c/b), Point(, -c/b));
     if(sgn(b) == ) return Line(Point(-c/a, ), Point(-c/a, sgn(a)));
     if(b < ) return Line(Point(, -c/b), Point(, -(a + c) / b));
     else return Line(Point(, -(a + c) / b), Point(, -c/b));
 }

 void moveRight(Line &v, double r) {
     double dx = v.ed.x - v.st.x, dy = v.ed.y - v.st.y;
     dx = dx / dist(v.st, v.ed) * r;
     dy = dy / dist(v.st, v.ed) * r;
     v.st.x += dy; v.ed.x += dy;
     v.st.y -= dx; v.ed.y -= dx;
 }

 bool isOnSeg(const Seg &s, const Point &p) {
     return (p == s.st || p == s.ed) ||
         (((p.x - s.st.x) * (p.x - s.ed.x) <  ||
           (p.y - s.st.y) * (p.y - s.ed.y) < ) &&
          sgn(cross(s.ed, p, s.st)) == );
 }

 bool isInSegRec(const Seg &s, const Point &p) {
     return sgn(min(s.st.x, s.ed.x) - p.x) <=  && sgn(p.x - max(s.st.x, s.ed.x)) <=
         && sgn(min(s.st.y, s.ed.y) - p.y) <=  && sgn(p.y - max(s.st.y, s.ed.y)) <= ;
 }

 bool isIntersected(const Point &s1, const Point &e1, const Point &s2, const Point &e2) {
     return (max(s1.x, e1.x) >= min(s2.x, e2.x)) &&
         (max(s2.x, e2.x) >= min(s1.x, e1.x)) &&
         (max(s1.y, e1.y) >= min(s2.y, e2.y)) &&
         (max(s2.y, e2.y) >= min(s1.y, e1.y)) &&
         (cross(s2, e1, s1) * cross(e1, e2, s1) >= ) &&
         (cross(s1, e2, s2) * cross(e2, e1, s2) >= );
 }

 bool isIntersected(const Seg &a, const Seg &b) {
     return isIntersected(a.st, a.ed, b.st, b.ed);
 }

 bool isParallel(const Seg &a, const Seg &b) {
     return sgn(cross(a.ed - a.st, b.ed - b.st)) == ;
 }

 //return Ax + By + C =0 's A, B, C
 void Coefficient(const Line &L, double &A, double &B, double &C) {
     A = L.ed.y - L.st.y;
     B = L.st.x - L.ed.x;
     C = L.ed.x * L.st.y - L.st.x * L.ed.y;
 }
 //point of intersection
 Point operator * (const Line &a, const Line &b) {
     double A1, B1, C1;
     double A2, B2, C2;
     Coefficient(a, A1, B1, C1);
     Coefficient(b, A2, B2, C2);
     Point I;
     I.x = - (B2 * C1 - B1 * C2) / (A1 * B2 - A2 * B1);
     I.y =   (A2 * C1 - A1 * C2) / (A1 * B2 - A2 * B1);
     return I;
 }

 bool isEqual(const Line &a, const Line &b) {
     double A1, B1, C1;
     double A2, B2, C2;
     Coefficient(a, A1, B1, C1);
     Coefficient(b, A2, B2, C2);
     return sgn(A1 * B2 - A2 * B1) ==  && sgn(A1 * C2 - A2 * C1) ==  && sgn(B1 * C2 - B2 * C1) == ;
 }

 double Point_to_Line(const Point &p, const Line &L) {
     return fabs(cross(p, L.st, L.ed)/dist(L.st, L.ed));
 }

 double Point_to_Seg(const Point &p, const Seg &L) {
     if(sgn((L.ed - L.st) * (p - L.st)) < ) return dist(p, L.st);
     if(sgn((L.st - L.ed) * (p - L.ed)) < ) return dist(p, L.ed);
     return Point_to_Line(p, L);
 }

 double Seg_to_Seg(const Seg &a, const Seg &b) {
     double ans1 = min(Point_to_Seg(a.st, b), Point_to_Seg(a.ed, b));
     double ans2 = min(Point_to_Seg(b.st, a), Point_to_Seg(b.ed, a));
     return min(ans1, ans2);
 }

 struct Circle {
     Point c;
     double r;
     Circle() {}
     Circle(Point c, double r): c(c), r(r) {}
     void read() {
         c.read();
         scanf("%lf", &r);
     }
     double area() const {
         return PI * r * r;
     }
     bool contain(const Circle &rhs) const {
         return sgn(dist(c, rhs.c) + rhs.r - r) <= ;
     }
     bool contain(const Point &p) const {
         return sgn(dist(c, p) - r) <= ;
     }
     bool intersect(const Circle &rhs) const {
         return sgn(dist(c, rhs.c) - r - rhs.r) < ;
     }
     bool tangency(const Circle &rhs) const {
         return sgn(dist(c, rhs.c) - r - rhs.r) == ;
     }
     Point pos(double angle) const {
         Point p = Point(c.x + r, c.y);
         return rotate(p, angle, c);
     }
 };

 double CommonArea(const Circle &A, const Circle &B) {
     double area = 0.0;
     const Circle & M = (A.r > B.r) ? A : B;
     const Circle & N = (A.r > B.r) ? B : A;
     double D = dist(M.c, N.c);
     if((D < M.r + N.r) && (D > M.r - N.r)) {
         double cosM = (M.r * M.r + D * D - N.r * N.r) / (2.0 * M.r * D);
         double cosN = (N.r * N.r + D * D - M.r * M.r) / (2.0 * N.r * D);
         double alpha =  * acos(cosM);
         double beta =  * acos(cosN);
         double TM = 0.5 * M.r * M.r * (alpha - sin(alpha));
         double TN = 0.5 * N.r * N.r * (beta - sin(beta));
         area = TM + TN;
     }
     else if(D <= M.r - N.r) {
         area = N.area();
     }
     return area;
 }

 int intersection(const Seg &s, const Circle &cir, Point &p1, Point &p2) {
     double angle = cosIncludeAngle(s.ed, cir.c, s.st);
     //double angle1 = cos(includedAngle(s.ed, cir.c, s.st));
     double B = dist(cir.c, s.st);
     double a = , b = - * B * angle, c = sqr(B) - sqr(cir.r);
     double delta = sqr(b) -  * a * c;
     if(sgn(delta) < ) return ;
     if(sgn(delta) == ) delta = ;
     double x1 = (-b - sqrt(delta)) / ( * a), x2 = (-b + sqrt(delta)) / ( * a);
     Vector v = (s.ed - s.st).unit();
     p1 = s.st + v * x1;
     p2 = s.st + v * x2;
     return  + sgn(delta);
 }

 double CommonArea(const Circle &cir, Point p1, Point p2) {
     if(p1 == cir.c || p2 == cir.c) return ;
     if(cir.contain(p1) && cir.contain(p2)) {
         return area(cir.c, p1, p2);
     } else if(!cir.contain(p1) && !cir.contain(p2)) {
         Point q1, q2;
         int t = intersection(Line(p1, p2), cir, q1, q2);
         if(t == ) {
             double angle = includedAngle(p1, p2, cir.c);
             return 0.5 * sqr(cir.r) * angle;
         } else {
             double angle1 = includedAngle(p1, p2, cir.c);
             double angle2 = includedAngle(q1, q2, cir.c);
             if(isInSegRec(Seg(p1, p2), q1))return 0.5 * sqr(cir.r) * (angle1 - angle2 + sin(angle2));
             else return 0.5 * sqr(cir.r) * angle1;
         }
     } else {
         if(cir.contain(p2)) swap(p1, p2);
         Point q1, q2;
         intersection(Line(p1, p2), cir, q1, q2);
         double angle = includedAngle(q2, p2, cir.c);
         double a = area(cir.c, p1, q2);
         double b = 0.5 * sqr(cir.r) * angle;
         return a + b;
     }
 }

 struct Triangle {
     Point p[];
     Triangle() {}
     Triangle(Point *t) {
         for(int i = ; i < ; ++i) p[i] = t[i];
     }
     void read() {
         for(int i = ; i < ; ++i) p[i].read();
     }
     double area() const {
         return ::area(p[], p[], p[]);
     }
     Point& operator[] (int i) {
         return p[i];
     }
 };

 double CommonArea(Triangle tir, const Circle &cir) {
     double ret = ;
     ret += sgn(cross(tir[], cir.c, tir[])) * CommonArea(cir, tir[], tir[]);
     ret += sgn(cross(tir[], cir.c, tir[])) * CommonArea(cir, tir[], tir[]);
     ret += sgn(cross(tir[], cir.c, tir[])) * CommonArea(cir, tir[], tir[]);
     return abs(ret);
 }

 struct Poly {
     int n;
     Point p[MAXN];//p[n] = p[0]
     void init(Point *pp, int nn) {
         n = nn;
         for(int i = ; i < n; ++i) p[i] = pp[i];
         p[n] = p[];
     }
     double area() {
         if(n < ) return ;
         double s = p[].y * (p[n - ].x - p[].x);
         for(int i = ; i < n; ++i)
             s += p[i].y * (p[i - ].x - p[i + ].x);
         return s / ;
     }
 };
 //the convex hull is clockwise
 void Graham_scan(Point *p, int n, int *stk, int &top) {//stk[0] = stk[top]
     sort(p, p + n);
     top = ;
     stk[] = ; stk[] = ;
     for(int i = ; i < n; ++i) {
         while(top && cross(p[i], p[stk[top]], p[stk[top - ]]) <= ) --top;
         stk[++top] = i;
     }
     int len = top;
     stk[++top] = n - ;
     for(int i = n - ; i >= ; --i) {
         while(top != len && cross(p[i], p[stk[top]], p[stk[top - ]]) <= ) --top;
         stk[++top] = i;
     }
 }
 //use for half_planes_cross
 bool cmpAg(const Line &a, const Line &b) {
     if(sgn(a.ag - b.ag) == )
         return sgn(cross(b.ed, a.st, b.st)) < ;
     return a.ag < b.ag;
 }
 //clockwise, plane is on the right
 bool half_planes_cross(Line *v, int vn, Poly &res, Line *deq) {
     int i, n;
     sort(v, v + vn, cmpAg);
     for(i = n = ; i < vn; ++i) {
         if(sgn(v[i].ag - v[i-].ag) == ) continue;
         v[n++] = v[i];
     }
     int head = , tail = ;
     deq[] = v[], deq[] = v[];
     for(i = ; i < n; ++i) {
         if(isParallel(deq[tail - ], deq[tail]) || isParallel(deq[head], deq[head + ]))
             return false;
         while(head < tail && sgn(cross(v[i].ed, deq[tail - ] * deq[tail], v[i].st)) > )
             --tail;
         while(head < tail && sgn(cross(v[i].ed, deq[head] * deq[head + ], v[i].st)) > )
             ++head;
         deq[++tail] = v[i];
     }
     while(head < tail && sgn(cross(deq[head].ed, deq[tail - ] * deq[tail], deq[head].st)) > )
         --tail;
     while(head < tail && sgn(cross(deq[tail].ed, deq[head] * deq[head + ], deq[tail].st)) > )
         ++head;
     if(tail <= head + ) return false;
     res.n = ;
     for(i = head; i < tail; ++i)
         res.p[res.n++] = deq[i] * deq[i + ];
     res.p[res.n++] = deq[head] * deq[tail];
     res.n = unique(res.p, res.p + res.n) - res.p;
     res.p[res.n] = res.p[];
     return true;
 }

 //ix and jx is the points whose distance is return, res.p[n - 1] = res.p[0], res must be clockwise
 double dia_rotating_calipers(Poly &res, int &ix, int &jx) {
     double dia = ;
     int q = ;
     for(int i = ; i < res.n - ; ++i) {
         while(sgn(cross(res.p[i], res.p[q + ], res.p[i + ]) - cross(res.p[i], res.p[q], res.p[i + ])) > )
             q = (q + ) % (res.n - );
         if(sgn(dist(res.p[i], res.p[q]) - dia) > ) {
             dia = dist(res.p[i], res.p[q]);
             ix = i; jx = q;
         }
         if(sgn(dist(res.p[i + ], res.p[q]) - dia) > ) {
             dia = dist(res.p[i + ], res.p[q]);
             ix = i + ; jx = q;
         }
     }
     return dia;
 }
 //a and b must be clockwise, find the minimum distance between two convex hull
 double half_rotating_calipers(Poly &a, Poly &b) {
     int sa = , sb = ;
     for(int i = ; i < a.n; ++i) if(sgn(a.p[i].y - a.p[sa].y) < ) sa = i;
     for(int i = ; i < b.n; ++i) if(sgn(b.p[i].y - b.p[sb].y) < ) sb = i;
     double tmp, ans = dist(a.p[], b.p[]);
     for(int i = ; i < a.n; ++i) {
         while(sgn(tmp = cross(a.p[sa], a.p[sa + ], b.p[sb + ]) - cross(a.p[sa], a.p[sa + ], b.p[sb])) > )
             sb = (sb + ) % (b.n - );
         if(sgn(tmp) < ) ans = min(ans, Point_to_Seg(b.p[sb], Seg(a.p[sa], a.p[sa + ])));
         else ans = min(ans, Seg_to_Seg(Seg(a.p[sa], a.p[sa + ]), Seg(b.p[sb], b.p[sb + ])));
         sa = (sa + ) % (a.n - );
     }
     return ans;
 }

 double rotating_calipers(Poly &a, Poly &b) {
     return min(half_rotating_calipers(a, b), half_rotating_calipers(b, a));
 }
 //欧拉四面体公式AB, AC, AD, BC, BD, CD
 double area(double p, double q, double r, double n, double m, double l) {
     p *= p, q *= q, r *= r, n *= n, m *= m, l *= l;
     long double ret = ;
     ret += LD(p) * q * r;
     ret += LD(p + q - n) * (q + r - l) * (p + r - m) / ;
     ret -= LD(p + r - m) * q * (p + r - m) / ;
     ret -= LD(p + q - n) * (p + q - n) * r / ;
     ret -= LD(q + r - l) * (q + r - l) * p / ;
     return sqrt(ret / );
 }

 /*******************************************************************************************/

 Point p[MAXN];
 Circle cir;
 double r;
 int n;

 int main() {
     double p, q, r, n, m, l;
     while(cin>>p>>q>>r>>n>>m>>l) {
         printf("%.4f\n", area(p, q, r, n, m, l));
     }
 }