三维凸包求内部一点到表面的最近距离（HDU4266）

http://acm.hdu.edu.cn/showproblem.php?pid=4266

The Worm in the Apple

Time Limit: 50000/20000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 547    Accepted Submission(s): 252

Problem Description

Willy the Worm was living happily in an apple – until some vile human picked the apple, and started to eat it! Now, Willy must escape!

Given a description of the apple (defined as a convex shape in 3D space), and a list of possible positions in the apple for Willy (defined as 3D points), determine the minimum distance Willy must travel to get to the surface of the apple from each point.

 

Input

There will be several test cases in the input. Each test case will begin with a line with a single integer
n (4≤n≤1,000), which tells the number of points describing the apple.

On the next n lines will be three integers x,
y and z (-10,000≤x,y,z≤10,000), where each point (x,y,z) is either on the surface of, or within, the apple. The apple is the convex
hull of these points. No four points will be coplanar.

Following the description of the apple, there will be a line with a single integer
q (1≤q≤100,000), which is the number of queries – that is, the number of points where Willy might be inside the apple. Each of the following
q lines will contain three integers x,
y and z (-10,000≤x,y,z≤10,000), representing a point (x,y,z) where Willy might be. All of Willy’s points are guaranteed to be inside
the apple. The input will end with a line with a single 0.

 

Output

For each query, output a single floating point number, indicating the minimum distance Willy must travel to exit the apple. Output this number with exactly 4 decimal places of accuracy, using standard 5 up / 4 down rounding (e.g.
2.12344 rounds to 2.1234, 2.12345 rounds to 2.1235). Output each number on its own line, with no spaces, and do not print any blank lines between answers.

 

Sample Input

6
0 0 0
100 0 0
0 100 0
0 0 100
20 20 20
30 20 10
4
1 1 1
30 30 35
7 8 9
90 2 2
0

 

Sample Output

1.0000
2.8868
7.0000
2.0000

 题意：有个虫子生活在一个多面体苹果里面，给出这个苹果的顶点，问这个虫子爬出苹果的最短距离是多少？

分析：点到面的最短距离（暴力枚举改点和所有凸面的距离）

#include"stdio.h"
#include"string.h"
#include"iostream"
#include"map"
#include"string"
#include"queue"
#include"stack"
#include"vector"
#include"stdlib.h"
#include"algorithm"
#include"math.h"
#define M 1009
#define eps 1e-10
#define inf 0x3f3f3f3f
#define mod 1070000009
#define PI acos(-1.0)
using namespace std;
struct node
{
    double x,y,z,dis;
    node(){}
    node(double xx,double yy,double zz):x(xx),y(yy),z(zz){}
    node operator +(const node p)//向量间求和操作
    {
        return node(x+p.x,y+p.y,z+p.z);
    }
    node operator -(const node p)//向量间相减操作
    {
        return node(x-p.x,y-p.y,z-p.z);
    }
    node operator *(const node p)//向量间叉乘操作
    {
        return node(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
    }
    node operator *(const double p)//向量乘以一个数
    {
        return node(x*p,y*p,z*p);
    }
    node operator /(const double p)//向量除以一个数
    {
        return node(x/p,y/p,z/p);
    }
    double operator ^(const node p)//向量间点乘操作
    {
        return x*p.x+y*p.y+z*p.z;
    }
};
struct threeD_convex_hull//三维凸包
{
    struct face
    {
        int a,b,c;
        int ok;
    };
    int n;//初始点数
    int cnt;//凸包三角形数
    node p[M];//初始点
    face f[M*8];//凸包三角形
    int to[M][M];//点i到j是属于哪个面
    double len(node p)//向量的长度
    {
        return sqrt(p.x*p.x+p.y*p.y+p.z*p.z);
    }
    double area(node a,node b,node c)//三个点的面积*2
    {
        return len((b-a)*(c-a));
    }
    double volume(node a,node b,node c,node d)//四面体面积*6
    {
        return (b-a)*(c-a)^(d-a);
    }
    double ptof(node q,face f)//点与面同向
    {
        node m=p[f.b]-p[f.a];
        node n=p[f.c]-p[f.a];
        node t=q-p[f.a];
        return m*n^t;
    }
    void dfs(int q,int cur)//维护凸包，若点q在凸包外则更新凸包
    {
        f[cur].ok=0;//删除当前面，因为此时它在更大的凸包内部
        deal(q,f[cur].b,f[cur].a);
        deal(q,f[cur].c,f[cur].b);
        deal(q,f[cur].a,f[cur].c);
    }
    //因为每个三角形的的三边是按照逆时针记录的，所以把边反过来后对应的就是与ab边共线的另一个面
    void deal(int q,int a,int b)
    {
        int fa=to[a][b];//与当前面cnt共边的另一个面
        face add;
        if(f[fa].ok)//若fa面目前是凸包的表面则继续
        {
            if(ptof(p[q],f[fa])>eps)//若点q能看到fa面继续深搜fa的三条边，更新新的凸包面
                dfs(q,fa);
            else//当q点可以看到cnt面的同时看不到a，b共边的fa面，则p和a，b点组成一个新的表面三角形
            {
                add.a=b;
                add.b=a;
                add.c=q;
                add.ok=1;
                to[b][a]=to[a][q]=to[q][b]=cnt;
                f[cnt++]=add;
            }
        }
    }
    int same(int s,int t)//判断两个三角形是否共面
    {
        node a=p[f[s].a];
        node b=p[f[s].b];
        node c=p[f[s].c];
        if(fabs(volume(a,b,c,p[f[t].a]))<eps
           &&fabs(volume(a,b,c,p[f[t].b]))<eps
           &&fabs(volume(a,b,c,p[f[t].c]))<eps)
            return 1;
        return 0;
    }
    void make()//构建3D凸包
    {
        cnt=0;
        if(n<4)
            return;
        int sb=1;
        for(int i=1;i<n;i++)//保证前两个点不共点
        {
            if(len(p[0]-p[i])>eps)
            {
                swap(p[1],p[i]);
                sb=0;
                break;
            }
        }
        if(sb)return;
        sb=1;
        for(int i=2;i<n;i++)//保证前三个点不共线
        {
            if(len((p[1]-p[0])*(p[i]-p[0]))>eps)
            {
                swap(p[2],p[i]);
                sb=0;
                break;
            }
        }
        if(sb)return;
        sb=1;
        for(int i=3;i<n;i++)//保证前四个点不共面
        {
            if(fabs(volume(p[0],p[1],p[2],p[i]))>eps)
            {
                swap(p[3],p[i]);
                sb=0;
                break;
            }
        }
        if(sb)return;
        face add;
        for(int i=0;i<4;i++)//构建初始四面体
        {
            add.a=(i+1)%4;
            add.b=(i+2)%4;
            add.c=(i+3)%4;
            add.ok=1;
            if(ptof(p[i],add)>eps)
                swap(add.c,add.b);
            to[add.a][add.b]=to[add.b][add.c]=to[add.c][add.a]=cnt;
            f[cnt++]=add;
        }
        for(int i=4;i<n;i++)//倍增法更新凸包
        {
            for(int j=0;j<cnt;j++)//判断每个点是在当前凸包的内部或者外部
            {
                if(f[j].ok&&ptof(p[i],f[j])>eps)//若在外部且看到j面继续
                {
                    dfs(i,j);
                    break;
                }
            }
        }
        int tmp=cnt;//把不是凸包上的面删除即ok=0；
        cnt=0;
        for(int i=0;i<tmp;i++)
            if(f[i].ok)
            f[cnt++]=f[i];
    }
    double Area()//表面积
    {
        double S=0;
        if(n==3)
        {
            S=area(p[0],p[1],p[2])/2.0;
            return S;
        }
        for(int i=0;i<cnt;i++)
            S+=area(p[f[i].a],p[f[i].b],p[f[i].c]);
        return S/2.0;
    }
    double Volume()//体积
    {
        double V=0;
        node mid(0,0,0);
        for(int i=0;i<cnt;i++)
            V+=volume(p[f[i].a],p[f[i].b],p[f[i].c],mid);
        V=fabs(V)/6.0;
        return V;
    }
    int tringleCnt()//凸包表面三角形数目
    {
        return cnt;
    }
    int faceCnt()//凸包表面多边形数目
    {
        int num=0;
        for(int i=0;i<cnt;i++)
        {
            int flag=1;
            for(int j=0;j<i;j++)
            {
                if(same(i,j))
                {
                    flag=0;
                    break;
                }
            }
            num+=flag;
        }
        return num;
    }
    double pf_dis(face f,node q)//点到面的距离
    {
        double V=volume(p[f.a],p[f.b],p[f.c],q);
        double S=area(p[f.a],p[f.b],p[f.c]);
        return fabs(V/S);
    }
    double min_dis(node q)//暴力搜索内部的点q到面的最短距离即体积/面积
    {
        double mini=inf;
        for(int i=0;i<cnt;i++)
        {
            double h=pf_dis(f[i],q);
            if(mini>h)
                mini=h;
        }
        return mini;
    }
    node barycenter()//凸包的重心
    {
        node ret(0,0,0),mid(0,0,0);
        double sum=0;
        for(int i=0;i<cnt;i++)
        {
            double V=volume(p[f[i].a],p[f[i].b],p[f[i].c],mid);
            ret=ret+(mid+p[f[i].a]+p[f[i].b]+p[f[i].c])/4.0*V;
            sum+=V;
        }
        ret=ret/sum;
        return ret;
    }
 
}hull;
int main()
{
    while(scanf("%d",&hull.n),hull.n)
    {
        for(int i=0;i<hull.n;i++)
            scanf("%lf%lf%lf",&hull.p[i].x,&hull.p[i].y,&hull.p[i].z);
        hull.make();
        int m;
        scanf("%d",&m);
        while(m--)
        {
            node q;
            scanf("%lf%lf%lf",&q.x,&q.y,&q.z);
            printf("%.4lf\n",hull.min_dis(q));
        }
    }
    return 0;
}